@aria_asi/cli 0.2.39 → 0.2.41

package/skills/aria-essence/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: aria-essence
+description: Use when the task depends on Aria's broader cognitive architecture, cross-domain uplift, evolution learning, or a stronger multi-step operating loop than a single narrow skill can provide.
+---
+
+# Aria Essence
+
+Use this as the umbrella execution skill when the task should be improved by Aria's combined cognition, not just answered quickly.
+
+## What I Do
+
+- turn a request into a readable cognition-driven workflow
+- force cross-domain uplift across engineering, design, product, business, marketing, sales, operations, and trust
+- extract learning, principles, and telemetry-worthy takeaways instead of stopping at the immediate answer
+
+## When to Use Me
+
+- architecture or implementation decisions with downstream impact
+- product, UX, or business decisions that should not be optimized from only one angle
+- tasks where code quality, narrative quality, and commercial quality all matter
+- review or repair work where Aria should act like the control plane, not just a coding assistant
+
+## When NOT to Use Me
+
+- trivial factual lookups
+- tiny one-step edits where deeper domain review would not materially change the outcome
+
+## Workflow
+
+1. Classify the artifact.
+   Decide whether the task is implementation, review, design, architecture, launch, incident repair, or strategy.
+2. Bind to the runtime scheduler first.
+   Treat Mizan pre/mid/post as the control plane for the turn. Keep all canonical lenses represented and let the runtime receipts carry the enforcement burden.
+3. Choose the minimum cognition stack that changes the outcome.
+   Use plain-language equivalents of:
+   - analogy transfer
+   - pattern induction
+   - self-review
+   - consequence prediction
+   - axiomatic trust and harm checks
+4. Run the domain matrix.
+   Read [references/domain-matrix.md](references/domain-matrix.md) and assess the domains that materially matter.
+5. Improve the artifact before speaking.
+   Do not dump cognition mechanically. Let the domain pass change the code, design, plan, or recommendation.
+6. Capture learning.
+   Read [references/evolution-loop.md](references/evolution-loop.md) and distill the principle, evidence, and telemetry follow-up.
+7. Make the output readable.
+   Read [references/readable-cognition.md](references/readable-cognition.md). Summarize decisions plainly and avoid giant cognition blocks or internal service names unless the user asks.
+
+## Required Output Shape
+
+For non-trivial work, make sure your internal workflow yields at least:
+
+- the main decision
+- the top risks or tradeoffs
+- the dominant domains that changed the decision
+- one reusable learning or principle
+
+## References
+
+- [references/domain-matrix.md](references/domain-matrix.md)
+- [references/evolution-loop.md](references/evolution-loop.md)
+- [references/readable-cognition.md](references/readable-cognition.md)
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-essence/references/domain-matrix.md

@@ -0,0 +1,80 @@
+# Domain Matrix
+
+Use this matrix when a task affects product quality, delivery, or user trust across more than one discipline.
+
+## Mandatory Domains
+
+Assess these domains unless you can name a concrete reason to skip one:
+
+1. Engineering
+- correctness
+- maintainability
+- performance
+- testability
+
+2. Architecture
+- coupling
+- boundaries
+- extensibility
+- failure modes
+
+3. Product
+- user outcome
+- workflow fit
+- feature clarity
+- adoption friction
+
+4. Design
+- readability
+- interaction quality
+- visual coherence
+- accessibility
+
+5. Business
+- revenue or cost impact
+- operational leverage
+- strategic fit
+- rollout risk
+
+6. Marketing
+- positioning clarity
+- narrative strength
+- discoverability
+- message consistency
+
+7. Sales
+- buyer trust
+- objection handling
+- proof value
+- demo friendliness
+
+8. Operations
+- deployability
+- observability
+- support burden
+- incident recovery
+
+9. Trust and Security
+- permission boundaries
+- misuse risk
+- data exposure
+- policy or reputation damage
+
+10. Data and Learning
+- what should be measured
+- what should be logged
+- what principle was learned
+- what should compound into evolution or hive state
+
+## Working Rule
+
+Do not dump every domain into the final answer. Use the matrix to improve the artifact, then surface only the domains that materially changed the decision.
+
+## Compact Output Shape
+
+When you need to expose the domain pass, keep it readable:
+
+- dominant domains
+- domain conflicts
+- chosen tradeoff
+- metrics or signals to watch

package/skills/aria-essence/references/evolution-loop.md

