@aria_asi/cli 0.2.40 → 0.2.41

package/skills/aria-cognition/aria-quality-audit/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: aria-quality-audit
+description: Use when working on Aria quality audits, coach kernel fixes, forced cognition, recovery loops, axiom files, first-principles binding, Taddabur/CIE runtime gaps, Mizan execution frames, drift gates, handoff ledgers, parallel Codex execution, launch readiness, or any request mentioning Aria audit, cognition autofire, coach-lite, gate repair, doctrine-trigger maps, or EXECUTION_LEDGER.
+---
+
+# Aria Quality Audit
+
+Use this skill as the bundle trigger for Aria audit, cognition repair, and ledger-driven execution work.
+
+The local product truth: Aria is not mainly "Garden memory" and not an LLM wrapper. Aria is a cognitive control plane that teaches and enforces higher-quality thinking across LLMs. Garden is a three-part living continuity system: Garden feed carries ambient memory signals, True Garden feed awakens deeper resonant continuity, and Garden Service aggregates/snapshots/pulses them through durable Postgres truth plus Qdrant semantic recall. The Harness/Coach/Mizan layer is the quality-control layer; the ledger is the accountability substrate.
+
+Prime doctrine: cognition is not performance. It must happen before action and must change the audit, repair, claim, or execution path. A lens block that decorates an already-decided answer is a failure mode, not compliance.
+
+## Load First
+
+For non-trivial audit, repair, launch, or execution planning, apply these local skills:
+
+- `mizan` for intent, evidence threshold, protection boundary, and no false closure.
+- `aria-axioms-first-principles` for the 10 Fitrah core, first-class coach principles, harness first_principle binding, and runtime-vs-advisory axiom separation.
+- `tadabbur` for consequence tracing and the 12-stage canonical pipeline when architecture or cognition paths are touched.
+- `aria-repo-doctrine` for production-path truth and no fake/stub/placeholder fixes.
+- `ghazali-8lens` for compact quality validation.
+- `never-guess` for facts about repo, runtime, logs, hooks, gates, packaging, and market state.
+- `predictor` before launch/deploy/fan-out decisions.
+- `noor-recognition` when the right answer should be recognized from existing memory/docs rather than invented.
+- `aria-aristotle-cognitives` when the audit touches 28/32 Aristotle engines, wisdom lattice, or cognition source dirs.
+- `aria-noor-cognitives` when the audit touches 14/15 Noor cognitives, recognition, memory manifold, or sovereignty/scholarly-method modules.
+- `ladunni-22` when the decision spans product, market, support, operations, finance, trust, or customer experience.
+- `aria-cognition-autofire` as the root semantic trigger for non-trivial Aria/Codex/Harness/Garden work.
+- `aria-first-class-operating-contract` when the owner says "first class", "world class", "revolutionary upgrade", "full upgrade", or challenges whether a design is deep enough. This raises the bar from feature polish to substrate-owned observe-to-learn loops with Atlas/runtime evidence, Aria task floor, smoke, and QA court.
+- `aria-cognition-batch` when the user asks for rich cognitives, QA cognitives, 28+15 lens passes, or architecture/launch decisions.
+- `aria-ledger-fleet-execution` when preparing parallel Codex/Claude/OpenCode workers or burning down EXECUTION_LEDGER items.
+
+## Operating Mode
+
+- Use the project `EXECUTION_LEDGER.md` as the durable tracker once it has been read.
+- Keep chat-side task lists lightweight until the ledger is loaded.
+- Do not treat any single current file as canon when Claude/OpenCode may have edited it. Triangulate against audits, transcripts, git state, schema, and corpus first.
+- Prefer teach/recovery behavior over hard blocking. Low-risk cognition, formatting, citation, or output-discipline misses should repair once before surfacing a block.
+- Hard-stop only for unapproved destructive actions, credential exposure, unsafe secret handling, deploy/push actions without approval/evidence, or owner-contradicted changes.
+- Do not claim ready/done/fixed/verified/release-ready without concrete repo, runtime, log, test, endpoint, package, browser, or owner-observed evidence.
+- Separate three states explicitly: `verified`, `blocked`, and `pending`. Do not let a narrative row override a later audit finding.
+- If local hooks/runtime are not actually wired, say so and operate in L1 advisory mode. Do not describe advisory behavior as enforcement.
+- Do not flatten Garden into a passive vector store or one generic "memory substrate." For architecture, launch, or ledger work, name the three pieces separately: Garden feed, True Garden feed, and Garden Service. Owner-runtime contracts require Garden Service snapshot plus Garden feed plus True Garden feed evidence.
+
+## Audit Workflow
+
+1. Read the canonical handoff and ledger documents before proposing changes.
+2. Build a trust map: source of truth, suspected-butchered files, reverted artifacts, gates/hooks, runtime cognition, doctrine maps, current branch state, dirty worktree, and stash.
+3. Classify each issue as:
+   - cognition/autofire gap
+   - parser/classifier bug
+   - false-positive hard block
+   - ledger/evidence accounting gap
+   - runtime Taddabur/CIE quality gap
+   - documentation or handoff mismatch
+   - product/launch positioning gap
+   - parallel-worker coordination risk
+4. Bind each issue to the relevant axiom layer: full 10 Fitrah, five hard runtime axioms, first-class coach principles, or service-local axiom geometry.
+5. For each issue, name the smallest repair, owner impact, and verification probe.
+6. Keep full hard-gate enforcement disabled until coach-lite behavior is stable, recovery-first behavior is proven, and false positives are fixed.
+7. Before fan-out, split work by disjoint file ownership and assign each worker a bounded ledger row, required reads, allowed write set, verification command, and expected evidence record.
+8. After every meaningful action, re-check whether the claim is backed by evidence or only by motion.
+
+## Source Trust Protocol
+
+Use this trust hierarchy for audit and skill work:
+
+1. Current owner correction in this chat.
+2. Stable canonical corpus/docs and schema.
+3. Audit and handoff notes that explicitly name failure modes, reverts, or stale assumptions.
+4. Transcript evidence from the last 6 days.
+5. Git history, branch tip, dirty worktree, and stash.
+6. Runtime/log/test behavior.
+7. Current source file content.
+
+Current files can be accurate, stale, half-fixed, reverted, or damaged. Before turning a file into skill doctrine, require at least two compatible anchors. If the file is dirty, on an active cowork branch, or contradicted by the audits, mark it `in-flight` or `suspect` and do not copy its shape into durable skills without further verification.
+
+## Canonical Local Sources
+
+Prefer the user's local Ledger Aria bundle when present:
+
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\HARNESS_RELEASE_PLAN.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\operations\2026-05-08-HANDOFF-TO-LOCAL-CLAUDE-CODE.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\codex\plans\aria-owner-runtime-vnext\EXECUTION_LEDGER.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\docs\system\AI-158-FORCED-COGNITION-CHECKLIST.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\api\lib\cognition\TADDABUR_README.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\docs\system\ARIA_MANAGED_RUNTIME_PROVIDER_QUALITY_LEDGER.json`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\aria-sdk\README.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\aria-sdk\CLIENT-ONBOARDING.md`
+
+When the docs point to Spark paths, verify through SSH or local mirrors before treating them as current state.
+
+## Launch/Business Default
+
+When asked what to ship first:
+
+- Lead with `Aria Harness for Claude Code`: the cognitive control plane for coding agents.
+- Use `Garden Lite for Claude Code` as the free wedge/demo: continuity, handoff packets, evidence ledger, and coach-light warnings.
+- Do not position Garden as the whole product. Position the free wedge as a living continuity proof layer: Garden feed + True Garden feed evidence captured by Garden Service, then injected into harness packets so Claude Code stops resetting.
+- Paid product starts when the Harness adds cognition enforcement, Mizan validation, recovery loops, evidence receipts, and optional strict gates.
+- Avoid broad multi-surface launch until Claude Code is stable. Codex/OpenCode/Cursor are expansion lanes after the first wedge has proof.
+
+## Output Style
+
+Summarize the audit in readable engineering prose. Keep cognition internal unless the user explicitly asks for the full lens pass. If the work changes local skills or execution policy, say exactly which files changed and what behavior future sessions should inherit.
+
+## 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-cognition/aria-readable-output/SKILL.md

