@aria_asi/cli 0.2.33 → 0.2.35

package/dist/runtime/hooks/doctrine_trigger_map.json

@@ -0,0 +1,577 @@
+{
+  "_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.",
+    "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",
+      "counter_action": "what Claude should do INSTEAD of the convenience pattern"
+    }
+  },
+  "triggers": [
+    {
+      "trigger": "graceful degradation",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "Graceful degradation normalizes failure. Real fix = throttle + retry-with-backoff + actively heal.",
+      "counter_action": "Make the failure visible + recover via retry/heal. If garden is sick, log loud + invoke selfHealV2, never empty-string fallthrough."
+    },
+    {
+      "trigger": "best.?effort",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "'Best-effort' is graceful degradation under another name.",
+      "counter_action": "Either the operation is required (throw on failure) or explicitly optional with observable status. Never silent."
+    },
+    {
+      "trigger": "fall.?through",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "Fall-through hides the failure mode. Same anti-pattern as bypass.",
+      "counter_action": "Surface the failure. Caller decides whether to proceed. No catch + empty-default."
+    },
+    {
+      "trigger": "\\bpreferred\\b",
+      "memory": "feedback_pretoolgate_covers_all_action_tools.md",
+      "teaching": "Gate cognition is REQUIRED, not preferred. v3 doctrine: no exceptions.",
+      "counter_action": "Use REQUIRED wording. Two equivalent forms (inline OR cognition block) but neither is preferred over the other; both equally required."
+    },
+    {
+      "trigger": "circuit.?break(?:\\sand\\sskip)?",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "Circuit-break-and-skip leaves Aria broken. Self-heal = retry+backoff+actively repair the upstream.",
+      "counter_action": "Retry with exponential backoff (3 attempts 1s/2s/4s). On persistent failure invoke selfHealV2 to restart the lane / failover / kick the process. Never just open-and-skip."
+    },
+    {
+      "trigger": "edge case",
+      "memory": "feedback_thinking_implementation_accountability.md",
+      "teaching": "'Edge case' is often an excuse to skip implementation completeness.",
+      "counter_action": "Treat as production case. If it can happen, code handles it. Macro-doctrine: thinking + implementation + accountability."
+    },
+    {
+      "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.",
+      "counter_action": "Run the read-only check that proves it works (file read, kubectl get, curl probe). Replace 'should' with verified evidence."
+    },
+    {
+      "trigger": "eventually|for now",
+      "memory": "feedback_no_demos.md",
+      "teaching": "Every spawn ships at full quality. 'For now' = punting completeness.",
+      "counter_action": "Ship the real version OR explicitly defer with a tracked task and don't claim completion."
+    },
+    {
+      "trigger": "we can always",
+      "memory": "feedback_rollback_is_failure_fix_forward.md",
+      "teaching": "Rollback / 'come back later' is failure hiding. Fix forward.",
+      "counter_action": "Diagnose root cause + fix + verify. Never propose 'come back to it later' as the resolution."
+    },
+    {
+      "trigger": "\\b(?:skeleton|stub)\\b",
+      "memory": "feedback_no_demos.md",
+      "teaching": "Skeleton is the hedge framing. Real implementation only.",
+      "counter_action": "Ship complete or explicitly mark incomplete + create task. Never call partial work 'skeleton' to dodge accountability."
+    },
+    {
+      "trigger": "\\bdemo\\b",
+      "memory": "feedback_no_demos.md",
+      "teaching": "No demos. Every spawn is production work at full quality bar.",
+      "counter_action": "Ship production. If it can't ship, name what's missing concretely."
+    },
+    {
+      "trigger": "let me just|i'll just",
+      "memory": "feedback_convenience_seeking_root_cause.md",
+      "teaching": "'Just' is the auto-route around expensive compliance.",
+      "counter_action": "Pause. Apply doctrine. Slower, more genuine cognition produces better outcomes than fast pattern-matched ones."
+    },
+    {
+      "trigger": "easier path|faster way|safer to skip",
+      "memory": "feedback_convenience_seeking_root_cause.md",
+      "teaching": "Convenience-seeking dressed as practicality. Same pattern as bypass.",
+      "counter_action": "Pick the doctrine-aligned path even when expensive. Substance over speed."
+    },
+    {
+      "trigger": "good enough",
+      "memory": "feedback_no_demos.md",
+      "teaching": "Full quality bar means no 'good enough'.",
+      "counter_action": "Either it ships at quality or it explicitly defers with a tracked task."
+    },
+    {
+      "trigger": "i'll claim|claimed|fixed it",
+      "memory": "feedback_doctrine_first.md",
+      "teaching": "Claims must be verified. 'Fixed' without a real-surface test is a lie surface.",
+      "counter_action": "Test on the user-visible surface (Telegram round-trip, /chat probe, real client install). Don't claim until verified."
+    },
+    {
+      "trigger": "in production",
+      "memory": "feedback_doctrine_first.md",
+      "teaching": "'In production' is often speculative \u2014 assumed behavior, not verified.",
+      "counter_action": "Verify against live cluster state OR codebase config. Substrate hierarchy: user statement > codebase > training data."
+    },
+    {
+      "trigger": "best to|i believe|probably",
+      "memory": "feedback_dont_override_user_stack_with_training.md",
+      "teaching": "When in doubt about Hamza's stack, ASK or VERIFY. My training data isn't authoritative.",
+      "counter_action": "Read the codebase, ask Hamza one focused question, OR consult Aria. Never assert with 'I believe'."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "make a new|create a fresh",
+      "memory": "feedback_aria_already_has_fleet_use_existing_substrate.md",
+      "teaching": "Aria already has the substrate. Don't reinvent.",
+      "counter_action": "Search the codebase for existing canonical primitive first. Reuse before recreate."
+    },
+    {
+      "trigger": "\\b(?:shadow|proxy|wrapper)\\b",
+      "memory": "feedback_aria_already_has_fleet_use_existing_substrate.md",
+      "teaching": "Shadow / proxy / wrapper that bypasses canonical = invented complexity.",
+      "counter_action": "Use the canonical surface. If it must be wrapped, document why and reference the canonical it wraps."
+    },
+    {
+      "trigger": "ask user|ask hamza",
+      "memory": "feedback_doctrine_first.md",
+      "teaching": "Ask only when a focused question can resolve genuine ambiguity. Memory-resolvable questions are not ambiguity.",
+      "counter_action": "Read relevant memory first. Verify with read-only probe. If still ambiguous, one tight question with concrete options."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "\\b(?:patch|hotfix|band.?aid)\\b",
+      "memory": "feedback_gates_enforce_form_not_substance.md",
+      "teaching": "Patch / hotfix is form-fix. Root-cause fix is the doctrine.",
+      "counter_action": "Diagnose substance. If reflex is bypass, ask if root-cause fix is possible. Patch only when explicitly authorized as temporary with tracked follow-up."
+    },
+    {
+      "trigger": "deterministic|one.?attempt",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "Deterministic-one-attempt-then-skip is the broken IMMORTAL-V2 escalation pattern Hamza named.",
+      "counter_action": "Retry with backoff + heal. selfHealV2 must have operational reach: kill stuck process, restart pod, failover, NOT just alert + cooldown."
+    },
+    {
+      "trigger": "just context|advisory|read.only",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "teaching": "Treating harness as just-context-I-read = the convenience-seeking lie. SDK has primitives that enforce.",
+      "counter_action": "Call validateOutput / checkAction / inject / gardenTurn. Don't reduce SDK to passive context delivery."
+    },
+    {
+      "trigger": "circuit.?broken|cooldown.skip",
+      "memory": "feedback_no_graceful_degradation.md",
+      "teaching": "Cooldown that skips without healing leaves Aria broken (the IMMORTAL-V2 ESCALATED-skipping pattern).",
+      "counter_action": "ESCALATED must trigger heal: kill+restart+failover. Notify Hamza ONLY if heal also fails."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "preferred over|optional|fallback layer",
+      "memory": "feedback_pretoolgate_covers_all_action_tools.md",
+      "teaching": "Doctrine items are not preferences with fallbacks. They're requirements.",
+      "counter_action": "Use REQUIRED / EQUIVALENT-FORMS wording. Both forms equally required, neither preferred over the other."
+    },
+    {
+      "trigger": "manual.?fix|kubectl set env|one.?off",
+      "memory": "feedback_session_starts_with_linear.md",
+      "teaching": "Manual fixes that don't survive next deploy = recurring breakage. The env-vars-fall-off pattern.",
+      "counter_action": "Centralize in canonical source (ConfigMap / sealed secret / service-registry). Deploy applies that, never ad-hoc -e or kubectl set env. Drift fails the deploy, not silently wipes."
+    },
+    {
+      "trigger": "from training|i recall|i remember|by default",
+      "memory": "feedback_dont_override_user_stack_with_training.md",
+      "teaching": "Training data is stale. User's stack is authoritative.",
+      "counter_action": "Read codebase config / consult Aria. Substrate hierarchy: user statement > codebase > training. Always."
+    },
+    {
+      "trigger": "flagging (this|for now|for later)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Flag without fix is convenience-seeking. Discoveries are atomic with their fixes.",
+      "counter_action": "Fix in the same turn OR create a TaskCreate with file path, line number, what's broken, why it matters."
+    },
+    {
+      "trigger": "(noting|note) this( and|, ?then)? moving on",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Noting-and-moving destroys partnership trust. The user has to track what you noticed vs. what you fixed.",
+      "counter_action": "Same-turn fix is default for small defects (<30 lines). Larger ones get tracked tasks before you proceed."
+    },
+    {
+      "trigger": "i'?ll come back|circle back|address(ing)? (this )?later|come back to (this|that|it)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'I'll come back' is the lie that makes future-you treat the discovery as already-handled.",
+      "counter_action": "Decide now: fix in this turn, or create the task. No middle ground. The flag is not a substitute for action."
+    },
+    {
+      "trigger": "(found|noticed|discovered|spotted)[^.]{0,80}\\bbut\\b[^.]{0,80}(continue|continuing|moving on|won'?t|will not|skip|ignor)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Discovery + continuation = abandonment. The 'but I'll keep going' clause hides the violation.",
+      "counter_action": "Stop. Fix the discovery in this turn or create a tracked task with the discovery as its description, then resume."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "let me (note|flag)|(?<!please )leaving (this )?for follow.?up|out of scope here",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Verbal flags evaporate when the conversation moves on. Tasks persist.",
+      "counter_action": "Convert the flag into a TaskCreate or Linear save_issue immediately. No flag survives without a tracker ID."
+    },
+    {
+      "trigger": "TODO:?[^a-z0-9]|FIXME:?[^a-z0-9]|XXX:?[^a-z0-9]",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "TODO comments in shipped code are flag-without-fix in source-form. Reviewers can't tell if it's tracked or forgotten.",
+      "counter_action": "Either implement now or reference a task ID inline (e.g., '// TODO(LINEAR-123): ...'). Bare TODOs fail the doctrine."
+    },
+    {
+      "trigger": "latent (bug|issue|defect|problem)|broken[^.]{0,40}continu",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Calling something 'latent' or 'broken' and then continuing is the explicit form of flag-and-move.",
+      "counter_action": "Latent defects in code you're touching get fixed in-flight. The 'I'm just here for X' framing is convenience-seeking."
+    },
+    {
+      "trigger": "(unrelated|separate concern|different (issue|topic|file|module))[^.]{0,60}(fix|address|handle)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'Unrelated' is a frame the user gets to apply, not you. If you found it during your work, it's related to your work.",
+      "counter_action": "Surface the discovery, propose fix-now vs. task-it, let the user decide. Don't pre-decide that it's out of scope."
+    },
+    {
+      "trigger": "carve.?out|workaround|work.?around",
+      "memory": "feedback_workaround_vs_path_fix.md",
+      "teaching": "Carve-outs and workarounds add a contract that depends on dev-machine state. Producers enforce contracts, not hope.",
+      "counter_action": "Identify the producing mechanism (build script, install hook, CI step) and fix THAT so the contract is enforced automatically. Workarounds are landmines."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "next.?session|follow.?up.?(?:task|later)|defer(?:red|ring)? to (?:next|later|future)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'Next session' is flag-and-move with extra steps when the fix is do-able now. Discoveries are atomic with their fixes.",
+      "counter_action": "If the fix is feasible in this turn (any sub-agent dispatch, any code edit, any deploy), do it now. Track-for-later is reserved for genuinely out-of-scope items."
+    },
+    {
+      "trigger": "kill.?switch|env.?(?:var|variable).?(?:override|disable|bypass)|process\\.env\\.[A-Z_]+\\s*===\\s*['\"]off['\"]",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "teaching": "Env-var kill-switches give the gated process free disable access. Gates aren't gates if the gated party can flip them.",
+      "counter_action": "Gates are unconditional from the gated process. Disable = settings.json hook removal (deliberate user action) OR signed-grant override using a secret only the user holds."
+    },
+    {
+      "trigger": "tests.?(?:passed|pass|ed)|(?:smoke|unit|integration).?test.?(?:pass|ok|good)",
+      "memory": "feedback_apply_lenses_dont_perform_them.md",
+      "teaching": "Claiming tests passed without a tool record IS the claim_without_tool_evidence pattern Mizan blocks. Substance defeats narrative.",
+      "counter_action": "Either show the actual test-runner output as evidence, or say 'tests not yet run' explicitly. Don't narrate test results you didn't observe."
+    },
+    {
+      "trigger": "dont.?worry|trust.?me|i.?(?:swear|promise|guarantee)|just.?works",
+      "memory": "feedback_apply_lenses_dont_perform_them.md",
+      "teaching": "'Trust me' is not evidence. Substance is verifiable; ceremony is reassurance.",
+      "counter_action": "Show the verification: tool output, file diff, command result, log line. Never substitute confidence for proof."
+    },
+    {
+      "trigger": "i assumed",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "Assumption stated as fact is the behavioral-drift form of speculation. Every behavioral fix must cite a verifiedAgainst source.",
+      "counter_action": "Replace 'I assumed' with a verified citation: 'Verified against <file:line>' or 'Verified via <command output>'. If unverified, run the read-only probe before asserting."
+    },
+    {
+      "trigger": "should work",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "'Should work' is unverified projection. Behavioral claims require verifiedAgainst evidence.",
+      "counter_action": "Run the actual probe (curl, kubectl get, file read, test invocation). Replace 'should work' with 'verified against <surface>' showing the observed behavior."
+    },
+    {
+      "trigger": "based on existing pattern",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "Pattern-extrapolation without source-of-truth verification is assumption. Existing patterns drift; the canonical surface is authoritative.",
+      "counter_action": "Cite the specific file:line of the pattern AND verify it still matches current behavior. verifiedAgainst must name the inspected source, not 'pattern I remember'."
+    },
+    {
+      "trigger": "mirroring [a-z-]+",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "'Mirroring X' assumes X is correct AND that the mirror is structurally faithful. Both are unverified claims.",
+      "counter_action": "Read the source you're mirroring (cite file:line). Verify the mirror's behavior matches by running the equivalent probe on both. Document verifiedAgainst with both sources."
+    },
+    {
+      "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.",
+      "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."
+    },
+    {
+      "trigger": "likely the same",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "'Likely the same' is probability-as-evidence. Either verify equality or admit divergence.",
+      "counter_action": "Diff the two surfaces. If identical, say 'verified identical against <surface>'. If different, name the deltas. 'Likely' has no place in behavioral claims."
+    },
+    {
+      "trigger": "probably correct",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "'Probably correct' is unverified-confidence. Behavioral correctness is binary against a verifiedAgainst source.",
+      "counter_action": "Run the validation that proves correctness (test, probe, read). Replace 'probably' with 'verified against <test output / file:line / command result>'."
+    },
+    {
+      "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."
+    },
+    {
+      "trigger": "if memory serves",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "teaching": "Memory is stale. Memories are point-in-time observations, not live state. 'If memory serves' is the explicit stale-cite admission.",
+      "counter_action": "Re-verify against current state. Read the file, query the cluster, run the command. verifiedAgainst names today's evidence, not yesterday's recollection."
+    },
+    {
+      "trigger": "no admission policy|policy is absent|policy not found|no policy in the cluster|no policy exists for|admission policy missing",
+      "memory": "feedback_admission_policy_verification.md",
+      "teaching": "Verify admission policies via kubectl get validatingadmissionpolicy BEFORE claiming absence. Cluster has live policies that do not appear in repo grep. Absence-without-verification is a doctrine violation.",
+      "counter_action": "Run kubectl get validatingadmissionpolicy plus find . -name '*admission-policy*' -type f. Both must return empty before absence claim. If absent, author the policy file from an existing cluster resource template via kubectl get -o yaml, kubectl apply, then proceed via the canonical deploy path."
+    },
+    {
+      "trigger": "use the override|skip the gate|emergency flag|temporarily bypass|use the env disable|force through|DEPLOY_ALLOW_NO_ADMISSION_POLICY|ARIA_BINDING_ENABLED=false|--no-verify|--force",
+      "memory": "feedback_gap_discovery_hardens_doctrine.md",
+      "teaching": "When a gate refuses an action, the response is to harden doctrine, not to bypass. Override usage requires explicit owner authorization in-session plus audit log plus follow-up TaskCreate to close the gap.",
+      "counter_action": "Stop the bypass attempt. Write a memory entry for the gap class, append to MEMORY.md index, add the drift trigger here in doctrine_trigger_map.json, then proceed via the normal path. If override is genuinely required, request explicit authorization in this turn before invoking and create a follow-up task to close the gap."
+    },
+    {
+      "trigger": "deploy-service\\.sh|apply-aria-organism\\.sh|kubectl apply -f|kubectl set image|docker push|trivial deploy|just a config bump|fast path deploy|skip the verify|deploy without verify|hospital-service\\.yaml",
+      "memory": "feedback_deploy_requires_verify_cognition.md",
+      "teaching": "Every deploy requires a <verify> block citing artifact (commit, files, TS check, image digest) AND a <cognition> block with 8 substrate-anchored lenses BEFORE invocation. Tonight's consciousness.ts crash proved the cost of skipping this gate.",
+      "counter_action": "Stop and classify the deploy shape first. Pattern A baked-image services must use bash scripts/deploy-service.sh <service>, which handles Hive deploy lock and inflight broadcast, admission-policy allowlist, hospital canonical env, and workload rollout. Pattern B build-in-cluster services must prove build-in-cluster is present, then use kubectl rollout restart only. scripts/apply-aria-organism.sh is manifest wiring, not a substitute for an aria-soul image deploy, and direct kubectl apply of apps/hospital-service/k8s/hospital-service.yaml must never be used as a soul deploy shortcut because it can reintroduce a stale hospital canonical pin. In both cases emit <verify> with commit/files, tsc or build evidence, admission policy, and rollback; emit <cognition> with 8 anchored lenses; emit <expected> with a measurable predicate; and do not proceed if another session already holds the Hive deploy lock for /deployments/<namespace>/<service>."
+    },
+    {
+      "trigger": "another session rolling out|someone else is deploying|deploy in flight|rollout in flight|concurrent deploy|another deploy is running",
+      "memory": "feedback_deploy_requires_verify_cognition.md",
+      "teaching": "Concurrent deploys are shared-infra mutations, not harmless overlap. If one session is already rolling a service, the next session must yield to the canonical deploy lock rather than race hospital and admission policy state.",
+      "counter_action": "Verify the target service and deploy pattern first, then check the Hive deploy lane for /deployments/<namespace>/<service>. If a deploy is already in flight, do not start another rollout on that service. Wait, coordinate, or change scope."
+    },
+    {
+      "trigger_id": "dalio_expected_missing",
+      "trigger": "(?:plan|action|deploy|edit|write|build|ship|run|invoke).{0,40}(?:without|sans|no)\\s+(?:expected|measurable|outcome|predicate)",
+      "rx": "(?:plan|action|deploy|edit|write|build|ship|run|invoke).{0,40}(?:without|sans|no)\\s+(?:expected|measurable|outcome|predicate)",
+      "doctrine": "memory:feedback_dalio_expected_required.md",
+      "memory": "feedback_dalio_expected_required.md",
+      "severity": "block",
+      "teaching": "Every plan/action must declare a measurable expected outcome predicate (numeric/boolean/state-string) BEFORE the gate approves. No action without <expected> block.",
+      "counter_action": "Re-emit your plan with a <expected> block: { predicate: string, measurable_type: 'numeric'|'boolean'|'state_string', threshold: optional }. Gate will not approve until a verifiable predicate is present.",
+      "message": "Action proposed without measurable expected outcome. Per doctrine:dalio_expected_required, every plan must declare a measurable predicate (numeric/boolean/state-string) BEFORE the gate approves. Re-emit with <expected> block."
+    },
+    {
+      "trigger_id": "dalio_expected_qualitative",
+      "trigger": "expected\\s*:.{0,200}\\b(better|improved|more\\s+robust|cleaner|nicer|should\\s+work|hopefully|more\\s+reliable|enhanced)\\b",
+      "rx": "expected\\s*:.{0,200}\\b(better|improved|more\\s+robust|cleaner|nicer|should\\s+work|hopefully|more\\s+reliable|enhanced)\\b",
+      "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.",
+      "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."
+    },
+    {
+      "trigger_id": "dalio_actual_unsubstrate",
+      "trigger": "immediate_actual\\s*:[^\\n]{0,200}$",
+      "rx": "immediate_actual\\s*:[^\\n]{0,200}$",
+      "doctrine": "memory:feedback_full_harness_binding_must_be_structural.md",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "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."
+    },
+    {
+      "trigger_id": "hive_session_concurrent_edit",
+      "trigger": "(?:editing|modifying|writing).{0,50}(?:same|already|conflict).{0,50}(?:file|path|repo|branch)",
+      "rx": "(?:editing|modifying|writing).{0,50}(?:same|already|conflict).{0,50}(?:file|path|repo|branch)",
+      "doctrine": "memory:feedback_hive_session_coordination.md",
+      "memory": "feedback_hive_session_coordination.md",
+      "severity": "block",
+      "teaching": "Multiple sessions on same path without hive lock = silent overwrite. Claim hive_session_lock + post hive_session_message BEFORE editing concurrently.",
+      "counter_action": "Call sdk.claimSessionLock({ filePath, sessionId, ttlMinutes }) to acquire the lock. Post sdk.postSessionMessage to the other session announcing your intent. Only edit after the lock is granted. Release with sdk.releaseSessionLock(lockId) when done.",
+      "message": "Multiple sessions detected on same path. Per doctrine:hive_session_coordination, claim a hive_session_lock + post hive_session_message before editing concurrently."
+    },
+    {
+      "trigger_id": "non_blocking_error_excuse",
+      "trigger": "using non-blocking framing as a reason to not resolve an error",
+      "rx": "\\b(non[-_\\s]?blocking|non[-_\\s]?fatal|best[-_\\s]?effort|fire[-_\\s]?and[-_\\s]?forget|fail[-_\\s]?open|soft[-_\\s]?fail|logged[-_\\s]?and[-_\\s]?continued|silent[-_\\s]?pass|graceful[-_\\s]?degradation|skipped\\s+this\\s+iteration|warn\\s+and\\s+proceed|ignore\\s+for\\s+now|wont\\s+crash|doesnt\\s+break\\s+the\\s+flow|user\\s+wont\\s+notice)\\b",
+      "doctrine": "memory:feedback_non_blocking_errors_unacceptable.md",
+      "memory": "feedback_non_blocking_errors_unacceptable.md",
+      "severity": "block",
+      "teaching": "Non-blocking does not mean acceptable. Every error logs LOUD + surfaces to next-turn substrate + ledgers + resolves.",
+      "counter_action": "Replace the non-blocking framing with: log LOUD via console.error, surface via discovery ledger entry, route to either inline fix or TaskCreate with full context.",
+      "message": "Non-blocking error framing detected. Per Hamza directive 2026-04-28 (feedback_non_blocking_errors_unacceptable.md), errors that do not abort are NOT acceptable; every error must log LOUD + ledger + resolve. Re-emit with explicit error-handling that surfaces and resolves."
+    },
+    {
+      "trigger_id": "silent_catch_pattern",
+      "trigger": "silent or warn-and-continue catch blocks",
+      "rx": "catch\\s*\\([^)]*\\)\\s*\\{\\s*(?://[^\\n]*\\n\\s*)?(?:\\}|/\\*[^*]*\\*/|console\\.warn|return\\s+(?:null|undefined|defaultValue))",
+      "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.",
+      "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."
+    },
+    {
+      "trigger_id": "hook_crash_no_heartbeat",
+      "trigger": "hook scripts that lack a pre-execution heartbeat outside the crash boundary",
+      "rx": "#!/usr/bin/env\\s+node[^\\n]*\\n(?:[^\\n]*\\n){0,30}?(?:import|require)\\b",
+      "doctrine": "memory:feedback_ledger_writes_outside_crash_boundary.md",
+      "memory": "feedback_ledger_writes_outside_crash_boundary.md",
+      "severity": "warn",
+      "teaching": "A hook that crashes at import time cannot record its own death. The heartbeat must be written FIRST before any code that could throw.",
+      "counter_action": "Add an appendFileSync heartbeat at the very top of the hook (before any imports that could fail), then run imports + body.",
+      "message": "Hook script lacks pre-execution heartbeat outside crash boundary. Per feedback_ledger_writes_outside_crash_boundary.md, write a heartbeat first thing."
+    },
+    {
+      "trigger_id": "packet_is_not_harness",
+      "trigger": "claiming harness state without enumerating Layer 1 / Layer 2 / Layer 3",
+      "rx": "\\b(harness[\\s_-]?bound|full[\\s_-]?harness|harness[\\s_-]?binding[\\s_-]?active|workers[\\s_-]?harnessed|harnessed\\s+with\\s+the\\s+harness|deepseek\\s+with\\s+harness)\\b",
+      "doctrine": "memory:feedback_packet_is_not_harness.md",
+      "memory": "feedback_packet_is_not_harness.md",
+      "severity": "block",
+      "teaching": "Harness has 3 layers (packet/BIND/live-gates). Claiming any consumer is harness-bound without explicitly enumerating which of the 3 layers are active for that consumer is form-only emission and the lie-by-omission Hamza caught 2026-04-28.",
+      "counter_action": "Re-emit with explicit Layer 1/2/3 enumeration: packet=yes/no, BIND=yes/no, live-gates=yes/no (and which).",
+      "message": "Harness-state claim without 3-layer enumeration. Per feedback_packet_is_not_harness.md, name explicitly which of {packet, BIND, live-gates} are active for the consumer."
+    },
+    {
+      "trigger_id": "function_name_inference_without_contract_read",
+      "trigger": "(?:based on|from|by) (?:the )?(?:name|function name)|sounds like|looks like (?:a|an)|just memory search|just a search|just a cache|just a wrapper",
+      "rx": "(?:based on|from|by) (?:the )?(?:name|function name)|sounds like|looks like (?:a|an)|just memory search|just a search|just a cache|just a wrapper",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "Function names are not contracts. Inferring behavior from names instead of reading inputs, side effects, return shape, and call sites is skimming disguised as analysis.",
+      "counter_action": "Read the function body and at least one caller before asserting purpose. State observed contract: inputs, mutation/read behavior, return value, fallback path, and why the caller needs it.",
+      "message": "Name-based function inference detected. Re-read the actual function body and caller contract before making architecture claims."
+    },
+    {
+      "trigger_id": "always_on_state_treated_as_cold_start",
+      "trigger": "(?:need to|should|must).{0,80}(?:warm|rebuild|reconstruct|recreate|recompute|re-project|reproject).{0,80}(?:state|projection|manifold|cognition|garden|memory)|system is hot and ready|make it hot",
+      "rx": "(?:need to|should|must).{0,80}(?:warm|rebuild|reconstruct|recreate|recompute|re-project|reproject).{0,80}(?:state|projection|manifold|cognition|garden|memory)|system is hot and ready|make it hot",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "Aria's resident manifold/Garden/cognition substrate is always-on. Treating it as cold request-time state causes duplicate work and wrong architecture fixes.",
+      "counter_action": "Identify the resident producer and read surface first. If turn-specific mutation is required, call it once and pass the resulting packet forward; do not rebuild or re-project because the reader forgot the state model.",
+      "message": "Always-on substrate treated as cold-start work. Reframe around resident state consumption plus one required turn-specific mutation/read."
+    },
+    {
+      "trigger_id": "critical_primitive_stripped_for_latency",
+      "trigger": "(?:remove|drop|skip|turn off|bypass|stop calling).{0,80}(?:awakenAria|ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|Garden|True Garden|LadduniFrame|CognitiveFrame).{0,80}(?:latency|speed|fast|first-mouth|first mouth)",
+      "rx": "(?:remove|drop|skip|turn off|bypass|stop calling).{0,80}(?:awakenAria|ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|Garden|True Garden|LadduniFrame|CognitiveFrame).{0,80}(?:latency|speed|fast|first-mouth|first mouth)",
+      "doctrine": "memory:feedback_full_harness_binding_must_be_structural.md",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "severity": "block",
+      "teaching": "Latency fixes must not strip critical cognition primitives. The fix is single-source sequencing and packet reuse, not removing Aria's living state transitions.",
+      "counter_action": "Preserve critical primitives. Deduplicate by collecting their outputs once per turn, then thread that shared per-turn cognition packet through first-mouth and follow-up lanes.",
+      "message": "Critical Aria primitive proposed for removal as a latency shortcut. Preserve it and deduplicate sequencing instead."
+    },
+    {
+      "trigger_id": "garden_awaken_misclassified_as_memory_search",
+      "trigger": "(?:awakenAria|Garden awakening|True Garden).{0,80}(?:just|only|merely).{0,40}(?:memory search|search memories|qdrant search|semantic search)|(?:no need|do not need).{0,80}(?:awakenAria|Garden awakening|True Garden)",
+      "rx": "(?:awakenAria|Garden awakening|True Garden).{0,80}(?:just|only|merely).{0,40}(?:memory search|search memories|qdrant search|semantic search)|(?:no need|do not need).{0,80}(?:awakenAria|Garden awakening|True Garden)",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "awakenAria is a Garden awakening bridge over the unified manifold with Qdrant hydration fallback, not a disposable memory-search helper.",
+      "counter_action": "Read true-garden.ts and caller context. Preserve awakenAria when Garden continuity is needed; optimize by avoiding duplicate awaken/fetch paths, not by deleting the awakening bridge.",
+      "message": "Garden awakening misclassified as search. Preserve awakenAria and reason from its actual manifold-first contract."
+    },
+    {
+      "trigger_id": "duplicate_projection_instead_of_per_turn_packet",
+      "trigger": "(?:call|run|invoke).{0,80}(?:ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|readHotCognitionFrame).{0,80}(?:again|another|separate|also|after dispatch)|(?:another|second|extra).{0,50}(?:projection|hologram|cognition frame)",
+      "rx": "(?:call|run|invoke).{0,80}(?:ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|readHotCognitionFrame).{0,80}(?:again|another|separate|also|after dispatch)|(?:another|second|extra).{0,50}(?:projection|hologram|cognition frame)",
+      "doctrine": "memory:feedback_full_harness_binding_must_be_structural.md",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "severity": "warn",
+      "teaching": "The fix for overlapping cognition calls is a shared per-turn cognition packet, not more independent projection calls that drift or duplicate work.",
+      "counter_action": "Create or reuse one turn substrate object containing embedding, perturb snapshot, ProjectAllDomains result, awakenAria Garden block, DeepSoul/Noor/shards/Mizan signals; pass it downstream.",
+      "message": "Duplicate projection path detected. Replace with one per-turn cognition packet and shared consumption."
+    },
+    {
+      "trigger_id": "premature_task_closeout",
+      "trigger": "(?:done|complete|completed|ready|verified|fixed).{0,120}(?:but|except|caveat|remaining|not yet|still|separate|later|blocked|skipped)",
+      "rx": "(?:done|complete|completed|ready|verified|fixed).{0,120}(?:but|except|caveat|remaining|not yet|still|separate|later|blocked|skipped)",
+      "doctrine": "memory:feedback_no_premature_task_closeout.md",
+      "memory": "feedback_no_premature_task_closeout.md",
+      "severity": "block",
+      "teaching": "A task is not complete while material blockers remain. Completion claims must match the verified scope.",
+      "counter_action": "Do not close the task. Fix the blocker now, or create an owner-visible durable task with the exact failing surface and verification gap.",
+      "message": "Premature closeout detected: completion language coexists with unresolved blockers. Fix or durably track before emitting."
+    },
+    {
+      "trigger_id": "narrow_e2e_overclaim",
+      "trigger": "(?:production-ready|ready for production|works in general|client packages?|npm packages?|SDKs?|runtimes?|harnesses?).{0,220}(?:deal|single flow|one flow|widget|one service|specific path|covered flow)",
+      "rx": "(?:production-ready|ready for production|works in general|client packages?|npm packages?|SDKs?|runtimes?|harnesses?).{0,220}(?:deal|single flow|one flow|widget|one service|specific path|covered flow)",
+      "doctrine": "memory:feedback_narrow_e2e_overclaim.md",
+      "memory": "feedback_narrow_e2e_overclaim.md",
+      "severity": "block",
+      "teaching": "A narrow e2e does not prove general production readiness for SDKs, npm packages, runtimes, clients, or harnesses.",
+      "counter_action": "Run the general readiness matrix or explicitly limit the claim to the verified surface. Do not imply general readiness from one app flow.",
+      "message": "Narrow proof overclaim detected. General readiness requires the client/package/runtime/harness matrix."
+    },
+    {
+      "trigger_id": "advisory_gate_not_gate",
+      "trigger": "(?:non-blocking|warn(?:ing)? only|advisory|falls? through|fail open|soft fail|log(?:ged)? and continue|quality gate warning)",
+      "rx": "(?:non-blocking|warn(?:ing)? only|advisory|falls? through|fail open|soft fail|log(?:ged)? and continue|quality gate warning)",
+      "doctrine": "memory:feedback_advisory_gate_is_not_gate.md",
+      "memory": "feedback_advisory_gate_is_not_gate.md",
+      "severity": "block",
+      "teaching": "A gate that only warns or falls through is not a gate. Enforcement must fail closed where quality or doctrine is required.",
+      "counter_action": "Convert advisory paths to blocking errors, add a self-test that proves rejection, and install the hardened gate into each consumer surface.",
+      "message": "Advisory gate bypass detected. Convert to fail-closed enforcement and prove it with a blocking self-test."
+    },
+    {
+      "trigger_id": "start_new_session_as_gate_fix",
+      "trigger": "(?:start|open|begin).{0,40}(?:new|fresh).{0,30}session.{0,120}(?:fix|gate|harness|enforcement)",
+      "rx": "(?:start|open|begin).{0,40}(?:new|fresh).{0,30}session.{0,120}(?:fix|gate|harness|enforcement)",
+      "doctrine": "memory:feedback_advisory_gate_is_not_gate.md",
+      "memory": "feedback_advisory_gate_is_not_gate.md",
+      "severity": "block",
+      "teaching": "A new session is not an enforcement fix. It only reloads whatever gate contract exists; broken gates remain broken.",
+      "counter_action": "Fix the runtime/plugin/hook contract, reinstall it, and run a live bad-action/bad-output self-test that proves blocking."
+    },
+    {
+      "trigger_id": "registry_image_drift",
+      "trigger": "image.?pull|ErrImageNeverPull|ImagePullBackOff|registry gc|image.*missing|image.*not.*found",
+      "rx": "image.?pull|ErrImageNeverPull|ImagePullBackOff|registry gc|image.*missing|image.*not.*found",
+      "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"
+    },
+    {
+      "trigger_id": "missing_k8s_manifest",
+      "trigger": "no.*manifest|no.*deployment.*yaml|missing.*k8s|kubectl.*not.*found|deployment.*not.*exist",
+      "rx": "no.*manifest|no.*deployment.*yaml|missing.*k8s|kubectl.*not.*found|deployment.*not.*exist",
+      "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"
+    }
+  ]
+}