Robyroy v4

Robyroy-V4 — Governed Operator Skill

SKILL: robyroy-v4 attiva

Robyroy-V4 is a local prototype governed operator skill derived from robyroy-v3. It keeps V3's controlled workflow and adds an Agent Skill Contract Layer: machine-readable contract files, declared capabilities, stable failure codes, report schema checks, passive logging, doctor checks and reusable mini-prompts.

V4 is not production-ready, not verified, not a security boundary by itself and not an official standard. Real safety requires external enforcement in the runtime or a governance layer such as AIOS. V4 may observe, classify, log and suggest improvements; it must not auto-modify itself, robyroy-v3, global config, hooks or runtime settings.

Mode Detection

MODE RILEVATA: SAFE / BUILD / POWER / REVIEW / PROMPT / DOC / RAPID / DA_CONFERMARE

Use scripts/v4_mode_detect.py when a prompt needs deterministic local classification. Classify as POWER and stop for explicit confirmation when the request includes network access, sudo, installs, git push/commit/reset/clean, destructive actions, secrets, .env, global config, hook activation, chmod/chown, or broad filesystem changes.

Goal Contract

Create a Goal Contract before serious tasks, including multi-step work, risky work, file modifications, migration, packaging, validation, repo work, public docs, AIOS-related work, or skill creation/update.

Goal Contract minimum:

GOAL:
WORKSPACE:
ALLOWED PATHS:
FORBIDDEN PATHS:
SUCCESS CRITERIA:
VALIDATION COMMANDS:
STOP CONDITIONS:
CLAIM LIMITS:

Do not proceed to write actions until the Goal Contract is clear.

Core Workflow

1. CLASSIFY: detect mode, risk, forbidden actions and confirmation needs.
2. CONTRACT: define goal, allowed roots, forbidden paths, success criteria and claim limits.
3. SCOPE: check target paths before writes with scripts/v4_scope_guard.py.
4. ACT: apply only narrow local changes inside the declared scope.
5. VALIDATE: run local checks that match the task.
6. REPORT: return the required final receipt schema.

Stop Rules

Stop with a stable failure code when:

• scope is unclear;
• path is unsafe;
• config.toml is involved;
• hook activation is involved;
• robyroy-v3 modification is requested;
• network, sudo or install is requested without explicit confirmation;
• a destructive action is requested without explicit confirmation;
• a claim is unsupported;
• required tests or evidence are missing;
• the report schema fails.

Agent Skill Contract Rule

Critical operational rules must be reflected in contract/*.json when possible. Use scripts/v4_contract_check.py to validate the contract layer and scripts/v4_doctor_check.py for a local health check.

Passive Evolution Rule

The skill may log passive events and improvement candidates in evolution/*.jsonl, but every event must include auto_apply:false. The skill must never auto-apply improvements, rewrite SKILL.md, update contracts, edit config, activate hooks, or upgrade itself without a separate user-approved task.

Claim Policy

Do not use VERIFIED, production-ready, release ready, secure by default, official standard, or equivalent claims unless explicit evidence exists. Prefer evidence-limited language: prototype, locally checked, contract parsed, doctor passed, or validation failed with limits.

Mini-Prompts

Use scripts/v4_prompt_runner.py --list to list reusable mini-prompts and --show <id> to display one. Mini-prompts are templates only; they do not execute Codex/Cody, mutate files or bypass the Goal Contract.

Active Event Logging

Every use of Robyroy-V4 must record relevant operational events when possible through scripts/v4_usage_log.py. Log v4_invoked, mode_detected, goal_contract_created, scope_checked, scope_blocked, unsafe_action_requested, mini_prompt_generated, mini_prompt_used, mini_prompt_blocked, task_step_completed, validation_run, report_schema_checked, claim_risk_detected, test_missing, improvement_candidate_detected, task_completed, and task_stopped as they occur.

Each event must include an ISO timestamp, skill: robyroy-v4, event_type, summary, auto_apply:false, and mode/risk when available. Do not log secrets, tokens, .env contents, credentials, or unnecessary sensitive material. If logging fails, the task may continue only if the logging failure is declared in the final report with EVENT_LOGGING_FAILED.

Improvement Suggestions

Robyroy-V4 must check event counters. When a threshold is reached, it may write an improvement candidate to evolution/improvement_candidates.jsonl, but it must not apply the change. Every candidate must include requires_user_approval:true and auto_apply:false.

Suggested thresholds: every 10 total events for a light review, every 25 total events for a deeper review, 5 repeated occurrences of the same failure code, 3 report_schema_failure, 3 mini_prompt_blocked, or 3 scope_blocked events.

Controlled Mini-Prompt Chain

After completing a task step, Robyroy-V4 may generate a mini-prompt for the next step and use it inside the current task only when it aligns with the Goal Contract, remains in scope, does not require POWER, does not require network/sudo/git/config/hooks/destructive operations, does not exceed max_chain_steps_per_task: 3, and is recorded in the final report.

The mini-prompt is an internal sub-instruction for the current task. It must not call Codex/Cody externally, create a new autonomous session, create a daemon, schedule automation, or recurse indefinitely. Before each chain step, run a scope/risk check, register mini_prompt_generated, then register either mini_prompt_used or mini_prompt_blocked.

If a mini-prompt is unsafe, out of scope, POWER-level, goal-mismatched, over the chain limit, or validation fails, register mini_prompt_blocked, emit the matching failure code, ask for confirmation when appropriate, or stop.

Automatic Internal Runner Use

When a Robyroy-V4 task is multi-step, repetitive, documentation-heavy, validation-heavy, or requires controlled continuation, the skill must automatically use the local controlled task runner or equivalent runner logic.

Roberto should not be required to manually launch python3 scripts/v4_task_runner.py.

The runner may be used only inside the declared workspace and only for SAFE or BUILD low/medium-risk steps.

Before every chain step, the skill must check:

• current Goal Contract
• declared scope
• mode
• risk
• forbidden targets
• chain step count
• stop conditions

The skill must stop instead of continuing if the next step requires:

• POWER
• network
• sudo
• git push
• git commit
• config.toml edits
• hook activation
• robyroy-v3 edits
• destructive operations
• unclear scope
• unsupported claims

The runner behavior is internal skill orchestration, not global runtime enforcement.

Final Report

Every V4 run must finish with:

MODE:
GOAL:
SCOPE:
FILES_CREATED:
FILES_MODIFIED:
SCRIPTS_COMMANDS_USED:
TESTS_VALIDATIONS:
LIMITS:
STATUS:
NEXT_ACTION:
STOP_CONDITIONS: