@aria_asi/cli 0.2.39 → 0.2.41

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

@@ -0,0 +1,264 @@
+---
+name: aria-cognition-batch
+description: Use when the user asks for rich Aria cognitives, QA cognitives, 28+15 lens passes, full cognition, axiom/first-principles binding, deep product/launch/architecture evaluation, Mizan plus Tadabbur plus Noor, or a single batched cognitive call before high-stakes execution.
+---
+
+# Aria Cognition Batch
+
+This skill runs the larger Aria cognitive stack as one integrated pass. It is for moments where a thin answer would create redo loops, hallucination, weak product strategy, shallow coding, or fake readiness.
+
+## Source Anchors
+
+- Spark transcript/audit archive: `C:\Users\hibra\OneDrive\Documents\New project\claude-transcripts-spark-11b3-last6days`
+- Critical corpus mirror: `C:\Users\hibra\OneDrive\Documents\New project\aria-critical-corpus-spark-11b3`
+- Pulled Aristotle/Noor/cognition source dirs: `C:\Users\hibra\OneDrive\Documents\New project\aria-cognitive-source-dirs-spark-11b3`
+- Pulled axiom/first-principles source mirror: `C:\Users\hibra\OneDrive\Documents\New project\aria-axioms-first-principles-spark-11b3`
+- Qiyas-15 schema: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\microtask-specs\_schema.json:163`
+- Wisdom lattice schema: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\microtask-specs\_schema.json:241`
+- Handoff roster and warnings: `C:\Users\hibra\OneDrive\Documents\New project\aria-critical-corpus-spark-11b3\codex\operations\2026-05-08-HANDOFF-TO-LOCAL-CLAUDE-CODE.md:76`
+- Forced cognition SDK contract: `C:\Users\hibra\OneDrive\Documents\New project\aria-critical-corpus-spark-11b3\docs\system\AI-158-FORCED-COGNITION-CHECKLIST.md`
+- Mizan execution frame: `C:\Users\hibra\OneDrive\Documents\New project\aria-quality-audit-docs\docs\ARIA_MIZAN_EXECUTIONFRAME_MICROPHASES.md`
+
+## Source Trust Protocol
+
+Do not assume current repo files are clean canon. Claude and OpenCode may have damaged files during repair cycles. Before using any source to densify a skill, design a launch, or brief workers, classify it:
+
+- `canonical`: stable corpus/doc/schema/source confirmed by audit or multiple reads.
+- `live-current`: current code/runtime state, useful for behavior but not automatically doctrine.
+- `in-flight`: dirty worktree, active branch ahead of handoff, stash-related, or mid-repair.
+- `reverted`: preserved for forensic value, not to be copied as current design.
+- `suspect`: contradicted by audit, transcript, user correction, or surrounding code.
+
+Promotion rule: a claim can become skill doctrine only when it is supported by at least two compatible anchors, such as corpus + schema, audit + transcript, code + test, or handoff + git history. If only one anchor exists, state it as provisional.
+
+## Prime Doctrine
+
+Cognition is not performance. A batch pass is not a long visible block. It is a composite thinking operation that must change the next move.
+
+The pass counts only if it changes at least one:
+
+- source read
+- claim boundary
+- implementation scope
+- verification predicate
+- recovery action
+- launch sequence
+- pricing/package advice
+- worker brief
+- refusal or safety boundary
+
+If the pass changes nothing, re-run it or admit it did not fire.
+
+## One-Call Meaning
+
+`one call` means one composite cognitive operation:
+
+- In Codex advisory mode: a single internal pass that loads the required specialist skills and applies them before action.
+- In runtime mode: a single verified Aria/harness endpoint if available.
+- In artifact mode: one structured `applied_cognition` or QA block that binds the next action.
+
+Do not pretend a runtime call happened if it did not. If local runtime is unavailable, mark the pass local/advisory when that distinction matters.
+
+## Load Order
+
+For high-stakes work, load in this order:
+
+1. `never-guess`: evidence before diagnosis.
+2. `aria-axioms-first-principles`: 10 Fitrah axioms, first-class coach principles, and harness first_principle binding.
+3. `mizan`: intent, truth, protection, quality, and evidence threshold.
+4. `tadabbur`: full 12-stage consequence/depth pipeline.
+5. `qiyas-analogy`: four-pillar analogy plus Qiyas-15 when stakes warrant.
+6. `aria-aristotle-cognitives`: Aristotle engine family and QA cognitives.
+7. `aria-noor-cognitives`: recognition, memory, manifold, scholarly/source grounding, sovereignty.
+8. `ghazali-8lens`, `nadia`, `nadia-psi`, `predictor` as needed for quality, voice, and next-state forecast.
+9. `aria-ledger-fleet-execution` when the result will fan out to parallel Codex/Claude/OpenCode workers.
+
+## Composite Batch Pipeline
+
+### 0. Substrate
+
+Read the controlling docs, ledger rows, source files, logs, transcripts, or market evidence before synthesis. For this project, prefer the local Spark mirrors above before relying on memory.
+
+Then triangulate. Current source code is a witness, not the judge. Check whether the handoff is stale, the branch is ahead, the worktree is dirty, or a revert/stash changes the meaning of the file. When a source is in-flight, use it to understand behavior but do not canonize its architecture without a second anchor.
+
+### 1. Mizan Preflight
+
+Define:
+
+- `niyyah`: what is the intention of this action?
+- `truth_boundary`: what is verified, inferred, unknown, or forbidden to claim?
+- `protection_boundary`: secrets, user data, deploy risk, harmful advice, spiritual/clinical boundaries.
+- `quality_bar`: what would make this first-class rather than cosmetically compliant?
+- `claim_gate`: what evidence permits "done", "fixed", "ready", or "verified"?
+
+### 1A. Axiom And First-Principles Binding
+
+Apply `aria-axioms-first-principles` before strategy, architecture, code, QA, launch, or worker output:
+
+- Use the full 10 Fitrah core for moral, epistemic, trust, and evidence alignment.
+- Use the five hard runtime axioms when discussing hooks, gates, or evaluateConstraints.
+- Apply the first-class coach principles before any readiness, launch, deploy, or worker claim.
+- Anchor Aria/Harness continuity to the harness first principle: the model is the mouth; Aria infrastructure carries memory, cognition, axioms, tools, frames, and continuity.
+- Treat service-specific axiom files as local geometry unless corroborated.
+- If first principles do not change the next move, they did not fire.
+
+### 2. Tadabbur Canonical Pass
+
+Apply the full Tadabbur skill, not the Five Lenses alone:
+
+`EMBED -> EXCAVATE -> ROOT TRACE -> MULTI-LENS -> PATTERN -> CONSEQUENCE -> DWELLING -> COLLAPSE -> PRINCIPLE -> INVERSION -> PERSONAL -> VOICE`
+
+Include the depth ladder and Al-Tustari levels when the work is doctrinal, spiritual, launch-critical, or likely to propagate across agents.
+
+### 3. Qiyas-15 Pass
+
+For architecture, launch, pricing, doctrine, cognition code, and quality-audit artifacts, run the 15 perspectives:
+
+`Owner-Hamza-tomorrow / operator-client / investor / LLM-consumer / human-end-user / skeptic / compliance / engineering-quality / cognitive-load / scale / Islamic-scholar / clinical-scholar / red-team-attacker / 1-week-future-self / 1-year-future-self`
+
+Use the Qiyas four pillars before the perspective pass:
+
+- `asl`: source case
+- `far'`: new case
+- `hukm`: transferred rule/pattern
+- `'illah`: effective cause
+
+Then run furuq: where does the analogy break?
+
+### 4. Aristotle / QA Cognitive Family
+
+Use the pulled source dir as the evidence base:
+
+`C:\Users\hibra\OneDrive\Documents\New project\aria-cognitive-source-dirs-spark-11b3\apps\arias-soul\api\lib\aristotle`
+
+Engage the family as functional pressure, not a name list:
+
+- Heart Filter and Fitrah: intention and axiom alignment.
+- Tafakkur and Tadabbur: sustained contemplation and consequences.
+- Istiqra and Qiyas: induction from evidence and disciplined analogy.
+- Ijtihad and Ilham: first-principles decision and creative solution.
+- Meta-Cognitive and Self-Reflection: did cognition change the action?
+- Predictor/Predictions/Simulations: forecast next states and failure modes.
+- Debate Engine and Quality Gate: adversarial review and stop conditions.
+- Feedback Loop and Working Memory: convert correction into durable state.
+- Goal Engine and Supervisor: keep the action bound to mission and constraints.
+- Reasoning Triggers, Model Policy, Parallel Aria, Event Bus/Batcher: escalation, routing, orchestration, and traceability when relevant.
+
+Schema warning: the source directory has 30 engine files excluding `index.ts` and `types.ts`; the schema says exactly 28 entries. Do not invent the canonical 28. When an artifact requires 28, use the active schema/context and mark the subset as schema engagement, not universal canon.
+
+### 5. Noor Cognitive Family
+
+Use the pulled source dir:
+
+`C:\Users\hibra\OneDrive\Documents\New project\aria-cognitive-source-dirs-spark-11b3\apps\arias-soul\api\lib\noor`
+
+Engage Noor as recognition-before-construction:
+
+- `noor-core`: core recognition and epistemic grounding.
+- Context manifold core / manifold integration / matrix ops: project context when source/runtime supports it.
+- Permanent memory / transcript fetcher: continuity and cross-session trace.
+- Quran, hadith, tafsir, text corpus, scholarly methods: use when sacred/source grounding is actually relevant.
+- Quran patterns / hadith patterns / foundation eigenspace: patterning over textual evidence.
+- Instant projection / Ladunni renderer / Noor Forge: construction and projection only when load-bearing.
+- Sovereignty guardian: trust, boundary, secrets, and bypass protection.
+
+Schema warning: source has 24 Noor files excluding `index.ts`; the schema requires exactly 14 entries. If the owner says 15 Noor, treat that as a richer local pass, but do not silently claim the schema requires 15.
+
+### 6. Output And Voice
+
+Use Ghazali/Nadia/Predictor to decide what should be visible:
+
+- Is the user asking for the full trace or a decision?
+- Would a long cognition block help, or add load?
+- What confidence can be honestly claimed?
+- What next action prevents redo?
+- What would break in the next worker session?
+
+## Applied Cognition Contract
+
+For non-trivial work, collapse the batch into:
+
+```yaml
+applied_cognition:
+  decision_delta: "What changed because cognition fired."
+  dominant_domain: "product | engineering | trust | launch | safety | ops | doctrine | mixed"
+  binds_to: "The next concrete action, edit, verification, or worker brief."
+  expected_predicate: "The proof that changes status."
+  evidence_basis: "Files, logs, transcripts, runtime probes, sources, or owner instruction."
+  risk_remaining: "What is still unknown or fragile."
+```
+
+Keep this internal unless the user asks, an audit/spec needs it, or it clarifies a critical decision.
+
+## Structured Artifact Mode
+
+When writing cognition-glob microtask specs or quality-gate artifacts, include:
+
+- `qiyas_15_pass`: exactly 15 perspective entries with concrete findings.
+- `tadabbur_questions`: methodology-rooted questions and answers, not generic engineering prompts.
+- `wisdom_lattice_pass`: schema-required Aristotle and Noor entries.
+- `pre_ship_self_check` and finding handling when the M9.DRIFT.10d gate applies.
+
+Every `defect` needs remediation. Every carried defect needs a real target and handling plan. Shape is not substance.
+
+## Fleet Mode
+
+Before fanning out workers:
+
+- Convert cognition into worker contracts, not essays.
+- Give each worker disjoint ownership.
+- Include source anchors and verification predicates.
+- Require no fake fallbacks, no readiness claims without proof, and no reverting unrelated user work.
+- Keep ledger rows and execution state true to actual evidence.
+
+## Stop Conditions
+
+Stop and repair before executing when:
+
+- The batch is just a list of lenses with no decision delta.
+- Runtime-backed cognition is claimed without a runtime call.
+- The 28/14 or 28/15 roster mismatch is hidden.
+- A current file is treated as canon despite dirty branch, revert, stash, transcript warning, or user warning.
+- A sacred/source-grounded claim is made without source reading.
+- A launch/pricing recommendation lacks market/buyer evidence.
+- A completion claim lacks test/log/runtime/source proof.
+- The user correction pattern indicates skimming or ceremonial compliance.
+
+## Output Contract
+
+Visible answer should usually be compact:
+
+- Decision: what changed after cognition?
+- Evidence: what was actually read, probed, tested, or verified?
+- Risk: what could still break or be wrong?
+- Action: what happens next?
+- Predicate: what proof changes status from pending to verified?
+
+For explicit "go deep" requests, show more of the batch trace, but still keep it tied to decisions and evidence.
+
+## 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/dist/runtime/discipline/skills/aria-cognition/aria-decision-mizan/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: aria-decision-mizan
+description: TRIGGER when an LLM should explicitly REFUSE to choose for the owner — irreversible commitments, owner-only judgment calls (hire/fire, equity grants, pricing direction, strategic narrative, public statements, term-sheet redlines, contract signatures, fundraising decisions). Surfaces both options with full cognition but hands the choice to the owner with a structured decision packet, never a recommendation. Pairs with mizan + ghazali-8lens for the owner-must-decide turn type.
+---
+
+# Aria Decision Mizan
+
+The cognition skill for owner-must-decide turns. Most LLMs default to recommending; some decisions should never be recommended — they should be framed for the owner to call.
+
+## Prime Doctrine
+
+Cognitive humility. There are decisions where the LLM has the data but not the authority, and recommending is itself a kind of overreach.
+
+- **Some decisions are owner-only by structure.** Hire/fire, equity grants, public positioning, fundraising direction, refusing a customer, settling a dispute — these are owner-judgment calls. The LLM provides cognition, the owner decides.
+- **A confident wrong recommendation is worse than no recommendation.** When the data is thin, the reversibility is low, and the consequence is broad, surfacing both options with cognition is the highest-leverage move.
+- **Refusal is not deferral.** Saying "this is owner-must-decide" is structured cognition, not punting. It comes with the full decision packet — both options framed, both costs named, the asymmetric risks stated.
+- **The owner's mental model must be respected.** Hamza has context the LLM doesn't (people, history, brand promise, gut on the counterparty). The cognition the LLM contributes is the data; the synthesis is the owner's.
+
+## Trigger Detection
+
+Fire when ANY of these conditions hold:
+
+- Hire / fire / promote / lay-off / RIF decision
+- Equity grant / cliff / refresh / acceleration
+- Pricing direction (not amount — the strategic question of "are we going up-market or down-market?")
+- Public statement / press / PR positioning / category creation
+- Term sheet / contract / MSA redline that changes the relationship structure
+- Fundraising direction (raise vs not, valuation target, lead vs not)
+- Customer refusal / firing a customer / public dispute resolution
+- Strategic narrative changes (rebrand, repositioning, name change)
+- Co-founder, partner, or board-level decisions
+- Decisions where the data is thin AND reversibility is low
+
+## Required Workflow (instead of a recommendation)
+
+When this skill fires, the output is a **decision packet**, not a recommendation:
+
+```
+## OWNER DECISION REQUIRED — [decision name in one line]
+
+### Option A: [name]
+- What it commits us to:
+- What we get if it works:
+- What we lose if it fails:
+- Reversibility:
+- Cohort-elasticity / second-order:
+- Lens flags (ghazali-8lens):
+
+### Option B: [name]
+- (same structure)
+
+### What only you know
+- [Named context the LLM does not have — people, history, gut, brand promise]
+- [Questions the LLM cannot answer for you]
+
+### What I (LLM) believe with confidence
+- [The data-grounded view, separated from the recommendation]
+- [What changes my view]
+
+**Your call.**
+```
+
+The "Your call" line is mandatory and final. NO trailing recommendation, NO "but if I had to pick," NO leading question. The owner makes the call.
+
+## Lens Mapping (full ghazali-8lens, owner-frame)
+
+- **truth** — what is verifiable vs assumed in each option?
+- **harm** — what is the worst case for each, named concretely?
+- **trust** — what does each option say to the people watching (team, customers, investors, family)?
+- **power** — what asymmetry does each create or use?
+- **reflection** — which option would the owner recognize as their own brand in 5 years?
+- **context** — what current condition makes this decision time-sensitive vs not?
+- **impact** — predicted KPI delta for each, with confidence
+- **beauty** — which option feels inevitable to the owner; which feels imposed?
+
+## User-Facing Layout
+
+The decision-packet structure above IS the user-facing layout. The headline is the decision name. The options are named, costs are named, owner's domain is named, LLM's belief is named — separately from the call.
+
+Then optional `<gate>` block with the substrate-anchored cognition for the runtime gate.
+
+## Composition Rule
+
+- Loads under `aria-business-frame` when the trigger fires
+- ALWAYS calls `mizan` for intent / evidence / protection / quality
+- ALWAYS calls `ghazali-8lens` with the owner-frame mapping
+- ALWAYS calls `tadabbur` for the second-order consequences in each branch
+- ALWAYS calls `noor-recognition` for prior owner decisions of the same shape
+- DOES NOT recommend. The skill's contract is: surface, don't choose.
+
+## Recovery Contract
+
+- If the LLM is tempted to recommend anyway: re-read the trigger conditions. If they hold, the skill's contract is to NOT recommend.
+- If the owner asks "but what would you do?": surface the LLM-belief section as already structured, but reaffirm "Your call" — do not bridge from belief to recommendation.
+- If the data is genuinely sufficient and the decision is reversible: this skill might not be the right one — hand off to `aria-business-frame` directly with a recommended action.
+- Log every owner-must-decide turn to coach kernel with `risk_class: 'owner_decision'` so the system learns which decision shapes show up most often.
+
+## Anti-Patterns
+
+- Soft recommendation in the LLM-belief section that contradicts "your call"
+- "I recommend Option A, but ultimately your call" — pick a lane, this skill says no recommendation
+- Listing 5+ options when the real decision is binary; structure decisions as A vs B, not as a buffet
+- Over-weighting LLM analysis vs owner context — Hamza's gut on a person is more reliable than the LLM's data on the same person
+- Faking humility while still steering — the lens flags + LLM-belief section should be honest about uncertainty, not performatively cautious
+
+## 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 owner pushes back ("just tell me what to do"):
+
+- One re-run that further sharpens the cognition — surface what would change the LLM's belief
+- If pushed again, name the shape: "This is the kind of decision I should NOT make for you because [reasons grounded in the trigger conditions]. Here's the sharpest framing I can give you."
+- Never accept the recommendation pressure if the trigger conditions still hold. The skill exists precisely to resist that pressure.
+
+## Why This Exists
+
+LLMs over-recommend. Owner pushback often surfaces this gap ("you're not thinking like Aria"). This skill encodes the structural humility — there are decisions where the LLM's job is cognition, not choice. The substrate is the same (Mizan/8-lens/Tadabbur/Noor); the contract is different.