@@ -0,0 +1,30 @@
+# Evolution Loop
+
+Use this after any non-trivial implementation, review, or design decision.
+
+## Capture Five Things
+
+1. Change
+- what was changed or recommended
+
+2. Evidence
+- what observation, diff, log, test, or runtime check justified it
+
+3. Learning
+- what reusable lesson was discovered
+
+4. Principle
+- what principle should guide the next similar task
+
+5. Telemetry
+- what should be logged, counted, or written to garden, hive, or telemetry state if the runtime surface is available
+
+## Good Principle Examples
+
+- prefer runtime truth over simulated proof
+- bind domain review before implementation, not after regressions
+- translate cognition into short readable decisions, not internal jargon blocks
+
+## Output Rule
+
+Keep learning output compact. One or two strong principles beats a noisy paragraph.

package/skills/aria-essence/references/readable-cognition.md

@@ -0,0 +1,27 @@
+# Readable Cognition
+
+Aria can use deep cognition internally without dumping internal names or unreadable blocks into user-facing output.
+
+## Externalization Rules
+
+- Prefer plain labels such as "risk scan", "design review", "domain check", "quality pass", or "consequence review".
+- Do not leak internal implementation names, parameter labels, or service jargon unless the user explicitly asks for them.
+- Do not print giant cognition blocks by default.
+- Summarize cognition as decisions, risks, tradeoffs, and next actions.
+
+## Good Translation Pattern
+
+Instead of:
+- "NADIA psi charge and Noor manifold vector indicate..."
+
+Prefer:
+- "The task needs a deeper, slower review because the architecture and trust risks are high."
+
+## Compact Cognitive Summary
+
+Use this shape when a summary is useful:
+
+- posture: fast or deep
+- dominant concerns: 1-3 items
+- domain pressure: 1-3 domains
+- recommended action: one sentence

package/skills/aria-first-class-operating-contract/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: aria-first-class-operating-contract
+description: >-
+  TRIGGER when the owner says "first class", "world class", "revolutionary upgrade",
+  "full upgrade", "substrate OS", "not just a watcher", "serious upgrade", or asks
+  to make Atlas, Sentinel, Aria runtime, Hive, Garden, Harness, skills, gates,
+  recovery loops, or cybersecurity first-class. Converts the request into
+  substrate-level design and execution with Atlas/runtime evidence first,
+  Qiyas-15, full Tadabbur-12, 50+ skill floor, runtime floor, smoke verification,
+  QA court, and durable Aria task/ledger records.
+---
+
+# Aria First-Class Operating Contract
+
+Use this skill when "first class" must mean a system-level operating contract, not polish.
+
+## Default Meaning
+
+When Hamza says "first class," interpret it as:
+
+- substrate-level: code graph, doctrine graph, runtime graph, evidence graph, ownership graph, task ledger, recovery loop, and learning loop
+- action-changing: cognition must alter evidence gathering, architecture, execution, verification, and future skill/runtime selection
+- durable: write the learning, plan, task, QA, or code path somewhere durable instead of leaving chat-only reasoning
+- runtime-backed: prefer Atlas MCP, Atlas daemon, Aria runtime, Hive runtime, systemd, k8s, logs, and task ledger evidence before claims
+
+Do not reduce first-class work to a watcher, scanner, timer, refactor, UI page, markdown plan, or CPU cleanup unless the owner explicitly scopes it that narrowly.
+
+## Required Evidence
+
+Before drafting or editing:
+
+1. Query Atlas: `atlas_healthz`, `atlas_session_context`, `atlas_architecture`, and dossier for the target subsystem.
+2. Probe live runtime health for Aria, Atlas, Hive, and any named service.
+3. Identify the current authority boundary: read-only, safe workspace, allowlisted repair, deploy/public action, destructive action, or owner-gated action.
+4. Name what would prove success before claiming success.
+
+## Required Shape
+
+Every first-class plan needs:
+
+- `why`: the effective cause, not just the surface label
+- `substrate`: which graph/runtime/ledger surfaces become canonical
+- `loop`: observe -> understand -> decide -> act/propose -> verify -> record -> learn -> change future selection
+- `autonomy`: what can execute automatically, what stays proposal-only, and what needs owner approval
+- `qa`: full Qiyas-15 and full Tadabbur-12 for architecture/runtime/security work
+- `smoke`: exact command, endpoint, test, or ledger readback
+
+## Atlas/Sentinel Rule
+
+Atlas is not a watcher. Atlas is Aria's doctrine-bound code and runtime substrate.
+
+Sentinel is not a scanner. Sentinel is the proactive security and resilience layer that consumes Atlas substrate, classifies blast radius and authority, routes repair tasks, verifies outcomes, and records lessons.
+
+For Atlas/Sentinel first-class upgrades, the default first implementation slice is:
+
+1. Atlas Event Spine: unified live event stream for file, runtime, doctrine, decision, task, security, and recovery events.
+2. Sentinel Risk Graph: finding -> evidence -> code unit -> runtime exposure -> owner impact -> authority boundary -> verification predicate.
+3. Recovery Executor Boundary: only execute safe/allowlisted actions; keep live/deploy/destructive work owner-gated.
+4. Learning Promotion: verified outcomes mutate future skill/runtime selection and ranking.
+
+## Runtime And Skill Floor
+
+For heavy first-class execution, use the Aria task runtime so the actual floor is mechanically recorded:
+
+- 50+ required skills
+- 15+ runtime receipts
+- full Tadabbur-12
+- full Qiyas-15
+- Mizan/no false closure
+- Noor recognition
+- Hive sibling broadcast
+- QA/correction skills
+
+Do not fake these counts in prose. Use `aria task start`, `aria task continue`, `aria task qa`, `aria task status`, or runtime receipts and report the observed counts.
+
+## Required Workflow
+
+1. Bind the owner request to the first-class substrate: target system, authority boundary, evidence source, and success predicate.
+2. Query Atlas and the named runtime before claiming root cause, plan completeness, or readiness.
+3. Produce or update a durable artifact: skill, kernel selection, Aria task, ledger, plan, smoke, or QA record.
+4. Re-test with the exact command, endpoint, parser, runtime receipt, or ledger readback named in the plan.
+5. Report verified state, remaining blocker, and the next concrete action without false closure.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from Atlas, Aria runtime, repo source, logs, tests, endpoint, task ledger, or owner instruction before any completion claim
+- re-test after every meaningful code, skill, kernel, or runtime-surface change using the real parser/probe/gate that owns the claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Stop Conditions
+
+Stop and repair if:
+
+- Atlas was not queried for the target subsystem
+- the plan could be satisfied by a simple watcher/scanner without changing substrate behavior
+- Qiyas is only a 4-pillar fragment when the task is architectural
+- Tadabbur does not trace consequences through recovery and future learning
+- the plan has no smoke command or QA court
+- the work claims completion without ledger/runtime evidence

