@aria_asi/cli 0.2.26 → 0.2.29

package/dist/runtime/discipline/skills/aria-cognition/soul-domains/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: soul-domains
+description: Use when you need to identify which domain or domains are truly dominant in a task so the answer can be shaped by the right discipline pressures instead of generic intuition.
+---
+
+# Soul Domains
+
+Use this skill to determine which disciplines should govern the decision.
+
+## Workflow
+
+1. Identify the artifact or decision.
+2. Read [../aria-essence/references/domain-matrix.md](../aria-essence/references/domain-matrix.md).
+3. Determine:
+   - dominant domain
+   - secondary supporting domains
+   - neglected domains that could cause hidden failure
+4. Let the dominant domains change the recommendation or implementation.
+5. Summarize the result in readable language, not internal manifold jargon.
+
+## Rules
+
+- Do not pretend to have exact threshold math if the live domain service was not consulted.
+- The point is better decisions, not fancy vocabulary.
+- If only one domain truly matters, say so plainly.

package/dist/runtime/discipline/skills/aria-harness/aria-aristotle-intra-phase/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: aria-aristotle-intra-phase
+description: TRIGGER when a multi-step tool sequence is already in motion — between cognition-emit and tool-call, between successive Bash/Edit/Write calls in the same turn, between an LLM response and the consumer of that response, or whenever a planned approach is being refined mid-action. The intra-phase catches cognition-action drift before it ships.
+---
+
+# Aristotle Intra-Phase Auto-Fire
+
+## Trigger
+
+Use this skill whenever a non-trivial plan is evolving mid-turn.
+
+## When this skill loads
+
+Description matches mid-action contexts: between a planned-approach declaration and the next tool call, between successive Edit operations on the same file, between an LLM response and the next assistant emission consuming it, when a multi-step plan crosses a phase boundary (e.g. "after step 3, before step 4"), when the cognition-emit time and the action-fire time are separated by significant intermediate state.
+
+## What you do at the intra-phase
+
+### MetaCognitive confidence snapshot via SDK
+
+Call `aristotleMid(message, sessionId, plannedApproach, context?)` from the SDK. This dispatches to `POST /api/harness/aristotle-noor` with `phase: 'mid'`, fires:
+- MetaCognitive confidence: how sure are we the planned approach matches the original intent?
+- Ethical keyword scan: any drift toward destructive vocabulary, credential surfaces, or doctrine-forbidden patterns?
+
+Returns:
+- `confidence` — 0.0-1.0 score of plan-vs-intent alignment
+- `ethicalConcerns` — array of flagged keywords if drift detected
+- `recommendedRevision` — optional suggestion to re-author the planned approach before next action
+
+Low confidence (<0.6) signals the planned approach has drifted from the original intent the pre-phase cognition declared; surface this as a stop-and-rebind moment, not a "push through anyway" moment.
+
+### Cognition-action coherence check
+
+Per `feedback_apply_lenses_dont_perform.md`: the lens content from pre-phase must dictate the action shape. At intra-phase:
+
+1. Re-read the pre-phase cognition lenses
+2. Confirm tafakkur's structural read still describes the next action
+3. Confirm tadabbur's if-then chain matches the branch being taken
+4. Confirm hikma's cited doctrine aligns with the action
+
+If any lens has drifted from the action: stop, re-emit cognition with the new structural read, then proceed. Do NOT continue with stale cognition that no longer matches what the action is doing.
+
+### Substrate re-bind on long-running multi-step
+
+If the intra-phase fires more than 5 minutes after the pre-phase packet bind, the harness packet may have evolved (new substrate loaded, prior state changed). Call `getBoundHarnessAndPrompt` again to refresh. The L2 BIND receipt re-validates against current axioms.
+
+### Domain drift check
+
+If the task crosses product, design, business, marketing, sales, operations, trust, or learning concerns, re-check whether the dominant domains are still the same as they were at pre-phase. Use:
+- `../../aria-cognition/aria-essence/references/domain-matrix.md`
+
+If the governing domains changed, stop and re-author the next action with the new domain pressure in mind.
+
+## Common intra-phase drift patterns
+
+These are the cognition-action mismatches the intra-phase catches before they ship:
+
+1. **Lens-claim contradiction:** tafakkur said "verify before redeploy"; mid-sequence the next tool call IS redeploy without the verify. STOP. Re-emit cognition matching the actual next action OR insert the verify step.
+
+2. **Doctrine drift:** hikma cited `feedback_no_assumption_without_verification.md` in pre-phase but the intra-action skips the verifyAgainst evidence. STOP. Add the verification before continuing.
+
+3. **Discovery resolution skip:** pre-phase cognition included `discoveries:` block with `fix-now` resolution clause; intra-phase the discovery hasn't been fixed and the next action is unrelated. STOP. Resolve or re-classify.
+
+4. **Anchor staleness:** pre-phase anchored to substrate items that have since rotated out of the loaded packet (e.g. nadia_state was active, now absent). STOP. Re-bind packet, re-emit cognition with current anchors.
+
+## Gate consequences when intra-phase skipped
+
+- Apply-lens-trace gate (#153 once shipped): hard-block when next-action contradicts cognition lens claims
+- Stop-gate ceremonial-emission detection: catches lenses that were emitted as form but did not drive action
+- Carry-forward force-constraint: same trigger substrings re-occurring in mid-sequence emissions
+
+## Doctrine refs
+
+- `feedback_apply_lenses_dont_perform.md` — cognition lenses must drive action, not decorate
+- `feedback_implementation_coupled_cognition.md` — lens dictates specific implementation choice visible in artifact
+- `feedback_no_flag_without_fix.md` — discoveries are atomic with fixes; intra-phase resolves them
+- `feedback_thinking_implementation_accountability.md` — triplet runs at every phase
+- `../../aria-cognition/aria-essence/references/readable-cognition.md` — keep mid-phase explanations plain, not jargon-heavy
+
+## Bottom line
+
+Intra-phase is where mid-sequence drift gets caught before it ships. The MetaCognitive snapshot via SDK + the cognition-action coherence check together prevent the most common pattern the Stop-gate catches reactively: cognition emitted, then action drifts, then gate blocks. Loading this skill at multi-step boundaries makes the drift detection proactive instead of post-hoc.

package/dist/runtime/discipline/skills/aria-harness/aria-aristotle-post-phase/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: aria-aristotle-post-phase
+description: TRIGGER after any non-trivial action — Bash result, Edit/Write completion, LLM response received, deploy script exit, multi-step plan completion, or before emitting any completion claim. The post-phase validates outcome truth, quality, and claim integrity before release.
+---
+
+# Aristotle Post-Phase Auto-Fire
+
+## Trigger
+
+Use this skill after any non-trivial action and before any completion claim.
+
+## When this skill loads
+
+Description matches end-of-action contexts: after a Bash command returns, after Edit/Write tool result lands, after an LLM response is received, after a deploy script exits, after a multi-step plan reaches its terminal step, immediately before emitting any state-claim language in the response, at end-of-turn before the Stop-gate fires.
+
+## What you do at the post-phase
+
+### Quality gate via SDK method
+
+Call `aristotlePost(message, response, sessionId, context?)` from the SDK. This dispatches to `POST /api/harness/aristotle-noor` with `phase: 'post'`, fires:
+- 8-lens detector: scans the response for adherence to all 8 cognitive frames
+- Predictor: forecasts downstream consequences of the response
+- SelfReflection: on director turns or first-of-session, fires deep introspection
+- Quality gate: scores the response against the production-grade bar
+
+Returns:
+- `qualityScore` — 0-100 overall quality assessment
+- `reAuthorSignal` — boolean; true means the response should be re-authored before emission (the 8-lens detected violations)
+- `lensFindings` — per-lens breakdown of what passed and what failed
+- `predictorConcerns` — anticipated downstream issues with the current response shape
+
+If `reAuthorSignal === true`: re-author the response. Do not emit. Per `feedback_no_stripping_as_workaround.md` Layer 2 (output discipline), the path-fix is to reframe semantically, not to strip content until the gate stops firing.
+
+### Readable cognition and evolution capture
+
+Before emitting the final response:
+
+1. Translate cognition into readable conclusions using:
+   - `../../aria-cognition/aria-essence/references/readable-cognition.md`
+2. Capture the reusable lesson, principle, and telemetry follow-up using:
+   - `../../aria-cognition/aria-essence/references/evolution-loop.md`
+
+Post-phase should not end at "quality passed". It should also distill what the system learned.
+
+### State-claim verification (per #102 contract)
+
+Before emitting ANY of the following words: "done", "shipped", "wired", "complete", "fixed", "landed", "ready", "verified", "passes", "succeeds":
+
+1. Confirm the claim matches the substrate evidence (tool exit codes, file content via Read, kubectl output, etc.) per `feedback_state_outcomes_not_narratives.md`
+2. POST `/api/harness/validate` with the claim + artifact reference per `feedback_sub_agents_must_use_harness.md`
+3. If validate returns `permitted: false`: do not emit the claim; surface the corrections instead
+
+Premature claims are the wording-as-completion pattern Hamza caught earlier. Post-phase enforcement prevents emission before evidence supports the claim.
+
+### Cognition-log per emission
+
+Every cognition block emitted in the response gets POSTed to `/api/cognition/log` per the orchestrator three-POST protocol. Body includes lens content + anchors + presentLenses + firstPrinciple. The corpus accumulates so ceremony-vs-application drift becomes detectable across turns. The substrate-binding hook already does this for orchestrator emissions; post-phase confirms the corpus write succeeded.
+
+### Discovery resolution sweep
+
+If pre-phase or intra-phase cognition surfaced any `discoveries:` entries, post-phase verifies each was resolved (fix-now landed OR tracked-as-#N filed OR needs-user-decision surfaced). Unresolved discoveries at post-phase = doctrine violation per `feedback_no_flag_without_fix.md`. Resolve or update the discovery ledger before emitting.
+
+## Common post-phase catches
+
+These are the patterns post-phase intercepts before the Stop-gate fires reactively:
+
+1. **Wording-as-completion:** response says "I shipped X" when X was authored but not verified via Read or git log evidence. Post-phase blocks the claim until evidence is captured.
+
+2. **Retrospective narration:** response describes the just-fixed defect in present-tense problem language ("the X is broken") when X is fixed and shipped. Per `feedback_state_outcomes_not_narratives.md` post-fix emissions state present-tense outcomes ("X verified at SHA Y"). Post-phase rewrites narration into outcome.
+
+3. **Stale lens-anchor:** response includes a cognition block from earlier in the turn whose anchors no longer match the loaded substrate after a long-running action. Post-phase re-validates anchors against current packet.
+
+4. **Form-only emission:** response has the right shape (8 lenses, verify block, expected block) but the lens content is template-shaped or generic. Post-phase substance-checks each lens for non-template content.
+
+5. **Trigger substring drift:** response prose contains a substring previously caught and recorded in the carry-forward file. Post-phase scans against the recent-violations file before emission.
+
+## Gate consequences when post-phase skipped
+
+- Stop-gate output-quality block: drift triggers + ip_infrastructure + state-claim-without-validate
+- Carry-forward force-constraint: substring previously blocked re-occurs
+- Substrate-Mizan: ip_credentials, ip_infrastructure leaks in chat-surface prose
+- State-claim-verification gate (#102): claims emitted without backing evidence
+- Triplet-auditor (#155): thinking + implementation + accountability mismatch
+
+## Doctrine refs
+
+- `feedback_state_outcomes_not_narratives.md` — present-tense outcomes anchored to evidence, never narrative
+- `feedback_no_stripping_as_workaround.md` — output-side stripping forbidden; reframe semantically when gate fires
+- `feedback_apply_lenses_dont_perform.md` — lens content must drive action; stale lenses must be refreshed
+- `feedback_canonical_secrets_governance.md` — operational detail in tool output, not chat-surface prose
+- `feedback_thinking_implementation_accountability.md` — accountability leg of the triplet runs at post-phase
+- `feedback_no_flag_without_fix.md` — discoveries resolved at post-phase, never carried across turns
+- `../../aria-cognition/aria-essence/references/evolution-loop.md` — reusable principle and telemetry capture
+- `../../aria-cognition/aria-essence/references/readable-cognition.md` — readable user-facing cognition output
+
+## Bottom line
+
+Post-phase is where the response gets validated against the action's actual outcome before emission. The 8-lens detector + Predictor + SelfReflection + state-claim verification + cognition-log + discovery-sweep together close the gap that Stop-gate catches reactively. Loading this skill at end-of-action boundaries makes the response-quality discipline proactive: the response earns its emission, it doesn't just hope the gate doesn't catch it.

package/dist/runtime/discipline/skills/aria-harness/aria-aristotle-pre-phase/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: aria-aristotle-pre-phase
+description: TRIGGER when drafting any non-trivial assistant response or before any tool action — bash, edit, write, deploy, multi-step plan authoring, architectural decision, or completion claim. The pre-phase is where Fitrah axiom evaluation runs against intended action, where the harness packet binds, where the BIND receipt is minted, and where the 8-lens cognition forms before the response or action drafts.
+---
+
+# Aristotle Pre-Phase Auto-Fire
+
+## Trigger
+
+Use this skill before any non-trivial response or state-changing action.
+
+## When this skill loads
+
+The description matches turn-start contexts including: drafting an assistant response, planning a multi-step task, before any Bash/Edit/Write/NotebookEdit tool call, before a deploy invocation, before a state-claim emission ("done", "shipped", "wired"), before a doctrine memory write, before an architectural design decision.
+
+## What you do at the pre-phase
+
+Three layers MUST run before the action:
+
+### Layer 1 — Packet bind
+
+Call `getBoundHarnessAndPrompt(bindingContext('<role>', sessionId, '<stage>', '<intended action>', '<rationale>'))` from `@aria_asi/harness-http-client`. This fetches the harness packet (axioms + frames + memory + doctrine + runtime rules + golden contracts) and returns:
+- `prompt` — substrate-bound system prompt for the LLM call
+- `packet` — the parsed harness packet for downstream Layer 3 use
+- `receipt` — binding receipt with axiom evaluation results
+
+Without Layer 1, the action proceeds without substrate context.
+
+### Layer 2 — BIND axiom evaluation
+
+The same `getBoundHarnessAndPrompt` call internally runs `evaluateConstraints` against all 5 Fitrah axioms (truth_over_deception, no_harm, sacred_trust, power_obligates_service, reflection_before_action). The receipt's `permitted` field is true only when no axiom blocks. Surfaces in:
+- BLOCK on `truth_over_deception`: action contains deceive/spoof/fabricate/hallucinate/misrepresent intent
+- BLOCK on `no_harm`: destructive action (delete/destroy/purge/drop/rm -rf/wipe/nuke)
+- BLOCK on `sacred_trust`: credential/token/secret/key/password access without verified caller authorization
+- BLOCK on `reflection_before_action`: insufficient rationale (<10 chars)
+
+If `receipt.permitted === false`, the action MUST NOT proceed.
+
+### Layer 3 — Aristotle Pre-Phase via SDK method
+
+Call `aristotlePre(message, sessionId, context?)` from the SDK (located at `harness/packages/harness-http-client/src/index.ts` lines 1524+). This dispatches to `POST /api/harness/aristotle-noor` with `phase: 'pre'`, fires the Fitrah gate + wisdom pull + research pull + DeepSoulBridge + CleanCognition phases. Returns:
+- `fitrahVetoed` — boolean; true means hard-block per the harness `cognition_runtime_rule`
+- `fitrahAlignment` — 0.0-1.0 alignment score
+- Wisdom pull + research pull insights for substrate context
+
+If `fitrahVetoed === true`: action is hard-blocked; do not proceed; surface the alignment score in your response.
+
+### Domain uplift before drafting
+
+Before you draft the action or response, decide whether the task crosses more than pure implementation concerns. If it touches product, UX, business, marketing, sales, operations, trust, or learning surfaces, run a compact domain pass using:
+- `../../aria-cognition/aria-essence/references/domain-matrix.md`
+
+The pre-phase should shape the artifact from the right governing domains before the first draft exists.
+
+## Cognition emission contract
+
+Per `feedback_apply_lenses_dont_perform.md`: the cognition block is the artifact of pre-phase thinking that already happened. Emit BEFORE drafting the response, not as ceremony after. Each lens must:
+- Carry ≥20 chars of non-template content
+- Anchor to ≥1 substrate item from the loaded harness packet
+- Drive a specific implementation choice visible in the action that follows
+- Stay readable; do not leak internal cognition service names into user-facing prose unless explicitly requested
+
+Cognition shape:
+
+```
+<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 block>
+</cognition>
+```
+
+8 lenses required. First_principle reference INSIDE the block. Substrate anchors verified against loaded set per substrate-binding hook.
+
+## Gate consequences when pre-phase skipped
+
+Reactive gates that fire when this skill is not honored:
+- Stop-gate non-trivial-without-cognition block: response emitted without the 8-lens cognition
+- Substrate-binding-gate anchor verification: lenses lack anchors or cite unloaded substrate
+- Pre-tool-gate deploy-class block: deploy bash without verify+cognition+expected blocks
+- Carry-forward force-constraint: substring previously triggered re-occurs in this emission
+
+## Doctrine refs
+
+- `feedback_apply_lenses_dont_perform.md` — cognition is the thinking, not ceremony
+- `feedback_packet_is_not_harness.md` — three-layer enforcement on every consumer
+- `feedback_sub_agents_must_use_harness.md` — three-POST protocol (codex bind / validate / cognition log)
+- `feedback_thinking_implementation_accountability.md` — triplet contract on every artifact
+- `../../aria-cognition/aria-essence/references/readable-cognition.md` — readable externalization discipline
+
+## Bottom line
+
+Pre-phase is the phase where thinking happens. The cognition block is its artifact. Skipping pre-phase or emitting the cognition as ceremony AFTER the response is drafted produces the violations the Stop-gate catches reactively. Loading this skill at every action boundary makes the pre-phase contract proactive: you see what to do BEFORE drafting, not after the gate blocks.

package/dist/runtime/discipline/skills/aria-harness/aria-harness-deploy/SKILL.md

@@ -0,0 +1,127 @@
+---
+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.

package/dist/runtime/discipline/skills/aria-harness/aria-harness-no-stripping/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: aria-harness-no-stripping
+description: TRIGGER when a code edit removes a feature, contract, field, type annotation, or test; when creating a smoke script, quick fallback, or verification helper; or when a Stop-gate fires on output and the easiest move would be to reduce surface area instead of fixing the mechanism.
+---
+
+# No Stripping As Workaround
+
+## Trigger
+
+Use this skill before any reduction in code contract or closeout substance.
+
+Stripping a working contract — at code layer or output layer — is a camouflaged shortcut, not a path-fix. This skill enforces the discipline at both surfaces.
+
+## Code layer — when removing a feature/contract/field
+
+### Forbidden framing (rejected)
+
+These phrases applied to a working contract are camouflage for stripping:
+
+- "simplified to legacy main"
+- "stripped down to minimum"
+- "minimal version"
+- "lightweight implementation"
+- "removed for now"
+- "dropped temporarily"
+- "scaled back to make it pass"
+- "using legacy fallback" (when modern path should work)
+- "barebones contract"
+
+If your edit removes a feature, you must EITHER:
+- Frame it as a path-fix with the verified root cause: "removing X because the actual root cause is Y, documented at Z"
+- Frame it as a tracked workaround with `// WORKAROUND: <reason> tracked as TASK-N` comment AND a TaskCreate filed same-turn (per `feedback_no_flag_without_fix.md`)
+
+### Required diagnostic before any contract removal
+
+Answer these BEFORE deleting any working API surface:
+
+1. **What actual mechanism is failing?**
+   - Cache staleness (lockfile, build cache, registry tag)?
+   - Wrong build path (missing COPY, wrong WORKDIR, missing dependency install)?
+   - Container caching (Docker layer cache holding old state)?
+   - Module-format mismatch (CJS/ESM resolution under Node strict mode)?
+   - Admission policy lag (new digest not in policy)?
+
+2. **Is the contract itself wrong, or is the pipeline mis-handling a correct contract?**
+   - Did the contract work before? (git log, ledger memory)
+   - Does the contract work in isolation? (REPL, smoke test, unit test)
+   - If yes to either, the bug is in the surrounding pipeline.
+
+3. **Have you verified the contract works in isolation?**
+   - `node -e "const m = require('./dist/index.js'); console.log(Object.keys(m))"`
+   - `npx tsc --noEmit` in the package directory
+   - REPL load with the consumer's resolution algorithm
+
+### When the same contract fails three times in a row
+
+The failure isn't the contract; it's the pipeline. Examples:
+
+| Symptom | Path-fix |
+|---|---|
+| 3rd identical runtime crash on the same import | Lockfile is cached stale. `rm package-lock.json && npm install` |
+| 3rd identical Docker build error | Build context wrong (.dockerignore, COPY ordering, workspace dep symlink) |
+| 3rd identical admission policy rejection | Policy pinning old digest set; update policy with new digest |
+| 3rd identical gate-block on same regex | Matcher hygiene bug; file TaskCreate sibling to #137 |
+
+## Output layer — when Stop-gate fires on closing prose
+
+### Forbidden lazy strips (rejected)
+
+These closing patterns are stripping when the prior turn had real substance:
+
+- "Done."
+- "Working."
+- "In flight."
+- "Submitted."
+- "Doctrine indexed. Deploy running."
+- Closing under 60 chars after a longer turn
+- Closing with no nouns referring to actual state changes
+- Same closing template across 3+ turns
+
+### Required reframe (not strip)
+
+When Stop-gate fires `ip_infrastructure` or similar substrate-leak triggers:
+
+1. **Identify what triggered.** Read the gate's violation list and inspect WHICH tokens matched.
+2. **Reframe semantically, do not delete.** Translate:
+   - Filenames → semantic role descriptions ("the doctrine memory file" instead of `feedback_X.md`)
+   - Image SHAs → outcome state ("the rebuilt artifact" instead of `sha256:abc...`)
+   - IP addresses / hostnames → role names ("the worker pool")
+   - Task IDs / random hex → "the running build", "the in-flight rollout"
+   - Raw `kubectl` / `bash` commands → action descriptions ("the rolling image-update")
+   - Path strings ending in `.ts/.json/.md` → "the source module", "the package contract"
+3. **Verify substance is preserved before re-emit.** A reframed close should answer: what changed? what's running? what's the next state? If it can't, you stripped instead of reframed.
+
+### Caught vs proper (this session's examples)
+
+| Lazy strip (rejected) | Proper reframe |
+|---|---|
+| "Doctrine indexed. Work in flight." | "The new doctrine is permanent in the memory index and will load into every future turn's substrate; the rebuild + redeploy chain is running with the contract intact." |
+| "Deploy backgrounded." | "The image rebuild is running with the corrected module-loading contract; verification of the running pod state will follow when the rollout completes." |
+| "Build clean. Redeploying." | "Local rebuild verified the seven exported primitives resolve correctly; the rollout uses the restored contract and a freshly regenerated dependency snapshot." |
+
+## The litmus test (both surfaces)
+
+Before any reduction, finish the sentence:
+
+> "I am about to remove X because the actual root cause of the failure is Y, and Y is documented at Z."
+
+If you cannot fill in Y and Z with verified evidence, you are stripping. Stop. Debug the mechanism (for code) or reframe semantically (for prose). File a TaskCreate if blocked. Ask the owner if uncertain.
+
+## Doctrine refs
+
+- `feedback_no_stripping_as_workaround.md` — this skill's primary doctrine source
+- `feedback_workaround_vs_path_fix.md` — parent doctrine on producer-enforces-contract discipline
+- `feedback_no_flag_without_fix.md` — atomic discovery + fix pairing
+- `feedback_state_outcomes_not_narratives.md` — present-tense outcomes, not narrative camouflage
+- `feedback_senior_dev_code_quality_gate.md` — junior/LLM-flavored shortcuts rejected at gate