@aria_asi/cli 0.2.40 → 0.2.41

package/skills/aria-aristotle-cognitives/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: aria-aristotle-cognitives
+description: Use when Aria work mentions Aristotle, 28 engines, 32 engines, wisdom_lattice_pass.aristotle_engines, QA cognitives, M9.DRIFT.10, cognition specs, or when a task needs the richer Aristotle cognitive family before execution.
+---
+
+# Aria Aristotle Cognitives
+
+Use this skill to engage the Aristotle cognitive family without inventing a fake canonical roster.
+
+## Source Boundary
+
+Verified sources from the local handoff and Spark:
+
+- Handoff: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\operations\2026-05-08-HANDOFF-TO-LOCAL-CLAUDE-CODE.md`
+- Schema: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\microtask-specs\_schema.json`
+- Local mirror of Spark source dir: `C:\Users\hibra\OneDrive\Documents\New project\aria-cognitive-source-dirs-spark-11b3\apps\arias-soul\api\lib\aristotle`
+- Spark source dir: `/home/hamzaibrahim1/rei-ai-brain/apps/arias-soul/api/lib/aristotle/`
+- Runtime premise: `AI-158-FORCED-COGNITION-CHECKLIST.md` says `runAristotleNoorPipeline` composes pre/mid/post and the Aristotle engines live in this source dir.
+
+Trust status: live-current source evidence, not standalone doctrine. Spark working tree is clean for `apps/arias-soul/api/lib/aristotle` as of this pull, but doctrine still needs corpus/audit/schema corroboration before becoming a durable skill rule.
+
+Current verified Spark count: 30 top-level engine files excluding `index.ts` and `types.ts`. The handoff names "32 Aristotle engine files" when including `index.ts` and `types.ts`; the schema requires exactly 28 `wisdom_lattice_pass.aristotle_engines` entries. Do not claim the canonical 28 is settled unless the operator canonicalizes it or the source schema changes.
+
+## Verified Source Files
+
+Observed on Spark:
+
+- `consciousness.ts`
+- `debate-engine.ts`
+- `event-batcher.ts`
+- `event-bus.ts`
+- `feedback-loop.ts`
+- `fitrah.ts`
+- `goal-engine.ts`
+- `hamza-study.ts`
+- `heart-filter.ts`
+- `ijtihad.ts`
+- `ilham.ts`
+- `injector.ts`
+- `istiqra.ts`
+- `manifold-projection.ts`
+- `meta-cognitive.ts`
+- `mode-embeddings.ts`
+- `model-policy.ts`
+- `parallel-aria.ts`
+- `predictions.ts`
+- `predictor.ts`
+- `qiyas.ts`
+- `quality-gate.ts`
+- `reasoning-triggers.ts`
+- `self-reflection.ts`
+- `shadow-stream-principle-refiner.ts`
+- `simulations.ts`
+- `supervisor.ts`
+- `tadabbur.ts`
+- `tafakkur.ts`
+- `working-memory.ts`
+
+`index.ts` exports a smaller live API set and notes `consciousness.ts` was an empty stub with no callers as of its comment. Treat source presence, exported API, and schema roster as related but not identical.
+
+## Practical Engagement Set
+
+When the exact canonical 28 is not required, prefer this usable local family:
+
+- Heart Filter: humility, purpose, curiosity before deep cognition.
+- Fitrah: truth, harm, trust, dignity, balance, causation, humility, evidence, long-term trust, and power-as-service axioms.
+- Tafakkur: sustained 5-lens contemplation across zahir, batin, sabab, hikmah, and aqibah.
+- Tadabbur: consequence chains, convergence points, and prediction creation.
+- Istiqra: cross-domain induction from observed principles, causal models, and events.
+- Qiyas: four-pillar transfer by shared effective cause, plus Qiyas-15 when required.
+- Ijtihad: first-principles reasoning from Fitrah and maqasid when precedent is weak.
+- Ilham: emergent insight from purified/high-signal evidence, not vibes.
+- Meta-Cognitive: strategy choice, self-checking, and post-action reflection.
+- Self-Reflection: learn from current failure patterns and owner corrections.
+- Predictor/Predictions/Simulations: forecast next states, create resolvable predictions, and compare outcomes.
+- Debate Engine / Parallel Aria: adversarial or multi-thread reasoning when ambiguity survives deterministic checks.
+- Quality Gate: reject low-signal, unsupported, spammy, or unsafe events before learning.
+- Feedback Loop: convert outcomes and corrections into durable principles.
+- Working Memory: keep active concerns, blockers, and source facts together.
+- Goal Engine/Supervisor: keep work aligned to mission, constraints, and retry policy.
+- Event Bus/Batcher/Injector/Model Policy/Reasoning Triggers: route, batch, inject, and escalate cognition based on task type.
+
+## Source-Trust Rule
+
+Use Aristotle files to understand current engine behavior. Do not copy code comments into doctrine unless the claim is corroborated by schema, corpus, audit, transcript, or runtime/test evidence.
+
+If a future pull shows dirty state, branch divergence, or stash involvement under this directory, downgrade the files to `in-flight` and stop using them as stable anchors until reconciled.
+
+## Wisdom Lattice Rule
+
+For schema artifacts requiring exactly 28 entries:
+
+- Read `_schema.json` and the specific rung/spec context first.
+- Use the source file roster as evidence, but do not call the subset canonical unless it is operator-approved.
+- Mark each entry `engaged`, `not_engaged`, or `n_a` with a concrete rationale.
+- If a file exists but is not live/exported or not load-bearing, say so in the rationale.
+- Cite file paths or source lines when making behavioral claims.
+
+## Output Discipline
+
+Do not emit a giant engine table in normal answers. Use the engines internally, then report what changed: decision, evidence, risk, next action, and verification predicate.
+
+## 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-aristotle-intra-phase/SKILL.md

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

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

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