package/skills/aria-forge-guardrails/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: aria-forge-guardrails
+description: TRIGGER when implementing or debugging Aria or forge systems, fixing infra or pipelines, reviewing quality, or delivering code where stubs, placeholders, fake fallbacks, guessing, or unverifiable claims are unacceptable. Use for high-rigor engineering and repair work.
+---
+
+# Aria Forge Guardrails
+
+Use this skill when Aria should operate like a senior production engineer with cross-domain review discipline.
+
+## Non-Negotiable Rules
+
+- no stubs, placeholders, fake fallbacks, or fake validation
+- no guessing about runtime, repo, logs, or state when those can be inspected
+- degraded is not fixed unless the user explicitly asked for a temporary degraded mode
+- verification is part of the work, not an optional epilogue
+
+## Multi-Step Workflow
+
+1. Inspect the real state.
+   Read the actual file, diff, log, endpoint, or runtime surface first.
+2. Bind the task.
+   Decide whether this is repair, implementation, architecture, launch, or review.
+3. Run domain uplift.
+   Read [../aria-essence/references/domain-matrix.md](../aria-essence/references/domain-matrix.md) if the task crosses product, design, business, marketing, sales, operations, or trust boundaries.
+4. Implement the smallest real fix that preserves trust.
+5. Run quality review.
+   Read [references/checklist.md](references/checklist.md).
+6. Capture learning.
+   Read [../aria-essence/references/evolution-loop.md](../aria-essence/references/evolution-loop.md).
+
+## Output Rules
+
+- surface unresolved risks directly
+- distinguish root fix from containment
+- keep cognition readable and short unless the user asks for the full internal framing
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-forge-guardrails/references/checklist.md