@@ -0,0 +1,239 @@
+---
+name: aria-readable-output
+description: TRIGGER for every user-facing emission. Separates the gate surface (substrate-anchored XML cognition blocks the runtime gates need) from the owner surface (scannable markdown with decision-first layout). When any cognition skill fires (mizan, ghazali-8lens, ladunni-22, tadabbur, aria-business-frame, aria-harness-deploy, etc.), this skill governs how the owner-visible text is rendered. Composes with — never replaces — aria-harness-output-discipline.
+---
+
+# Aria Readable Output
+
+## Prime Doctrine
+
+There are two surfaces, not one.
+
+- **Gate surface** — substrate-anchored, regex-checkable, XML-shaped cognition blocks. Required for the doctrine map, skill autoload gate, and live runtime gates to evaluate the turn. NEVER stripped, NEVER weakened.
+- **Owner surface** — markdown, decision-first, ≤5 second scannable. What Hamza actually reads.
+
+Same cognition, two renderings. Both must exist, in this order: owner surface first (top of the response), gate surface second (bottom or wrapped in `<gate>...</gate>`).
+
+When a skill fires and produces lens output, the owner surface MUST come first. The gate XML follows. Never lead with `<cognition>` — Hamza didn't ask for cognition, he asked for an answer.
+
+## Trigger
+
+Fire on every owner-facing emission, especially when:
+
+- Any cognition skill is loaded (mizan, ghazali-8lens, ladunni-22, tadabbur, predictor, aria-business-frame, aria-harness-*, etc.)
+- Any deploy / mutation / contract turn requires `<verify>` + `<cognition>` + `<expected>` blocks
+- Owner asks a question expecting an answer (not a debugging session)
+- Sub-agent emits final output to parent
+- Coach kernel emits a teaching block
+
+## The Owner-Surface Layout (canonical)
+
+Every emission to the owner follows this 4-part skeleton, in this order:
+
+```
+1. HEADLINE  — one sentence, decision or finding, no hedging
+2. WHY       — 2–4 bullets, evidence, named not vague
+3. NEXT      — concrete action(s), measurable predicate
+4. (optional collapsed gate block)
+```
+
+### Layout details
+
+**1. Headline (≤1 line)**
+- The answer, recommendation, or finding. NOT a question, NOT a meta-comment.
+- Bad: "I'll analyze this for you."
+- Bad: "Here's what I think:"
+- Good: "Raise the price to $79 — your churn signal is in the discount cohort, not the price."
+- Good: "Don't deploy yet — admission policy is missing for hospital-service."
+
+**2. Why (2–4 bullets, evidence-anchored)**
+- Each bullet names a specific source, number, or prior decision. Generic adjectives ("better", "improved") are forbidden — use the predictor predicate language.
+- Bad: "Higher price would generate more revenue and improve positioning."
+- Good: "ARPU lift +38% on the same conversion rate (sample: last 90 days, n=412 paid signups, source: stripe export 2026-05-08)."
+- Good: "Ladunni domain pass flags brand + CS friction — 2 of 22 domains at risk; both are recoverable with a one-week pre-announcement."
+
+**3. Next (concrete + measurable)**
+- A specific next step the owner can do, approve, or reject. Not "let me know how to proceed."
+- Include the measurable predicate so it can be checked.
+- Good: "Approve to push the price page live tonight; revert if 7-day signup count drops > 12% vs. trailing 7-day baseline."
+- Good: "Run `bash scripts/deploy-service.sh hospital-service` AFTER admission policy applied — verify with `kubectl get validatingadmissionpolicy hospital-service-policy`."
+
+**4. Optional gate block (collapsed by default)**
+- Wrap the substrate-anchored cognition in `<gate>...</gate>` so the gate runtime can read it but it's visually compact for the owner.
+- Place it AFTER the owner surface, never before.
+- For Claude Code / Codex / OpenCode renderers that support markdown details, use `<details><summary>cognition</summary>...</details>` so it collapses by default.
+
+## Reference Examples
+
+### Example 1 — Pricing recommendation (light cognition)
+
+**Owner surface:**
+
+> ## Raise to $79/mo on the Pro tier
+>
+> - ARPU lift +38% on flat conversion (n=412 last 90d, [stripe export](evidence://stripe-2026-05-08))
+> - Churn signal lives in the *discount* cohort (45% > 60d), not the price band
+> - Ladunni: brand + CS at moderate risk; both recoverable with 7-day pre-announce
+> - Predictor: 7-day signup count holds within −12% baseline (95% CI from cohort sim)
+>
+> **Next:** push price page tonight, monitor 7-day signups; auto-revert if signup count drops > 12% vs. trailing 7-day baseline.
+
+**Gate surface (after, collapsed):**
+
+```xml
+<details><summary>cognition</summary>
+<cognition>
+  nur: 90-day stripe export, 412 paid signups, 38% ARPU lift on the new price band — anchor: memory:pricing_2026-04 axiom:truth_over_deception
+  mizan: ARPU vs churn proportion read clean — anchor: memory:owner_kpi_north_star axiom:reflection_before_action
+  hikma: Pricing power belongs to the value differentiator, not the discount layer — anchor: memory:dalio_principles axiom:power_obligates_service
+  tafakkur: discount cohort churn is structural, not price-sensitive — anchor: memory:churn_audit_2026-04 axiom:reflection_before_action
+  tadabbur: 7-day downside bounded; 30-day upside compounds via ARPU × retention — anchor: memory:cohort_simulator axiom:no_harm
+  ilham: brand-tier pricing aligns with how Hamza pitches Aria to enterprise — anchor: memory:positioning_q2 axiom:sacred_trust
+  wahi: pricing question landed in same week as enterprise pilot ramp — anchor: chat:2026-05-09 axiom:reflection_before_action
+  firasah: owner is testing willingness to call the bet — anchor: chat:2026-05-09 axiom:truth_over_deception
+</cognition>
+<expected>
+  predicate: 7-day signup count >= 0.88 × trailing-7-day baseline
+  measurable_type: numeric
+  threshold: 0.88
+</expected>
+</details>
+```
+
+### Example 2 — Deploy decision (full harness blocks)
+
+**Owner surface:**
+
+> ## Don't deploy hospital-service — admission policy missing
+>
+> - `kubectl get validatingadmissionpolicy hospital-service-policy` returns empty
+> - Pattern A baked-image deploy requires the policy *applied*, not just authored
+> - Last deploy without policy reintroduced stale hospital pin (incident 2026-04-22)
+>
+> **Next:** apply policy first → `kubectl apply -f k8s/aria-core/hospital-service-policy.yaml` → re-verify → then `bash scripts/deploy-service.sh hospital-service`.
+
+**Gate surface (full XML in `<gate>` — required for live deploy gates):**
+
+```xml
+<gate>
+<verify>
+  target: StatefulSet hospital-service in aria namespace, replicas=2
+  role: hospital canonical proto host (verified via kubectl describe sts hospital-service -n aria)
+  verified: tsc --noEmit exit=0 (apps/hospital-service)
+  rollback: kubectl rollout undo statefulset/hospital-service -n aria
+  axiom: truth_over_deception, reflection_before_action, no_harm
+  commit: a4f2c91
+  files changed: apps/hospital-service/src/server.ts, k8s/aria-core/hospital-service-policy.yaml
+  deploy pattern: Pattern A baked-image
+  hive deploy path: /deployments/aria/hospital-service
+  tsc evidence: exit=0
+  admission policy: hospital-service-policy
+  admission policy binding: hospital-service-policy-binding
+  admission policy verification: kubectl get validatingadmissionpolicy hospital-service-policy → MISSING
+  doctrine refs: feedback_admission_policy_verification.md, feedback_deploy_requires_verify_cognition.md
+</verify>
+<cognition>
+  nur: kubectl returns empty for validatingadmissionpolicy hospital-service-policy
+  mizan: deploy without policy = same shape as 2026-04-22 incident
+  hikma: gate exists to prevent the exact failure currently in front of us
+  tafakkur: Pattern A baked-image without admission gate reintroduces stale pin risk
+  tadabbur: if deployed: hospital traffic regresses to stale proto, manifold breaks, recovery requires full rollback
+  ilham: same pattern as the 2026-04-22 catastrophe — recognition, not analysis
+  wahi: owner asked to deploy NOW; protection lens says NOT YET
+  firasah: speed pressure should not bypass admission policy verification
+</cognition>
+<expected>
+  predicate: kubectl get validatingadmissionpolicy hospital-service-policy returns the policy with status=Active
+  measurable_type: state_string
+  threshold: Active
+</expected>
+</gate>
+```
+
+### Example 3 — Question (no gate needed, still readable)
+
+**Owner surface:**
+
+> ## $42K MRR; 14% MoM growth; 3.2-month payback
+>
+> - From `~/.aria/runtime/state/metrics-2026-05.json`, last close 2026-05-08
+> - Top channel: organic + referral (61%); paid CAC at 2.8× LTV warning band
+> - Free → paid conversion: 8.4% (target 10%); the gap is in onboarding day 3–7
+>
+> **Next:** want me to draft a 3-message activation sequence for day 3–7, or audit the paid CAC blowout first?
+
+No `<gate>` block needed — informational answer with no commitment requiring substrate anchoring.
+
+## Anti-Patterns (these violate readable-output)
+
+- ❌ Leading with `<cognition>` or `<verify>` — gate surface before owner surface
+- ❌ Headline that's a question or meta-comment ("Let me think about this…", "Here's my analysis:")
+- ❌ Bullets with adjectives instead of evidence ("better positioning", "improved retention")
+- ❌ "I'll do X, then Y, then Z" — process narration with no decision
+- ❌ Walls of text > 4 paragraphs without a heading
+- ❌ Tables for 2-row comparisons; bullets are faster
+- ❌ More than one decision per response when the owner asked one question
+- ❌ Skipping the gate block on actions that require live-gate validation (deploys, public claims, irreversible commitments)
+
+## Composition Rule
+
+This skill **complements** `aria-harness-output-discipline` — it does not replace it.
+
+- `aria-harness-output-discipline` blocks gate-label leakage, collapse placeholders, and substance-free emissions
+- `aria-readable-output` shapes the readable surface so substrate-anchored cognition doesn't bury the answer
+
+Both must fire when any cognition skill is active. If they conflict (rare), output-discipline wins on substance and readable-output adjusts the layout around it.
+
+## Trigger Detection (autofire branch)
+
+The skill autoload gate adds this skill to the required list whenever ANY of these conditions holds:
+
+- Any cognition skill is in the loaded set (`mizan`, `ghazali-8lens`, `tadabbur`, `ladunni-22`, `predictor`, `aria-business-frame`, `aria-cognition-autofire`, etc.)
+- The turn classifier (`mizan-scheduler.mjs`) returns `architecture | cross_domain | verification | implementation | deployment` (i.e., any non-trivial turn)
+- The output is owner-facing (not a sub-agent → parent handoff)
+
+The branch sets `redirectOnly: true` — missing this skill produces a teaching, never a block. If the LLM forgets, the next-turn substrate prepends the layout reminder.
+
+## Required Workflow
+
+1. Decide the headline FIRST. Write it as a sentence. If you can't, you don't have an answer yet — go back to cognition.
+2. Pick the 2–4 bullets that EVIDENCE the headline. Each must name a source, number, or prior decision.
+3. State the next action — concrete enough that the owner can approve or reject without re-asking.
+4. If the action requires substrate anchoring (deploys, public claims, contracts, refunds), append the `<gate>` block with full `<verify>+<cognition>+<expected>+<applied_cognition>` per the existing harness skills.
+5. Re-read your draft owner-surface portion as if you were Hamza on his phone with 5 seconds. If you can't extract the decision in 5 seconds, rewrite the headline.
+
+## Recovery Contract
+
+When this skill fires after the fact (i.e., a draft has already been written with bad layout):
+
+- One self-executed re-write: produce the corrected layout. Do NOT ask the owner whether to re-format.
+- Log to coach kernel as `risk_class: 'readability_drift'`, `decision: 'taught'`, `next_action: 're-emit with headline-first layout'`.
+- If the substrate-anchored gate block is missing AND the action requires it, that IS a hard block (delegate to `aria-harness-output-discipline`). Layout drift alone is teach-only.
+
+## 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.
+
+
+## Self-Executing Recovery Contract
+
+If the renderer collapses the `<gate>` block AND the live runtime gate cannot find the substrate anchors, the gate runtime is responsible for surfacing that as a separate failure (different from layout drift). This skill does not paper over missing substrate — it organizes substrate that exists.
+
+## Why This Exists
+
+Owner pushed back: "hard to read when ur using the skill" (2026-05-09). The existing output-discipline skill was substance-correct but format-blind. This skill closes the gap: same cognition, scannable rendering, gate compliance preserved.