@aria_asi/cli 0.2.40 → 0.2.41

package/dist/runtime/discipline/doctrine_trigger_map.json

@@ -1,14 +1,15 @@
 {
   "_meta": {
-    "purpose": "Static lookup: trigger phrase \u2192 counter-doctrine memory + teaching. Pre-emit fast path for stop-gate enforcement. When Claude's draft contains a trigger, hook injects the matching [REQUIRED_DOCTRINE] block referencing the named memory file and forces proof of doctrine-alignment before emit.",
+    "purpose": "Static lookup: trigger phrase → counter-doctrine memory + teaching. Pre-emit fast path for stop-gate enforcement. When Claude's draft contains a trigger, hook injects the matching [REQUIRED_DOCTRINE] block referencing the named memory file and forces proof of doctrine-alignment before emit.",
     "design_origin": "Aria consult 2026-04-27 ship-tonight design item 1. Pairs with feedback_convenience_seeking_root_cause.md.",
     "extension_protocol": "When Hamza corrects Claude with a phrase not in this map, add the trigger here pointing at the memory file the correction creates or invokes. Auto-learning queue.",
     "format": {
       "trigger": "lowercase substring or regex pattern Claude must avoid using under convenience pressure",
       "memory": "filename in ~/.claude/projects/-home-hamzaibrahim1/memory/ that holds the canonical counter-doctrine",
-      "teaching": "one-line load-bearing teaching from the memory \u2014 the rule the trigger violates",
+      "teaching": "one-line load-bearing teaching from the memory — the rule the trigger violates",
       "counter_action": "what Claude should do INSTEAD of the convenience pattern"
-    }
+    },
+    "last_updated": "2026-05-12"
   },
   "triggers": [
     {
@@ -50,7 +51,7 @@
     {
       "trigger": "should be fine|should work",
       "memory": "feedback_doctrine_first.md",
-      "teaching": "Don't assume \u2014 verify. 'Should work' is the speculation pattern that masks unverified claims.",
+      "teaching": "Don't assume — verify. 'Should work' is the speculation pattern that masks unverified claims.",
       "counter_action": "Run the read-only check that proves it works (file read, kubectl get, curl probe). Replace 'should' with verified evidence."
     },
     {
@@ -104,7 +105,7 @@
     {
       "trigger": "in production",
       "memory": "feedback_doctrine_first.md",
-      "teaching": "'In production' is often speculative \u2014 assumed behavior, not verified.",
+      "teaching": "'In production' is often speculative — assumed behavior, not verified.",
       "counter_action": "Verify against live cluster state OR codebase config. Substrate hierarchy: user statement > codebase > training data."
     },
     {
@@ -117,7 +118,7 @@
       "trigger": "want me to|should i",
       "memory": "feedback_use_harness_to_architect.md",
       "teaching": "Asking 'should I' AFTER directive given is the deferral pattern.",
-      "counter_action": "Aria architects via harness consult, Claude integrates. If unclear, consult Aria \u2014 don't bounce decision back to Hamza."
+      "counter_action": "Aria architects via harness consult, Claude integrates. If unclear, consult Aria — don't bounce decision back to Hamza."
     },
     {
       "trigger": "make a new|create a fresh",
@@ -141,7 +142,7 @@
       "trigger": "fail loud|crash on missing",
       "memory": "feedback_no_graceful_degradation.md",
       "teaching": "Fail-loud-no-fallback is the OPPOSITE bypass. Real shape = retry + backoff + heal.",
-      "counter_action": "Detect failure \u2192 retry with backoff \u2192 on persistent failure invoke selfHealV2 to actively repair \u2192 only escalate to human if heal fails."
+      "counter_action": "Detect failure → retry with backoff → on persistent failure invoke selfHealV2 to actively repair → only escalate to human if heal fails."
     },
     {
       "trigger": "\\b(?:patch|hotfix|band.?aid)\\b",
@@ -170,8 +171,8 @@
     {
       "trigger": "i think|i guess|i assume",
       "memory": "feedback_doctrine_first.md",
-      "teaching": "Don't assume. axiom_runtime: admit_ignorance \u2192 verify before action.",
-      "counter_action": "State 'I don't know \u2014 verifying' + run a read-only check (file read, kubectl get, codebase grep) + then act on facts."
+      "teaching": "Don't assume. axiom_runtime: admit_ignorance → verify before action.",
+      "counter_action": "State 'I don't know — verifying' + run a read-only check (file read, kubectl get, codebase grep) + then act on facts."
     },
     {
       "trigger": "preferred over|optional|fallback layer",
@@ -219,7 +220,7 @@
       "trigger": "we should also (fix|address|handle|update|deal with)",
       "memory": "feedback_no_flag_without_fix.md",
       "teaching": "'We should also fix' tells the user about a problem you found while volunteering them to fix it.",
-      "counter_action": "If the fix is in your scope, fix it now. If it's truly out of scope, create the task \u2014 don't hand it back as a verbal note."
+      "counter_action": "If the fix is in your scope, fix it now. If it's truly out of scope, create the task — don't hand it back as a verbal note."
     },
     {
       "trigger": "let me (note|flag)|(?<!please )leaving (this )?for follow.?up|out of scope here",
@@ -255,7 +256,7 @@
       "trigger": "ignore[^.]{0,40}(?:not.?found|missing|absent|undefined)|exclude[^.]{0,40}(?:not.?found|missing|absent)",
       "memory": "feedback_workaround_vs_path_fix.md",
       "teaching": "Ignoring a not-found file/path is fixing the symptom; the cause is the file isn't being produced where expected.",
-      "counter_action": "Trace why the file is missing \u2014 which step was supposed to produce it? Fix that step, not the consumer's tolerance for absence."
+      "counter_action": "Trace why the file is missing — which step was supposed to produce it? Fix that step, not the consumer's tolerance for absence."
     },
     {
       "trigger": "next.?session|follow.?up.?(?:task|later)|defer(?:red|ring)? to (?:next|later|future)",
@@ -308,14 +309,14 @@
     {
       "trigger": "similar to [a-z-]+",
       "memory": "feedback_no_assumption_without_verification.md",
-      "teaching": "'Similar to X' is the soft-mirror pattern \u2014 even more dangerous because the asserted similarity is itself unverified.",
+      "teaching": "'Similar to X' is the soft-mirror pattern — even more dangerous because the asserted similarity is itself unverified.",
       "counter_action": "Either it IS the same (cite identical surfaces) or it's different (name the differences). 'Similar' is a hedge that hides the gap."
     },
     {
       "trigger": "presumably",
       "memory": "feedback_no_assumption_without_verification.md",
       "teaching": "'Presumably' is the explicit speculation marker. Presumption without verification fails the doctrine.",
-      "counter_action": "Replace 'presumably' with the read-only probe result. If the probe can't be run, say 'unverified \u2014 verifying' and then verify before asserting."
+      "counter_action": "Replace 'presumably' with the read-only probe result. If the probe can't be run, say 'unverified — verifying' and then verify before asserting."
     },
     {
       "trigger": "likely the same",
@@ -333,7 +334,7 @@
       "trigger": "i think it'?s",
       "memory": "feedback_no_assumption_without_verification.md",
       "teaching": "'I think it's' is internal speculation surfaced as claim. Thoughts aren't evidence.",
-      "counter_action": "State 'I don't know \u2014 verifying' and run the probe. Then assert with verifiedAgainst citation, not internal belief."
+      "counter_action": "State 'I don't know — verifying' and run the probe. Then assert with verifiedAgainst citation, not internal belief."
     },
     {
       "trigger": "if memory serves",
@@ -383,9 +384,9 @@
       "doctrine": "memory:feedback_dalio_expected_required.md",
       "memory": "feedback_dalio_expected_required.md",
       "severity": "block",
-      "teaching": "Expected-outcome predicate must be numeric/boolean/state-string \u2014 qualitative adjectives ('better', 'improved', 'should work') are not measurable and cannot be evaluated post-gate.",
+      "teaching": "Expected-outcome predicate must be numeric/boolean/state-string — qualitative adjectives ('better', 'improved', 'should work') are not measurable and cannot be evaluated post-gate.",
       "counter_action": "Replace qualitative expected with a measurable predicate. Example: instead of 'expected: better performance', use 'expected: { predicate: \"p95 latency < 200ms\", measurable_type: \"numeric\", threshold: 200 }'.",
-      "message": "Expected-outcome predicate is qualitative ('better'/'improved'/'should work') \u2014 not measurable. Replace with numeric/boolean/state-string predicate the post-gate can evaluate."
+      "message": "Expected-outcome predicate is qualitative ('better'/'improved'/'should work') — not measurable. Replace with numeric/boolean/state-string predicate the post-gate can evaluate."
     },
     {
       "trigger_id": "dalio_actual_unsubstrate",
@@ -396,7 +397,7 @@
       "severity": "warn",
       "teaching": "immediate_actual must cite a tool output, file:line, or command result the post-gate can verify. Bare prose is not substrate-anchored evidence.",
       "counter_action": "Append a verifiedAgainst citation to your immediate_actual field. Format: 'immediate_actual: <observation> [verifiedAgainst: <tool output | file:line | command result>]'.",
-      "message": "immediate_actual lacks substrate citation \u2014 cite a tool output, file:line, or command-result the post-gate can verify."
+      "message": "immediate_actual lacks substrate citation — cite a tool output, file:line, or command-result the post-gate can verify."
     },
     {
       "trigger_id": "hive_session_concurrent_edit",
@@ -427,7 +428,7 @@
       "doctrine": "memory:feedback_non_blocking_errors_unacceptable.md",
       "memory": "feedback_non_blocking_errors_unacceptable.md",
       "severity": "warn",
-      "teaching": "Silent or warn-only catches discard error signal \u2014 they are the failure pattern this doctrine names.",
+      "teaching": "Silent or warn-only catches discard error signal — they are the failure pattern this doctrine names.",
       "counter_action": "Upgrade to console.error with structured kind+message+stack, write to discovery ledger, then either re-throw or return a typed error result.",
       "message": "Silent or warn-only catch detected. Per feedback_non_blocking_errors_unacceptable.md every catch must LOUD-log + ledger + resolve. Replace with structured error handling."
     },
@@ -558,9 +559,9 @@
       "doctrine": "memory:feedback_registry_image_drift.md",
       "memory": "feedback_registry_image_drift.md",
       "severity": "warn",
-      "teaching": "Images missing from localhost:5000 is NEVER a GC problem — it's a build-gap. Every service in service-registry.json must have its image built and pushed after any registry flush, node upgrade, or cluster restart.",
-      "counter_action": "Rebuild + push the missing image via: cd apps/<service> && docker build -t localhost:5000/<image>:latest . && docker push localhost:5000/<image>:latest && kubectl rollout restart deployment/<name> -n aria. Never just delete the pod or scale-to-zero. Never blame the registry — the image was never there.",
-      "message": "Images missing from localhost:5000 — see feedback_registry_image_drift.md"
+      "teaching": "Images missing from localhost:5000 is NEVER a GC problem \u2014 it's a build-gap. Every service in service-registry.json must have its image built and pushed after any registry flush, node upgrade, or cluster restart.",
+      "counter_action": "Rebuild + push the missing image via: cd apps/<service> && docker build -t localhost:5000/<image>:latest . && docker push localhost:5000/<image>:latest && kubectl rollout restart deployment/<name> -n aria. Never just delete the pod or scale-to-zero. Never blame the registry \u2014 the image was never there.",
+      "message": "Images missing from localhost:5000 \u2014 see feedback_registry_image_drift.md"
     },
     {
       "trigger_id": "missing_k8s_manifest",
@@ -569,9 +570,9 @@
       "doctrine": "memory:feedback_registry_image_drift.md",
       "memory": "feedback_registry_image_drift.md",
       "severity": "warn",
-      "teaching": "A service without a K8s manifest is not deployed — it's aspirational code. Every service in the registry must have a canonical k8s/<service>.yaml manifest. Without it, kubectl apply cannot restore the service after cluster restart.",
-      "counter_action": "Create the canonical K8s manifest (Deployment + Service + liveness probe) at k8s/<service>.yaml. Register the service in k8s/service-registry.json. Never deploy via ad-hoc kubectl run or docker run — only via a version-controlled manifest.",
-      "message": "Service lacks K8s manifest — see feedback_registry_image_drift.md"
+      "teaching": "A service without a K8s manifest is not deployed \u2014 it's aspirational code. Every service in the registry must have a canonical k8s/<service>.yaml manifest. Without it, kubectl apply cannot restore the service after cluster restart.",
+      "counter_action": "Create the canonical K8s manifest (Deployment + Service + liveness probe) at k8s/<service>.yaml. Register the service in k8s/service-registry.json. Never deploy via ad-hoc kubectl run or docker run \u2014 only via a version-controlled manifest.",
+      "message": "Service lacks K8s manifest \u2014 see feedback_registry_image_drift.md"
     },
     {
       "trigger_id": "containment_only_production_fix",
@@ -583,6 +584,216 @@
       "teaching": "Containment-only production fixes are rationalized bypasses when they intentionally leave the broken user-visible mechanism unrepaired. Small source-level fixes are acceptable when they repair the root mechanism and are verified.",
       "counter_action": "Keep the smallest correct change, but tie it to the root mechanism, observable recovery or proof, and user-visible verification; do not only silence gates or change cosmetics.",
       "message": "Containment-only production fix detected. Preserve smallest-correct-change discipline, but replace cosmetic containment with root-mechanism repair plus observable recovery and proof."
+    },
+    {
+      "trigger_id": "revenue_decision_without_cohort",
+      "trigger": "(?:price|pricing|discount|refund|expansion).{0,80}(?:without|no|missing).{0,40}(?:cohort|elasticity|alternative cost)",
+      "rx": "(?:price|pricing|discount|refund|expansion).{0,80}(?:without|no|missing).{0,40}(?:cohort|elasticity|alternative cost)",
+      "doctrine": "memory:feedback_revenue_requires_cohort_decomposition.md",
+      "memory": "feedback_revenue_requires_cohort_decomposition.md",
+      "severity": "warn",
+      "teaching": "Revenue decisions without cohort decomposition mistake price elasticity for discount drag. Decompose by acquisition source x entry price BEFORE recommending.",
+      "counter_action": "Load aria-revenue-engine; run the 5-step cohort-elasticity frame; cite cohort data with date and source. Severity:warn means recovery, not block."
+    },
+    {
+      "trigger_id": "gtm_message_without_buyer_language",
+      "trigger": "(?:message|copy|hook|headline|positioning).{0,80}(?:without|no|skipped).{0,40}(?:interview|buyer language|customer call)",
+      "rx": "(?:message|copy|hook|headline|positioning).{0,80}(?:without|no|skipped).{0,40}(?:interview|buyer language|customer call)",
+      "doctrine": "memory:feedback_message_fit_requires_buyer_language.md",
+      "memory": "feedback_message_fit_requires_buyer_language.md",
+      "severity": "warn",
+      "teaching": "Message-fit IS buyer-language fit. If the buyer doesn't say 'I have problem X' the way the headline says X, the message is upstream-broken.",
+      "counter_action": "Load aria-gtm-architect; run 5-call buyer interview OR surface 3 candidate messages explicitly marked 'untested'."
+    },
+    {
+      "trigger_id": "churn_intervention_without_cause",
+      "trigger": "(?:churn|retention).{0,80}(?:fix|intervention|recommendation).{0,80}(?:without|no|skip).{0,40}(?:cause|decompose|interview)",
+      "rx": "(?:churn|retention).{0,80}(?:fix|intervention|recommendation).{0,80}(?:without|no|skip).{0,40}(?:cause|decompose|interview)",
+      "doctrine": "memory:feedback_churn_decompose_before_fix.md",
+      "memory": "feedback_churn_decompose_before_fix.md",
+      "severity": "warn",
+      "teaching": "Churn is 5 different things (wrong-fit / un-activated / life-cycle / competitor / price). Misdiagnosing the cause is the most common retention failure.",
+      "counter_action": "Load aria-retention-engine; decompose churn by cause; run 10-customer churn-interview sprint if cause data missing."
+    },
+    {
+      "trigger_id": "owner_decision_recommended",
+      "trigger": "(?:i recommend|my recommendation|best to|i'd suggest|you should).{0,120}(?:hire|fire|layoff|rif|equity grant|fundraise|public statement|rebrand|m&a)",
+      "rx": "(?:i recommend|my recommendation|best to|i'd suggest|you should).{0,120}(?:hire|fire|layoff|rif|equity grant|fundraise|public statement|rebrand|m&a)",
+      "doctrine": "memory:feedback_owner_must_decide_no_recommend.md",
+      "memory": "feedback_owner_must_decide_no_recommend.md",
+      "severity": "warn",
+      "teaching": "Type-1 (one-way-door) decisions on people, equity, public, fundraising are owner-only. LLM provides cognition; owner decides.",
+      "counter_action": "Load aria-decision-mizan; produce decision packet (Type-1/2 diagnosis + reversibility + pre-mortem + What-only-you-know + What-I-believe + Your-call). Refuse trailing recommendation."
+    },
+    {
+      "trigger_id": "code_without_contract_first",
+      "trigger": "(?:write|implement|build|scaffold).{0,80}(?:handler|endpoint|api|service).{0,80}(?:without|no|skip).{0,40}(?:contract|schema|spec|docs|interface)",
+      "rx": "(?:write|implement|build|scaffold).{0,80}(?:handler|endpoint|api|service).{0,80}(?:without|no|skip).{0,40}(?:contract|schema|spec|docs|interface)",
+      "doctrine": "memory:feedback_contract_before_handler.md",
+      "memory": "feedback_contract_before_handler.md",
+      "severity": "warn",
+      "teaching": "API contract written before handler. Backwards is harder than forwards. The contract drives the handler, the tests, the SDK, the docs, the mock server.",
+      "counter_action": "Load aria-backend-architect + aria-senior-code-cookbook; write the contract (zod/typebox/openapi) first; review with FE; then implement handler."
+    },
+    {
+      "trigger_id": "fe_state_in_react_useState",
+      "trigger": "(?:server data|api data|backend data).{0,120}(?:useState|component state|local state)",
+      "rx": "(?:server data|api data|backend data).{0,120}(?:useState|component state|local state)",
+      "doctrine": "memory:feedback_server_state_belongs_in_query_lib.md",
+      "memory": "feedback_server_state_belongs_in_query_lib.md",
+      "severity": "warn",
+      "teaching": "Server state in useState is the most common stale-data bug source. Each piece of state has exactly one home.",
+      "counter_action": "Load aria-frontend-architect; route server state to TanStack Query / SWR / RTK Query; URL state to URL params; form state to form library; local UI state only to useState."
+    },
+    {
+      "trigger_id": "tenant_isolation_at_app_layer",
+      "trigger": "(?:tenant|multi-tenant).{0,120}(?:where|filter|check).{0,120}(?:application|app layer|handler)",
+      "rx": "(?:tenant|multi-tenant).{0,120}(?:where|filter|check).{0,120}(?:application|app layer|handler)",
+      "doctrine": "memory:feedback_tenant_isolation_at_query_layer.md",
+      "memory": "feedback_tenant_isolation_at_query_layer.md",
+      "severity": "block",
+      "teaching": "Tenant isolation at application layer fails eventually \u2014 one missing WHERE clause = cross-tenant data leak. Enforce at query layer (RLS or scoped query builder) with fail-closed default.",
+      "counter_action": "Load aria-backend-architect; migrate to Postgres RLS or tenant-scoped query builder; verify with the 5-step isolation test from backend-cookbook \u00a73."
+    },
+    {
+      "trigger_id": "deploy_without_runbook",
+      "trigger": "(?:deploy|ship|release|launch).{0,80}(?:feature|service|endpoint).{0,120}(?:without|no|missing).{0,40}(?:runbook|alert|slo)",
+      "rx": "(?:deploy|ship|release|launch).{0,80}(?:feature|service|endpoint).{0,120}(?:without|no|missing).{0,40}(?:runbook|alert|slo)",
+      "doctrine": "memory:feedback_runbook_before_deploy.md",
+      "memory": "feedback_runbook_before_deploy.md",
+      "severity": "warn",
+      "teaching": "On-call at 3am needs the runbook. Writing it after the incident is too late. Phase 3 (deploy prep) is first-class, not afterthought.",
+      "counter_action": "Load aria-fullstack-orchestrator; produce runbook (healthy/degraded/critical states + rollback procedure + alert wiring) BEFORE deploy."
+    },
+    {
+      "trigger_id": "audit_severity_inflation",
+      "trigger": "(?:critical|p0|emergency).{0,200}(?:style|naming|aesthetic|preference|nit|formatting)",
+      "rx": "(?:critical|p0|emergency).{0,200}(?:style|naming|aesthetic|preference|nit|formatting)",
+      "doctrine": "memory:feedback_audit_severity_calibration.md",
+      "memory": "feedback_audit_severity_calibration.md",
+      "severity": "warn",
+      "teaching": "Severity inflation (calling preferences critical) erodes the signal. Critical = data loss / security breach / payment failure / data exposure.",
+      "counter_action": "Load aria-senior-code-audit / aria-repo-audit; recalibrate per the calibration test ('would this finding firing at 3am wake me up?'); demote stylistic findings to low or remove."
+    },
+    {
+      "trigger_id": "research_without_decomposition",
+      "trigger": "(?:research|look up|investigate)\\s+(?:linear|asana|stripe|opencode|claude|codex|hubspot|salesforce|aws|gcp|azure|.{0,40})\\s+(?:vs|or|alternative|comparison)",
+      "rx": "(?:research|look up|investigate)\\s+(?:linear|asana|stripe|opencode|claude|codex|hubspot|salesforce|aws|gcp|azure|.{0,40})\\s+(?:vs|or|alternative|comparison)",
+      "doctrine": "memory:feedback_research_decompose_before_fetch.md",
+      "memory": "feedback_research_decompose_before_fetch.md",
+      "severity": "warn",
+      "teaching": "Vague research requests produce vague answers. Decompose into 2-5 sub-questions, each with source class + freshness window + success criterion.",
+      "counter_action": "Load aria-research-orchestrator; decompose; check Noor/memory first; fetch with right tool per sub-question; verify with \u22652 sources or flag single-sourced."
+    },
+    {
+      "trigger_id": "owner_facing_cognition_first",
+      "trigger": "^\\s*<cognition>",
+      "rx": "^\\s*<cognition>",
+      "doctrine": "memory:feedback_owner_surface_before_gate.md",
+      "memory": "feedback_owner_surface_before_gate.md",
+      "severity": "warn",
+      "teaching": "Owner surface comes BEFORE gate surface. Leading with <cognition> buries the answer.",
+      "counter_action": "Load aria-readable-output; restructure: headline first, why bullets, next action, then optional <details> gate block."
+    },
+    {
+      "trigger_id": "adjective_only_recommendation",
+      "trigger": "(?:better|improved|more robust|cleaner|nicer|enhanced|stronger).{0,80}(?:positioning|retention|conversion|growth|brand|messaging)",
+      "rx": "(?:better|improved|more robust|cleaner|nicer|enhanced|stronger).{0,80}(?:positioning|retention|conversion|growth|brand|messaging)",
+      "doctrine": "memory:feedback_no_adjective_recommendations.md",
+      "memory": "feedback_no_adjective_recommendations.md",
+      "severity": "warn",
+      "teaching": "Adjectives ('better', 'improved') are not measurable. Predictor predicate must be numeric, boolean, or named state.",
+      "counter_action": "Replace adjective with measurable predicate. Example: instead of 'better retention', use 'NRR \u2265 110% over rolling 90 days' or 'day-7 activation \u2265 35%'."
+    },
+    {
+      "trigger": "\\bdeferred to enhancement\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "QA's job is detect-AND-bind-fix in same turn, not surface-and-defer. 'Deferred to enhancement' = degraded-not-fixed pattern (forge-guardrails violation).",
+      "counter_action": "Run the furuq decision tree: reversible+in-scope → BIND FIX same turn; only loopback on irreversible/owner-only/ambiguous/out-of-scope/too-costly. Cite the specific scope-boundary if loopback warranted."
+    },
+    {
+      "trigger": "\\bflag(?:ged)? for later\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Surfacing a gap without binding the fix when scope is authorized = artifact theater. Cognition's value comes from changing the action, not announcing the finding.",
+      "counter_action": "Bind the fix in this turn or cite the specific aria-decision-mizan trigger that requires loopback (irreversible/owner-judgment/ambiguous/out-of-scope/too-costly)."
+    },
+    {
+      "trigger": "\\bnoted,?\\s+(?:will fix|will address|will handle)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Acknowledging without binding is the deferral antipattern. The operator gave scope; cognition found gap; binding action is the cognition's responsibility.",
+      "counter_action": "Execute the Edit/Write/Bash that closes the gap NOW. Emit the post-fix artifact, not the pre-fix promise."
+    },
+    {
+      "trigger": "\\bacceptable first[- ]cut\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "'Acceptable first-cut' is a framing that lets degraded ship. Forge-guardrails: degraded is not fixed unless operator explicitly asked for temporary degraded mode.",
+      "counter_action": "Either bind the full fix in same turn, or explicitly cite operator authorization for a temporary degraded mode with named rollback predicate."
+    },
+    {
+      "trigger": "\\bdirection\\?",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Ending an emission with 'direction?' after surfacing gaps is the loopback antipattern. Operator authorization was the scope-setting input; loopback is reserved for scope-boundary triggers.",
+      "counter_action": "Before emitting, run the furuq decision tree on every gap. Bind fixes inside authorized scope. Only loopback with specific scope-boundary citation (which furuq# applies)."
+    },
+    {
+      "trigger": "\\bQA (?:finding|defect|caught|surfaced|gap)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "A QA finding has been emitted. The Recovery Contract is BINDING: every finding must close the turn classified A (FIXED-IN-TURN with tool-call evidence) / B (TRACKED-AS-TASK with TaskCreate ID) / C (MIZAN-SCOPE with specific furuq # + both options) / D (INVALIDATED with refutation evidence). No deferral, no 'minor', no 'monitor'.",
+      "counter_action": "BEFORE emit-close: affirm the 7-item Turn-End Checklist. For each finding: classify A/B/C/D and produce the required evidence/predicate IN THIS TURN. Caps: 3 findings inline, remainder TaskCreate; 5 cognitive-passes max; same-finding re-classify forbidden. Cap-breach → architect-mode escalation (POST /api/harness/codex), not further LLM-iteration."
+    },
+    {
+      "trigger": "\\b(?:qiyas|tadabbur|8[- ]lens|ghazali|furuq|forge[- ]guardrails?) (?:finding|defect|gap|caught|surfaced)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Cognitive-pass finding surfaced. The Recovery Contract is the must-satisfy artifact for turn-close: classify A/B/C/D before emit; auto-loaded qiyas + tadabbur + memory body in this turn.",
+      "counter_action": "Run qiyas furuq pass on the finding (which #1-7 applies?) → tadabbur consequence trace (1st/2nd/3rd order if NOT fixed?) → classify → execute. Loop-safe: same finding cannot be re-classified within turn; >3 findings = TaskCreate the tail; >5 passes = architect-mode."
+    },
+    {
+      "trigger": "\\bfound (?:a |an )?(?:defect|gap|blind[- ]spot|issue|risk|bug|antipattern)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "A defect/gap/risk was found. The Recovery Contract requires classification A/B/C/D before turn-close — 'found X' without binding the fix or escalation is the antipattern the operator caught 2026-05-12.",
+      "counter_action": "Within this turn: (a) reversible+in-scope → Edit/Write/Bash NOW + verify with predicate; (b) >5-tool-call effort or cross-system → TaskCreate with full scope contract; (c) irreversible/owner-judgment/ambiguous → aria-decision-mizan invocation with both options + specific furuq #; (d) re-inspection refutes → INVALIDATED with evidence. NO other paths."
+    },
+    {
+      "trigger": "\\bsurfaced (?:a |an |\\d+ )?(?:defect|gap|finding|risk|issue|antipattern)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Surfacing a finding is half of cognition's job. Binding the fix/task/escalation is the other half — the must-satisfy half. The Recovery Contract closes the loop within this turn.",
+      "counter_action": "For each surfaced finding: classify A (FIXED) / B (TASK) / C (MIZAN) / D (INVALID). Emit evidence anchor for each. Affirm 7-item Turn-End Checklist before emit-close. If any classification cannot complete → architect-mode handoff (not further LLM thinking)."
+    },
+    {
+      "trigger": "\\b(?:caught|detected|spotted|identified) (?:a |an |\\d+ )?(?:defect|gap|issue|risk|bug|finding|antipattern)\\b",
+      "memory": "feedback_qa_binds_to_fix_not_question.md",
+      "teaching": "Detection event triggered. Cognition's job is detect AND change-action; an emission that contains detect without bound action has completed only half the cognition triplet.",
+      "counter_action": "Before any narrative response: (1) classify the finding A/B/C/D; (2) produce the required evidence (tool-call output / TaskCreate ID / mizan invocation / refutation); (3) verify the 7-item Turn-End Checklist; (4) emit POST-fix artifact, not pre-fix promise. Loop cap: 3 findings inline."
+    },
+    {
+      "trigger": "\\b(?:the skill body says|per the loaded skill|based on the substrate|substrate suggests|loaded substrate indicates)\\b",
+      "memory": "feedback_autoload_does_not_invoke_skills.md",
+      "teaching": "Citing a loaded skill body as if it counted as workflow invocation is the autoload-as-context antipattern. Body in context ≠ workflow ran.",
+      "counter_action": "If the named skill is active-workflow (tadabbur/qiyas-analogy/aria-cognition-batch/mizan/aria-forge-guardrails), INVOKE it via the Skill tool now. Body alone is reference; invocation runs the work."
+    },
+    {
+      "trigger": "\\b(?:autoload(?:ed)?\\s+(?:body|bodies|skill|skills)|loaded\\s+as\\s+context|read\\s+the\\s+skill\\s+body)\\b",
+      "memory": "feedback_autoload_does_not_invoke_skills.md",
+      "teaching": "Autoload injects skill bodies as additionalContext substrate. That is NOT skill-tool invocation. Active-workflow skills demand the invocation.",
+      "counter_action": "Run the 4-class Recovery Contract: A. INVOKED (Skill tool called) / B. COMPOSED-VIA-PARENT (parent that composes it was invoked) / C. SCOPE-EXEMPT (read-only inspection) / D. CAP-DEFERRED (>5 in turn)."
+    },
+    {
+      "trigger": "\\b(?:I\\s+considered\\s+it|it's\\s+in\\s+context|already\\s+loaded|substrate\\s+is\\s+loaded)\\b",
+      "memory": "feedback_autoload_does_not_invoke_skills.md",
+      "teaching": "Treating loaded-as-substrate as equivalent to invoked-as-workflow is the parallel-session confession of 2026-05-12. Body presence is not workflow execution.",
+      "counter_action": "If an active-workflow skill is named, invoke via Skill tool. Sidecar field invocationRequired tells you which ones."
+    },
+    {
+      "trigger": "\\bbanking\\s+on\\s+(?:the\\s+)?(?:autoload|loaded\\s+bodies?|loaded\\s+substrate)\\b",
+      "memory": "feedback_autoload_does_not_invoke_skills.md",
+      "teaching": "The exact phrase from the parallel-session confession. This pattern is doctrine drift — autoload-as-context is not skill-as-invocation.",
+      "counter_action": "Stop. List the active-workflow skills loaded this turn. Invoke each via Skill tool OR classify under B/C/D per Recovery Contract."
+    },
+    {
+      "trigger": "\\binvoke\\s+(?:skill|skills|tadabbur|qiyas|mizan|cognition|forge)\\b",
+      "memory": "feedback_autoload_does_not_invoke_skills.md",
+      "teaching": "Explicit invocation request. Honor it by calling the Skill tool, not by emitting prose that performs the workflow shape.",
+      "counter_action": "Use the Skill tool with the exact skill name. Do not write the workflow output without first invoking the skill."
     }
   ]
-}
+}

package/dist/runtime/discipline/skills/aria-cognition/34-frameworks-unified/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: 34-frameworks-unified
+description: Use when a problem benefits from combining many strategic frameworks at once, especially for business analysis, marketing, sales, leadership, creative problem-solving, decision-making under uncertainty, or multi-perspective synthesis.
+---
+
+# 34 Frameworks Unified
+
+Read `/home/hamzaibrahim1/.claude/skills/34-frameworks-unified.md` for the full framework inventory and recombination model.
+
+Workflow:
+
+1. Identify the actual decision, strategy, or design problem.
+2. Load the source doc and select only the framework families that materially improve the answer.
+3. Synthesize across those lenses instead of producing isolated mini-analyses.
+4. Favor high-signal recombination over exhaustive enumeration.
+
+## 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-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.