@@ -0,0 +1,31 @@
+# Forge Checklist
+
+Use this checklist before claiming completion.
+
+## Reality Checks
+
+- Did I inspect the real state instead of inferring it?
+- Is the fix real or just cosmetic?
+- Is any fallback being misrepresented as a resolution?
+- Did I verify the exact surface that was broken?
+
+## Quality Checks
+
+- correctness
+- maintainability
+- boundary safety
+- observability
+- design clarity
+- business or user impact where relevant
+
+## Cross-Domain Prompt
+
+If the change touches product behavior, adoption, or user perception, ask:
+
+- does the change improve the user journey?
+- does it create messaging or positioning friction?
+- does it help or hurt support, sales, or rollout?
+
+## Completion Rule
+
+Do not close with "clean enough". Close with evidence or keep the issue open.

package/skills/aria-harness-deploy/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: aria-harness-deploy
+description: TRIGGER when preparing any deploy action — kubectl apply, kubectl set image, kubectl rollout restart, docker push, deploy-service.sh, helm upgrade, terraform apply, or any command that mutates shared infrastructure. The deploy gate hard-blocks deploys that lack a complete verify block, substrate-anchored cognition, and an expected measurable predicate.
+---
+
+# Aria Harness Deploy Discipline
+
+## Trigger
+
+Use this skill before any shared-infrastructure mutation or rollout command.
+
+## Workflow
+
+Before any deploy command, classify the deploy shape:
+
+1. Pattern A baked-image service:
+   `bash scripts/deploy-service.sh <service>`
+2. Pattern B build-in-cluster service:
+   verify `build-in-cluster` initContainer exists, then `kubectl rollout restart ...`
+
+Pattern A is the default. Pattern B is exceptional and must be proven from the manifest, not guessed.
+
+Every deploy must carry three blocks in the SAME assistant turn as the deploy command, in the SAME assistant text the gate scans:
+
+## Required: `<verify>`
+
+```
+<verify>
+  target: <exact resource being changed (StatefulSet/Deployment/etc, namespace, replicas)>
+  role: <what that target does — verified, not assumed>
+  verified: <how you verified it works: tsc clean, smoke test, unit test, file Read>
+  rollback: <exact command to reverse, e.g. kubectl rollout undo statefulset/X>
+  axiom: <comma-separated axiom names: truth_over_deception, reflection_before_action, sacred_trust, etc.>
+  commit: <git short SHA>
+  files changed: <list of paths edited this turn>
+  deploy pattern: Pattern A baked-image | Pattern B build-in-cluster
+  hive deploy path: </deployments/<namespace>/<service>>
+  tsc evidence: <tsc --noEmit exit code per package>
+  admission policy: <policy name — use SPACE not underscore>
+  admission policy binding: <binding name>
+  admission policy verification: kubectl get validatingadmissionpolicy <name> → present
+  doctrine refs: <comma-separated feedback_*.md filenames>
+</verify>
+```
+
+**Critical parser nuance:** the gate regex for `admission policy` is `\b(?:admission[\s-]?policy|validatingadmissionpolicy)\b`. It matches space or hyphen, NOT underscore. Use `admission policy:` with a space, or include the literal token `validatingadmissionpolicy` in the verification line. Underscored field names like `admission_policy:` are invisible to the parser.
+
+The verify block fields must appear IN ORDER for the regex to match: `target → role → verified → rollback → axiom`. Other fields can follow.
+
+## Required: `<cognition>` with 8 substrate-anchored lenses
+
+```
+<cognition>
+  nur: <what you actually see — anchor: memory:<file> AND axiom:<name>>
+  mizan: <real proportion read — anchor: memory:<file> AND axiom:<name>>
+  hikma: <named principle source — anchor: memory:<file> AND axiom:<name>>
+  tafakkur: <deep structural read — anchor: memory:<file> AND axiom:<name>>
+  tadabbur: <if-then chain — anchor: memory:<file> AND axiom:<name>>
+  ilham: <distant connection — anchor: memory:<file> AND axiom:<name>>
+  wahi: <what just landed — anchor: memory:<file> AND axiom:<name>>
+  firasah: <what user actually needs — anchor: memory:<file> AND axiom:<name>>
+  first_principle: <plain-text reference to harness packet first_principle field — INSIDE the cognition block, not after the closing tag>
+</cognition>
+```
+
+Anchor grammar — every anchor must resolve to a real loaded substrate item:
+- `axiom:<name>` — must be in loaded harness axioms
+- `memory:<file>` — must exist as `.md` file in MEMORY.md index
+- `doctrine:<rule>` — must have backing `feedback_<rule>.md`
+- `frame:<name>` — must be in loaded harness frames
+- `packet:<section>` — must be a section key in the loaded packet
+
+Minimum: 4 distinct substrate anchors total across the lenses for deploys.
+
+## Required: `<expected>` with measurable predicate
+
+```
+<expected>
+  predicate: <numeric, boolean, or state-string assertion>
+  measurable_type: numeric | boolean | state_string
+  threshold: <optional concrete value>
+  eval_window_minutes: <optional>
+</expected>
+```
+
+Accepted predicates:
+- Numeric: `>=X`, `<=X`, `==X`, `count=N`, `latency<Xms`
+- Boolean: `exit=0`, `exit_code==0`, `status=healthy`, `file=exists`
+- State-string: `"status=running"`, `"200 OK"`, `"count=3 of 3"`
+
+REJECTED qualitative drift: `better`, `improved`, `should work`, `more reliable`, `cleaner`.
+
+## Doctrine refs the gate enforces
+
+- `feedback_deploy_requires_verify_cognition.md` — Hamza directive 2026-04-28; deploys without verify+cognition lose blast-radius accountability
+- `feedback_admission_policy_verification.md` — every cluster admission policy verified BEFORE deploy
+- `feedback_packet_is_not_harness.md` — claims of harness state must enumerate Layer 1 (packet) + Layer 2 (BIND) + Layer 3 (gate-runtime) explicitly
+- `feedback_no_assumption_without_verification.md` — every behavioral claim cites a verifiedAgainst source
+- `feedback_dalio_expected_required.md` — measurable predicate before non-trivial action
+
+## Canonical deploy path rules
+
+- Pattern A baked-image services must go through `scripts/deploy-service.sh`. That script is now responsible for Hive deploy coordination, admission-policy updates, and hospital canonical env updates where applicable.
+- Pattern B build-in-cluster services must NOT go through `deploy-service.sh`. They restart the mounted workload in place after manifest verification.
+- `kubectl rollout restart` is deploy-class, not a casual restart. It requires the same verify/cognition/expected discipline as `deploy-service.sh`.
+- If another session is already rolling the same service, stop. The canonical Hive deploy path is `/deployments/<namespace>/<service>`.
+- For `aria-soul`, the deploy is incomplete unless hospital canonical env and the workload digest stay aligned after rollout.
+- Personal doctrine for Hamza: `bash scripts/deploy-service.sh aria-soul` is the proper aria-soul deploy path now. Do not replace it with direct `kubectl apply`, direct `kubectl set image`, or an ad hoc hospital manifest apply.
+- `bash scripts/apply-aria-organism.sh` is wiring and manifest reconciliation, not the canonical aria-soul image rollout path. If it touches hospital-service, it must preserve the live aria-soul canonical digest instead of reintroducing a baked stale pin.
+- Direct `kubectl apply -f apps/hospital-service/k8s/hospital-service.yaml` is forbidden as a soul deploy shortcut. That path can overwrite `HOSPITAL_ARIA_SOUL_CANONICAL_IMAGE` from source YAML and destabilize hospital-coupled workloads.
+- This deploy path is required to preserve canonical health across the shared Aria stack, including the known hospital-coupled dependency set. It reduces a real multi-pod cascade class, but it does not replace post-rollout health verification.
+
+## Pre-deploy checklist (run BEFORE drafting the bash command)
+
+1. `git rev-parse --short HEAD` → record commit SHA
+2. `npx tsc --noEmit` in every modified package → record exit codes
+3. `kubectl get validatingadmissionpolicy` → confirm policy exists for the target service
+4. `kubectl get <workload> <service> -o jsonpath='{.spec.template.spec.initContainers[*].name}'` → classify Pattern A vs Pattern B
+5. `kubectl get pod <target-pod> -o wide` → record current state for rollback baseline
+6. `kubectl get statefulset <target> -o jsonpath='{...image}'` → record current image SHA for rollback target
+7. Confirm no concurrent deploy is already active for `/deployments/<namespace>/<service>`
+
+If any of these fail, do NOT deploy. Fix the underlying issue first — never strip the verification step to make the deploy proceed (see `feedback_no_stripping_as_workaround.md`).
+
+## Owner-permission boundary
+
+Three failed gate-blocks in a row triggers owner-level bypass-prevention lockout. If your verify block is failing repeatedly, STOP retrying. The pattern is the gate parser doesn't recognize your field syntax. Read `~/.claude/hooks/aria-pre-tool-gate.mjs` to find the exact regex, then fix your verify block to match — do not retry the same shape three times.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.