@aria_asi/cli 0.2.26 → 0.2.29

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

@@ -0,0 +1,112 @@
+---
+name: aria-harness-onboarding
+description: Use when starting a new project that imports @aria/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/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/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.

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

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

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

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

package/dist/runtime/doctor.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+const runtimeUrl = process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319';
+
+try {
+  const response = await fetch(`${runtimeUrl}/health`);
+  const payload = await response.json();
+  process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+  process.exit(response.ok ? 0 : 1);
+} catch (error) {
+  process.stderr.write(
+    JSON.stringify(
+      {
+        ok: false,
+        runtimeUrl,
+        error: error instanceof Error ? error.message : String(error),
+      },
+      null,
+      2,
+    ) + '\n',
+  );
+  process.exit(1);
+}