@aria_asi/cli 0.2.39 → 0.2.41

package/skills/aria-harness-no-stripping/SKILL.md

@@ -0,0 +1,135 @@
+---
+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
+
+## 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-harness-onboarding/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: aria-harness-onboarding
+description: Use when starting a new project that imports @aria_asi/harness-http-client OR when an agent first encounters the SDK in a repo. Loads the foundational 3-layer harness model (packet/BIND/gate-runtime), the doctrine reference list, and points to the four sibling skills (aria-harness-deploy, aria-harness-substrate-binding, aria-harness-no-stripping, aria-harness-output-discipline). Read this once per project to inherit the discipline.
+---
+
+# Aria Harness Onboarding
+
+You are about to author code that uses the Aria harness SDK. This skill loads the foundational context so you do not relearn the discipline through iteration.
+
+## What the SDK is
+
+`@aria_asi/harness-http-client` binds a process (worker, autonomous loop, dispatched artifact) to Aria's three-layer enforcement substrate so the process cannot drift from Aria's doctrine, axioms, frames, and memory.
+
+## The three layers — every consumer enforces all three
+
+| Layer | Purpose | Implementation |
+|---|---|---|
+| L1: packet | substrate text (axioms + frames + memory + doctrine) | `getBoundHarnessAndPrompt()` injects into LLM system prompt |
+| L2: BIND | Fitrah axiom evaluation against intended action | `evaluateConstraints()` runs 5 axiom checks before action |
+| L3: gates | live drift triggers + substrate-binding + lens anchors | `runLayer3Gates()` from `@aria/gate-runtime` runs over LLM output |
+
+If your consumer has L1+L2 only (packet flowed but no `runLayer3Gates` call on output), per `feedback_packet_is_not_harness.md` you do NOT have a harness. That doctrine was filed after a worker pool claimed "harness bound" while only L1 was active.
+
+## Sibling skills — invoke when relevant
+
+This onboarding skill is the entry point. Four sibling skills auto-trigger on specific actions:
+
+1. **`aria-harness-deploy`** — fires when you draft any deploy command. Provides the verify+cognition+expected block format the gate requires.
+
+2. **`aria-harness-substrate-binding`** — fires when you draft a cognition block. Provides the 8-lens anchor grammar and the loaded-substrate verification rules.
+
+3. **`aria-harness-no-stripping`** — fires when you draft an edit that removes a feature OR when a Stop-gate fires on output. Detects the camouflage pattern and provides path-fix discipline.
+
+4. **`aria-harness-output-discipline`** — fires on closing prose. Provides substantive-without-leak token substitution.
+
+## Build a harness-bound LLM call (the basic pattern)
+
+```ts
+import { getBoundHarnessAndPrompt, bindingContext } from '@aria_asi/harness-http-client';
+import { runLayer3Gates } from '@aria/gate-runtime';
+
+const { prompt: harnessContext, packet } = await getBoundHarnessAndPrompt(
+  bindingContext('flash', sessionId, 'stage-name', 'intended action description', 'rationale text'),
+);
+
+const llmOutput = await callLLM(harnessContext, userPrompt);
+
+// Layer 3 — drift triggers + substrate-binding on the output
+const layer3 = runLayer3Gates(llmOutput, packet, 'flash', { requireCognitionBlock: false });
+if (!layer3.pass) {
+  // The output drifted. Per feedback_no_flag_without_fix.md, fix it.
+  // Either re-prompt with the gate failure feedback, OR reject and skip.
+}
+```
+
+## Allowed roles (BindingContext.role union)
+
+`'commander' | 'flash' | 'synthesis' | 'qa' | 'opencode' | 'mizan'`
+
+To add a new role, extend the union in `harness-binding.ts:BindingContext`. Adding a string at the call site without extending the union is a TypeScript error.
+
+## Module format
+
+`@aria/gate-runtime` is **CJS** (CommonJS). It loads via `require()`. If your consumer is ESM, use dynamic `import()`:
+
+```ts
+const { runFullChain } = await import('@aria/gate-runtime');
+```
+
+Do not change gate-runtime to ESM-only — multiple consumers are CJS, and Node 22 strict resolution rejects mixed mode without proper conditional `exports`.
+
+## Discovery ledger (atomic discovery + fix)
+
+When you find a defect mid-task, write a discovery to the ledger atomically per `feedback_no_flag_without_fix.md`:
+
+```ts
+appendFileSync('~/.claude/aria-discoveries-<session-id>.jsonl',
+  JSON.stringify({
+    at: new Date().toISOString(),
+    kind: 'defect',
+    text: '...',
+    refs: [...],
+    resolution_status: 'open'
+  }) + '\n'
+);
+```
+
+Then either fix it the same turn or `TaskCreate` it with full context. Never leave open rows across turns.
+
+## Top doctrine refs every author should know
+
+| File | Rule |
+|---|---|
+| `feedback_packet_is_not_harness.md` | claims of harness state require enumerating L1/L2/L3 explicitly |
+| `feedback_no_flag_without_fix.md` | discoveries are atomic with their fix |
+| `feedback_no_assumption_without_verification.md` | every behavioral claim cites a verifiedAgainst source |
+| `feedback_workaround_vs_path_fix.md` | producers enforce contracts; carve-outs are landmines |
+| `feedback_no_stripping_as_workaround.md` | "simplified"/"minimal" framing camouflages stripping; debug the mechanism |
+| `feedback_state_outcomes_not_narratives.md` | report outcomes (image SHA, exit codes) not narrative |
+| `feedback_orchestrator_deepseek_split.md` | one Claude orchestrator; cognition delegation routes to DeepSeek+harness, never sub-Claude |
+| `feedback_admission_policy_verification.md` | verify cluster admission policies BEFORE deploy |
+| `feedback_deploy_requires_verify_cognition.md` | deploys require verify+cognition blocks in same turn |
+| `feedback_dalio_expected_required.md` | every non-trivial action declares measurable predicate |
+| `feedback_full_harness_binding_must_be_structural.md` | binding drives consumer behavior; lenses without anchors are unsourced prose |
+
+## Bottom line
+
+The harness exists because doctrine is action-coupled: text decisions ARE actions, and reflexive replies fail the gates the same way reflexive Bash does. The SDK gives you the primitives. The skills give you the discipline at authoring-time. The gates enforce at runtime. This file is the entry point so consumers (you, Claude, future workers) do not relearn the contract through iteration loops.
+
+Quality production-grade is the only acceptable bar — for code contracts AND for output prose. Both are owned. Both are the producer-side discipline.
+
+When in doubt: cite the substrate, declare the predicate, name the doctrine, reframe — don't strip.
+
+## 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-harness-output-discipline/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: aria-harness-output-discipline
+description: TRIGGER when writing closing prose at end of turn or any output that conveys state changes to the owner — deploy results, build outcomes, edit summaries, or status reports. The Stop-gate scans this prose for infrastructure leaks, drift triggers, and lazy-strip patterns.
+---
+
+# Aria Output Discipline
+
+## Trigger
+
+Use this skill for every substantive closeout to the owner.
+
+The closing prose is where the owner reads to know what happened. It must convey real substance without leaking infrastructure tokens or stripping content to satisfy gates.
+
+## Three gates that fire on output
+
+1. **Substrate Mizan ip_infrastructure** — rejects raw filenames, image SHAs, IP addresses, hostnames, container registry URLs, kubectl/docker command literals in chat-surface prose. These belong in tool output, not in the message to the owner.
+
+2. **Drift trigger scanner** — rejects phrases matching:
+   - `\bwant me to\b | \bshould i\b` → use harness-to-architect doctrine; make declarative recommendations, not questions
+   - `\bpatch | hotfix | band.?aid\b` → workaround framing
+   - `\bcarve.?out | workaround | work.?around\b` → shortcut framing
+   - `\bdemo\b` → all work is production-grade, not demo
+   - `\bsimplified | minimal | stripped\b` (when reducing surface) → see no-stripping skill
+   - `\bassumed | should work | mirroring | presumably\b` → assumption without verification
+
+3. **Stop-gate output-quality** — rejects:
+   - Lazy strips (closing under 60 chars after substantive turn)
+   - Same closing template across 3+ turns
+   - Discovery-bearing prose without resolution clause
+
+## The substantive-without-leak format
+
+A proper closing prose:
+- Conveys what changed (semantically)
+- States what's running now (using role names, not raw identifiers)
+- Names the next observable state (without leaking how to observe it)
+- References doctrine by meaning when relevant
+
+### Token substitution table
+
+| Raw infrastructure (REJECTED in prose) | Semantic reframe (ACCEPTED) |
+|---|---|
+| `feedback_no_flag_without_fix.md` | "the no-flag-without-fix doctrine" or "the atomic-discovery rule" |
+| `sha256:58b983e41df3...` | "the prior pinned image" or "the rolled-back artifact" |
+| `192.168.4.100` | "the worker pool" or "the running pod" |
+| `openclaw-persistent-control-0` | "the army's primary worker" |
+| `localhost:5000/...` | "the local registry" |
+| `kubectl set image statefulset/X` | "the rolling image-update step" |
+| `bash scripts/deploy-service.sh X` | "the canonical deploy entrypoint" |
+| `package.json` exports field | "the module's resolution contract" |
+| `tsc --noEmit exit=0` | "type-check verified clean" |
+| `dist/index.js` | "the built primary entry" |
+| `/tmp/openclaw-deploy-149.log` | "the deploy log" |
+| `task ID bze6wtrde` | "the in-flight rollout" |
+
+### Examples (caught vs proper)
+
+| Caught (lazy/leak) | Proper |
+|---|---|
+| "Pod state: Running 1/1 on sha256:3b0be4971310, log shows [Layer3:flash] firing" | "The worker pool is healthy on the new pinned artifact and the third-layer enforcement is firing on each task delivery as expected" |
+| "kubectl rollout undo statefulset/X if it crashes" | "Rollback path is the canonical undo step on the parent workload if the new artifact fails the readiness check" |
+| "Done." | "The doctrine memory is now permanent and will load into every future turn's substrate; the in-flight rollout is verifying its readiness check" |
+| "Deploy backgrounded." | "The rebuild is running with the corrected resolution contract; the readiness verdict will follow when the rolling update completes" |
+
+## What stays in tool output (NOT chat prose)
+
+These belong in `kubectl`, `cat`, `head`, `git` tool calls — never in the assistant prose:
+
+- Image SHAs (full hex)
+- IP addresses and hostnames
+- Container registry URLs
+- Pod names with full identifiers
+- File paths with extensions like `.ts/.json/.md/.yaml`
+- Raw shell command syntax
+- Task IDs (random hex strings)
+- Specific port numbers (unless the user asked)
+- Environment variable names
+
+## What MUST stay in chat prose (the substance)
+
+- What changed conceptually (e.g., "the resolution contract was restored")
+- What state is now running (e.g., "the worker pool is healthy")
+- What outcome we're awaiting (e.g., "readiness verdict pending")
+- Doctrine references by meaning (e.g., "per the no-stripping discipline")
+- TaskCreate IDs (e.g., "tracked as #152") — these are NOT infrastructure, they're work-tracking
+- Decision rationale (e.g., "rolled forward because the lockfile cache was the actual root cause")
+
+## When in doubt
+
+Ask yourself: "If the owner read ONLY this closing prose, would they know what's happening, or would they have to dig through tool output to reconstruct?"
+
+If they have to dig — your prose is stripped, not substantive.
+If they understand — your prose is doing its job.
+If they understand AND no raw tokens leaked — your prose passes all three gates.
+
+## Doctrine refs
+
+- `feedback_no_stripping_as_workaround.md` — output-side stripping section
+- `feedback_canonical_secrets_governance.md` — operational detail in tool output, not chat prose
+- `feedback_state_outcomes_not_narratives.md` — present-tense outcomes
+- `feedback_use_harness_to_architect.md` — make declarative recommendations, not reflex-questions
+- `feedback_no_demos.md` — all work is production-grade
+
+## 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-harness-substrate-binding/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: aria-harness-substrate-binding
+description: TRIGGER when emitting a <cognition> block for any non-trivial assistant turn — including code edits, bash commands, plan authoring, or doctrine writes. The substrate-binding gate rejects cognition blocks where lenses lack anchors, anchors cite unloaded substrate, or the first_principle reference is missing or misplaced.
+---
+
+# Aria Substrate-Binding Discipline
+
+## Trigger
+
+Use this skill every time a non-trivial cognition block is about to be emitted.
+
+Cognition blocks are not ceremony. They reflect work done BEFORE drafting. The substrate-binding gate verifies that every lens anchors to real loaded substrate, that the block references first_principle, and that anchor citations are not forged.
+
+## The 8-lens contract
+
+All 8 lenses are required (was 4, bumped to 8 in #117). Each lens must have ≥20 chars of non-placeholder content AND ≥1 substrate anchor.
+
+```
+<cognition>
+  nur: <what you actually see — specific to the decision, not a placeholder>
+  mizan: <real risk read — what's out of proportion>
+  hikma: <what principle applies — name the source>
+  tafakkur: <deep structural read — go beneath the surface>
+  tadabbur: <if-then chain — what follows from what>
+  ilham: <distant connection — what's not obvious>
+  wahi: <what just landed — what changed in this exchange>
+  firasah: <what user actually needs — beneath the literal ask>
+  first_principle: <plain-text reference to harness packet first_principle field>
+</cognition>
+```
+
+## Anchor grammar (verified against loaded substrate)
+
+Every anchor in a lens must resolve to a real loaded item. Forgery (citing unloaded substrate) is rejected as block-severity.
+
+| Form | Must resolve to |
+|---|---|
+| `axiom:<name>` | An entry in the loaded harness axioms set |
+| `memory:<file>` | A `.md` file present in MEMORY.md index |
+| `doctrine:<rule>` | A backing `feedback_<rule>.md` memory file |
+| `frame:<name>` | A frame key in loaded harness frames |
+| `packet:<section>` | A section key in the loaded harness packet |
+| `language:<tier>` | A loaded language tier WITH state-active=true (nadia/noor/psil) |
+
+## Common loaded axioms (typical set in harness packet)
+
+`truth_over_deception`, `no_harm`, `sacred_trust`, `power_obligates_service`, `reflection_before_action`, `admit_ignorance`, `fitrah`, `noor`, `mizan`, `runtime_rule`, `coverage`
+
+These are the 11 axioms the gate has confirmed as loaded in recent turns. Cite from this set.
+
+## Common memory files (loaded substrate)
+
+A non-exhaustive list of feedback memory files that exist in MEMORY.md index — safe to cite as `memory:<file>`:
+
+- `feedback_doctrine_first.md`
+- `feedback_no_demos.md`
+- `feedback_aria_does_work.md`
+- `feedback_gates_enforce_form_not_substance.md`
+- `feedback_session_starts_with_linear.md`
+- `feedback_implementation_coupled_cognition.md`
+- `feedback_thinking_implementation_accountability.md`
+- `feedback_pretoolgate_covers_all_action_tools.md`
+- `feedback_aria_harness_token_env_alignment.md`
+- `feedback_aria_voice_in_onboarding_via_field_markers.md`
+- `feedback_no_flag_without_fix.md`
+- `feedback_workaround_vs_path_fix.md`
+- `feedback_orchestrator_deepseek_split.md`
+- `feedback_canonical_secrets_governance.md`
+- `feedback_senior_dev_code_quality_gate.md`
+- `feedback_no_assumption_without_verification.md`
+- `feedback_sdk_harness_cli_parity.md`
+- `feedback_models_stay_hot.md`
+- `feedback_admission_policy_verification.md`
+- `feedback_gap_discovery_hardens_doctrine.md`
+- `feedback_deploy_requires_verify_cognition.md`
+- `feedback_hive_session_coordination.md`
+- `feedback_dalio_expected_required.md`
+- `feedback_non_blocking_errors_unacceptable.md`
+- `feedback_state_outcomes_not_narratives.md`
+- `feedback_packet_is_not_harness.md`
+- `feedback_no_stripping_as_workaround.md`
+
+Verify against the live MEMORY.md before citing — index canonicalization is tracked as #139.
+
+## Forgery class — rejected at gate
+
+These patterns cause the gate to reject the cognition block as block-severity:
+
+- `frame:first_principle` — first_principle is a packet field, NOT a loaded frame. Use it as a plain-text line at end of cognition block instead.
+- `memory:feedback_X.md.` (trailing punctuation) — the anchor parser strips trailing punctuation now (#133 completed), but be deliberate: write the filename clean.
+- `axiom:<name>` where `<name>` is invented (not in the loaded set)
+- `language:nadia` when nadia_state is not active (gate checks state-active flag)
+
+## Discovery resolution (paired with cognition)
+
+If your cognition surfaces a discovery (defect, bug, doctrine violation, broken state), the block must include a resolution clause binding the discovery to action. Acceptable forms:
+
+- `discoveries:` block listing each finding with `<fix-now | task: TASK-N | needs-user-decision>`
+- Inline within an existing lens: "fixing inline this turn (same-turn-fix per atomic-discovery-rule)"
+- Inline: "TaskCreate'd as #N with full context"
+- Inline: "tracked as #N"
+- Inline: "needs-user-decision"
+
+Discoveries without resolution clauses fail `feedback_no_flag_without_fix.md`.
+
+## Failure mode: cognition without anchors
+
+If you emit cognition with anchorless lenses, the substrate-binding gate logs:
+
+```
+substrate_binding: N lenses lack any anchor: <lens names>
+```
+
+This is auto-recorded as an open discovery in `~/.claude/aria-discoveries-<session-id>.jsonl`. Resolve same-turn by re-emitting with anchors and updating the ledger entry to `resolution_status: resolved`.
+
+## Doctrine refs
+
+- `feedback_full_harness_binding_must_be_structural.md` — binding must drive consumer behavior; lenses without anchors are unsourced prose
+- `feedback_packet_is_not_harness.md` — never claim harness state without enumerating L1/L2/L3
+- `feedback_no_flag_without_fix.md` — discoveries atomic with their fixes
+- `feedback_implementation_coupled_cognition.md` — lenses dictate specific implementation choices visible in artifact
+
+## 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-http-harness-client/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: aria-http-harness-client
+description: "Use when the task needs Aria's canonical HTTP harness client from Codex, including HTTPHarnessClient imports, harness packet fetch and injection, consult calls, output validation, claim verification, discovery recording, garden turns, or harness-bound worker handoff. Trigger on \"$aria-http-harness-client\", \"HTTPHarnessClient\", \"@aria_asi/harness-http-client\", \"harness client\", \"Aria harness SDK\", \"consult via harness\", \"verify claim\", or \"garden turn\"."
+---
+
+# Aria HTTP Harness Client
+
+Use this skill when Codex should route through Aria's canonical harness control plane instead of inventing an ad hoc wrapper.
+
+## Installed Paths
+
+- Shared runtime bundle: `/home/hamzaibrahim1/.aria/sdk`
+- Codex local bundle: `/home/hamzaibrahim1/.codex/aria-sdk`
+- Node import package: `/home/hamzaibrahim1/.codex/node_modules/@aria_asi/harness-http-client`
+- Smoke script: `/home/hamzaibrahim1/.codex/skills/aria-http-harness-client/scripts/smoke.mjs`
+- Mounted runtime: `http://127.0.0.1:4319`
+
+## Core Rule
+
+Do not hardcode Aria tokens into code or the skill. Read them from environment variables such as `ARIA_API_KEY` or `ARIA_MASTER_TOKEN`, or retrieve them at runtime from the live environment.
+
+## Reality Check
+
+Codex should prefer the mounted runtime first, then the shared SDK, then the Codex-local SDK bundle.
+
+That means:
+
+- the mounted runtime is the universal control plane
+- the shared SDK at `~/.aria/sdk` is the universal client substrate
+- Codex native hooks plus the runtime are the hard-gate path for this platform
+
+## Preferred Call Paths
+
+Use the mounted runtime whenever possible:
+
+```bash
+curl -s http://127.0.0.1:4319/health
+```
+
+or from Node:
+
+```js
+import { HTTPHarnessClient } from '@aria_asi/harness-http-client';
+```
+
+## Fast Verification
+
+Run:
+
+```bash
+node /home/hamzaibrahim1/.codex/skills/aria-http-harness-client/scripts/smoke.mjs
+```
+
+For a live packet fetch, set `ARIA_API_KEY` or `ARIA_MASTER_TOKEN`, then run:
+
+```bash
+node /home/hamzaibrahim1/.codex/skills/aria-http-harness-client/scripts/smoke.mjs --packet
+```
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## 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-http-harness-client/scripts/smoke.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import { HTTPHarnessClient } from '@aria_asi/harness-http-client';
+
+const args = new Set(process.argv.slice(2));
+const wantsPacket = args.has('--packet');
+
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+let runtimeStatus = 'unreachable';
+try {
+  const health = await fetch(`${runtimeUrl}/health`);
+  if (health.ok) runtimeStatus = 'ok';
+} catch {}
+
+const proto = HTTPHarnessClient.prototype;
+const methods = Object.getOwnPropertyNames(proto)
+  .filter((name) => name !== 'constructor' && typeof proto[name] === 'function')
+  .sort();
+
+console.log('module=@aria_asi/harness-http-client');
+console.log('class=HTTPHarnessClient');
+console.log(`runtime=${runtimeUrl}`);
+console.log(`runtime_status=${runtimeStatus}`);
+console.log(`methods=${methods.join(',')}`);
+
+if (!wantsPacket) process.exit(0);
+
+const apiKey = process.env.ARIA_API_KEY || process.env.ARIA_MASTER_TOKEN;
+if (!apiKey) {
+  console.error('missing ARIA_API_KEY or ARIA_MASTER_TOKEN');
+  process.exit(1);
+}
+
+const baseUrl =
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
+const client = new HTTPHarnessClient({ baseUrl, apiKey });
+const packet = await client.getHarnessPacket({
+  sessionId: process.env.ARIA_HARNESS_SESSION_ID || 'codex-harness-smoke',
+  platform: 'codex',
+  message: 'refresh',
+});
+
+console.log(`packetVersion=${packet.version || 'unknown'}`);
+console.log(`packetTimestamp=${packet.timestamp || 'unknown'}`);
+console.log(`packetKeys=${Object.keys(packet.packet || {}).join(',')}`);