harness-everything 0.6.1 → 0.8.0

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,40 +4,34 @@ description: "Route software/project work through the Harness kernel: classify T
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.8.0
 ---
 
 # Harness Everything
 
-Public/manual Harness kernel entry. Hook-capable hosts should run the kernel before peer/domain skill selection.
+Kernel routing entry.
 
 ## USE FOR:
-- Software triage/re-routing, including work that already names or strongly matches another skill.
-- Inspecting Tier, invariants, or suggestions.
+- Software/project triage, re-routing, and suggested-skill evaluation.
+- Work that names or matches another skill.
 
 ## DO NOT USE FOR:
 - General Q&A or non-software writing.
 
 ## Invariants
+1. **Route before execution** — establish scope/tier.
+2. **Verify before claim** — require objective evidence.
+3. **Re-plan on repetition** — after 3 same-signature failures, use `zoom-out`.
+4. **Evaluate before skip** — read each suggested skill's complete `SKILL.md`.
 
-1. **Route before execution** — establish scope/tier before mutation.
-2. **Verify before claim** — completion needs objective evidence.
-3. **Re-plan on repetition** — after 3 same-signature failures, stop micro-retrying and use `zoom-out`/fresh diagnosis.
-
-These rails are mandatory; Tier guidance is not a fixed pipeline.
+Tier guidance is not a fixed pipeline.
 
 ## Workflow
+1. Reuse kernel output, or run `node "<this-skill-dir>/scripts/kernel-router.js" "<prompt summary>"`.
+2. Make the **Harness Routing Checkpoint** user-visible.
+3. For every suggestion, read its `SKILL.md`; evaluate `USE FOR`, `DO NOT USE FOR`, workflow/basic flow, and hard rules. Name, description, router summary, or "routine/common task" alone cannot justify skip. Read extra material only when explicitly required for applicability.
+4. Execution is advisory after evaluation. Unreadable suggestions are `unresolved/unavailable`. Using one suggestion does not waive evaluation of others. If all are skipped, give one brief flow-grounded reason.
 
-1. Reuse current-turn kernel output, or run `node "<this-skill-dir>/scripts/kernel-router.js" "<prompt summary>"`.
-2. Preserve the invariants.
-3. Treat suggested skills as advisory: choose, combine, reorder, or omit them as useful.
-
-## Tier Guidance
-
-- **Tier 1:** Prefer direct execution.
-- **Tier 2:** TODO tracking, TDD, and verification are common suggestions.
-- **Tier 3:** Fable/multi-agent skills are optional when macro planning or delegation helps.
-
-**Rule:** do not enforce workflow order; let the agent orchestrate itself inside the invariants.
+**Rule:** mandatory evaluation, advisory execution; no fixed workflow order.
 
 Deep dive: <this-skill-dir>/references/triage-and-tiers.md

package/plugins/harness-everything/skills/harness-everything/references/triage-and-tiers.md

@@ -1,8 +1,8 @@
 # Task Triage & Tier Details
 
-Harness uses tiers to estimate scope and surface useful capabilities. A tier is **not** a fixed pipeline. The runtime enforces a very small set of cross-cutting invariants and leaves tactics, skill choice, ordering, and delegation to the agent.
+Harness uses tiers to estimate scope and surface useful capabilities. A tier is **not** a fixed pipeline. The runtime enforces a small set of cross-cutting invariants plus mandatory evaluation of router-suggested skills; execution choice, ordering, and delegation remain with the agent after that evaluation.
 
-> Architecture rule: **Do not enforce workflow order. Enforce workflow invariants.**
+> Architecture rule: **Do not enforce workflow order. Enforce workflow invariants and evaluate suggestions before skipping them.**
 
 ## 0. When Harness Routing Applies
 
@@ -12,19 +12,18 @@ flowchart TD
     S -- No --> B[Bypass Harness<br/>Answer naturally]
     S -- Yes --> K[Harness Kernel<br/>classify scope + inject invariants]
     K --> T{Tier recommendation}
-    T -- Tier 1 --> A1[Prefer direct execution]
-    T -- Tier 2 --> A2[Agent chooses useful domain skills]
-    T -- Tier 3 --> A3[Agent chooses planning / delegation if useful]
-    A1 --> E[Execute with agent-selected tactics]
-    A2 --> E
-    A3 --> E
+    T --> G{Suggested skills?}
+    G -- Yes --> R[Read each suggested SKILL.md<br/>evaluate basic flow + applicability]
+    G -- No --> C[Agent chooses smallest useful tactic]
+    R --> C
+    C --> E[Execute with agent-selected tactics]
     E --> V{Objective evidence supports completion?}
-    V -- No --> R[Diagnose / iterate]
-    R --> F{Same-signature failure x3?}
+    V -- No --> D[Diagnose / iterate]
+    D --> F{Same-signature failure x3?}
     F -- No --> E
     F -- Yes --> Z[Zoom out / re-plan]
     Z --> E
-    V -- Yes --> D([Claim completion])
+    V -- Yes --> O([Claim completion])
 ```
 
 ### Bypass Rules
@@ -43,16 +42,18 @@ The kernel exists to keep strong models free while protecting the few behaviors
 1. **Route before execution** — establish task scope/tier before mutating software work.
 2. **Verify before claim** — completion claims require objective evidence appropriate to the change.
 3. **Re-plan on repetition** — after three same-signature failures, stop micro-retrying and use a fresh diagnosis / `zoom-out`.
+4. **Evaluate before skip** — when the router suggests a skill, read that skill's complete `SKILL.md` entry/basic flow before omitting it.
 
-These are the rails. Everything else is agent judgment unless the user or an authoritative project document explicitly requires it.
+The fourth invariant is conditional: it applies when the router emits one or more suggestions. It makes **evaluation mandatory, not execution**.
 
 ### What is intentionally *not* mandatory
 
-- Loading `todo-driven-workflow` for every Tier 2/3 task.
-- Running TDD for changes where executable behavioral tests do not add value.
-- Entering Fable/multi-agent mode merely because the task is Tier 3.
+- Executing `todo-driven-workflow` for every Tier 2/3 task after its applicability has been evaluated.
+- Running TDD where the `tdd` flow has been read and executable behavioral tests do not add value.
+- Entering Fable/multi-agent mode merely because the task is Tier 3 after those suggested flows have been evaluated.
 - Following a universal `TODO → TDD → verification-loop` or `Fable → subagent → verification-loop` sequence.
 - Loading `install-cognitive-os` as a peer skill before every other skill.
+- Reading every optional deep-dive/reference linked by a suggested skill. Only material the skill entry explicitly requires to decide applicability joins the mandatory evaluation set.
 
 `install-cognitive-os` remains the human-readable/manual entry point for the cognitive policy. Supported runtime integrations should establish the kernel invariants without depending on that skill being selected first.
 
@@ -73,14 +74,26 @@ npx github:dyphn1/Harness-everything next "<brief prompt summary>"
 `kernel-router.js` delegates classification and guide discovery to `tier-router.js`, removes legacy fixed-pipeline instructions, and emits:
 
 - the recommended tier and rationale,
+- a compact **Harness Routing Checkpoint**,
 - the **required Harness invariants**,
-- **suggested skills** marked advisory,
-- the policy that the agent may choose the smallest useful skill/tool set.
+- suggested skills under a **mandatory evaluation / advisory execution** contract,
+- the policy that the agent may choose the smallest useful skill/tool set after evaluating suggestions.
 
-If a host's `UserPromptSubmit` integration already ran the kernel this turn, reuse that output rather than running it twice.
+If a host's `UserPromptSubmit` integration already ran the kernel this turn, reuse that output rather than running it twice. The checkpoint must still become user-visible for software/project work: use the host's visible hook rendering when it has one, otherwise include the checkpoint in the first progress/update message.
 
 The tier classifier is heuristic. Treat its result as the default route, not an oracle. A clear task reading or explicit user instruction may override it; record the reason when doing so.
 
+### Suggestion evaluation contract
+
+For every router-suggested skill:
+
+1. Resolve and read the complete `SKILL.md` entry.
+2. Evaluate `USE FOR`, `DO NOT USE FOR`, its workflow/basic flow, and any hard rules in the entry against the current task.
+3. If the entry explicitly requires another document to determine applicability, read that required material too. Ordinary deep-dive/reference links remain optional unless the entry makes them decision-critical.
+4. Only then choose `use`, `skip`, or `unresolved/unavailable`.
+
+A skill must not be skipped from only its name, frontmatter description, router summary, or a generic judgement such as “routine/common task.” Using one suggested skill does not waive evaluation of the other suggestions before they are skipped. A suggestion that cannot be resolved/read is not a valid skip; mark it `unresolved/unavailable`.
+
 ## 3. Tier Guidance
 
 ### Tier 1 — Trivial
@@ -94,7 +107,8 @@ Typical shape:
 Default behavior:
 - prefer direct execution,
 - avoid large plans and unnecessary delegation,
-- load a focused skill only when it materially improves the result,
+- when the router emits no suggestions, proceed with the bounded direct path,
+- when it does emit a focused suggestion, evaluate that skill entry before omitting it,
 - still verify any completion claim with evidence appropriate to the change.
 
 ### Tier 2 — Standard
@@ -116,7 +130,7 @@ Common **suggestions**, not a pipeline:
 | Isolated workspace would reduce risk | `using-git-worktrees` |
 | Quantitative scoring/benchmarking is requested | `eval-harness` |
 
-The model decides which of these are useful and in what order. It may use none, one, or several while preserving the kernel invariants.
+Every emitted suggestion is mandatory to **evaluate** by reading its skill entry/basic flow. After that, the model decides which skills are useful and in what order; it may execute none, one, or several while preserving the kernel invariants. Adopting one suggestion does not permit the others to be skipped without evaluation. If every suggestion is skipped after evaluation, the visible checkpoint/progress update must include one brief reason grounded in the evaluated flow mismatch.
 
 ### Tier 3 — Macro
 
@@ -137,7 +151,7 @@ Common **suggestions**, not a pipeline:
 | Settled intent needs a spec | `to-spec` |
 | Settled work needs tracer-bullet issues | `to-tickets` |
 
-Tier 3 does **not** automatically require multi-agent execution. A strong model may complete macro work directly when that is the safer/smaller choice.
+Tier 3 does **not** automatically require multi-agent execution. It does require evaluation of the suggested entries before omission. A strong model may still complete macro work directly when, after reading those flows, direct execution is the safer/smaller choice. The same evaluated all-skipped rationale rule applies.
 
 ## 4. Cognitive OS Relationship
 
@@ -160,28 +174,31 @@ But this diagram describes a reasoning policy, not a peer-skill dependency graph
 
 | Host mode | Expected behavior |
 |---|---|
-| Lifecycle hook available | Run the Harness Kernel on prompt submission so routing context exists before domain-skill execution. Hard gates may enforce supported invariants at tool/stop boundaries. |
-| Advisory instructions only | Tell the agent to run/reuse `harness next` before software mutation and `harness verify` before completion. The behavior is advisory, not a hard gate. |
-| Manual use | Invoke `harness-everything` or `install-cognitive-os` explicitly to inspect/re-establish the contract. |
+| Lifecycle hook available | Run the Harness Kernel on prompt submission so routing context exists before domain-skill execution. Surface the emitted checkpoint through a host-visible hook surface when supported; otherwise the agent carries it into the first visible progress/update. Suggested-skill execution stays agent-controlled, but each suggested skill must be evaluated before omission. Hard gates may enforce supported invariants at tool/stop boundaries. |
+| Advisory instructions only | Tell the agent to run/reuse `harness next` before software mutation, surface the checkpoint, read/evaluate each suggested skill before skipping it, and run `harness verify` before completion. The behavior is instruction-governed, not a hard host gate. |
+| Manual use | Invoke `harness-everything` or `install-cognitive-os` explicitly to inspect/re-establish and surface the contract; suggested skills still follow read-before-skip. |
 
-Never describe an advisory integration as hard enforcement. Platform-specific adapters may differ while preserving functional intent.
+Never describe an advisory integration as hard enforcement. Platform-specific adapters may differ while preserving functional intent. Kernel emission alone is not proof that a host UI displayed the checkpoint or that the host compelled the model to read a suggested skill; #82 live evidence owns those claims.
 
 ## 6. Routing Checkpoint
 
-When a visible checkpoint is useful, keep it small:
+For software/project work, the kernel always emits a compact checkpoint and the execution surface must make it user-visible before or with the first progress update:
 
 ```markdown
 ## 🚦 Harness Routing Checkpoint
 - Tier: Tier X — <reason>
-- Required invariants: route-before-execution; verify-before-claim; re-plan-after-3-same-failures
-- Suggested skills: <only the skills that appear useful>
+- Strategy: <selected/deferred strategy>
+- Required invariants: route-before-execution; verify-before-claim; re-plan-after-3-same-failures; evaluate-suggestions-before-skip (when suggestions exist)
+- Suggested skills: <deduplicated suggestions, or none>
+- Suggestion evaluation: <required before skip | no suggestions>
+- Suggestion disposition: <using one or more | skipped all after evaluation — brief reason | unresolved/unavailable>
 ```
 
-The checkpoint reports state; it does not prescribe a universal workflow.
+The checkpoint reports state; it does not prescribe a universal workflow. Suggested skills are **mandatory to evaluate and advisory to execute**. A non-empty suggestion set cannot disappear silently or be rejected from summaries alone. When every suggestion is skipped after evaluation, state one brief reason grounded in the evaluated flows. When at least one is used, no prose explanation is required for each other omission, but read-before-skip still applies to every omitted suggestion.
 
 ## 7. Self-Healing and Dynamic Skills
 
-Existing self-heal, generated-skill discovery, knowledge-guide matching, and fact-audit behavior remain part of the classifier/runtime. They may recommend resources but should not silently convert recommendations into mandatory pipeline stages.
+Existing self-heal, generated-skill discovery, knowledge-guide matching, and fact-audit behavior remain part of the classifier/runtime. They may recommend resources; recommendations trigger mandatory applicability evaluation, not automatic execution or mandatory pipeline stages.
 
 If bootstrap reports missing integration touchpoints, use the existing self-heal command:
 

package/plugins/harness-everything/skills/harness-everything/scripts/kernel-router.js

@@ -25,6 +25,7 @@ const INVARIANT_TEXT = {
   'scope-lock': 'Route before execution: stay inside the authorized task/repository scope.',
   'verify-before-claim': 'Verify before claim: completion claims require objective evidence appropriate to the change.',
   'replan-after-repeated-failure': 'Re-plan on repetition: after 3 same-signature failures, stop micro-retrying and zoom out/re-diagnose.',
+  'evaluate-suggestions-before-skip': 'Evaluate before skip: read each suggested skill\'s complete SKILL.md entry/basic flow before omitting it.',
   'loop-budget': 'Stop iterative-single when its explicit iteration budget is exhausted.',
   'objective-verification': 'Use an objective check for iterative work; self-critique alone is not verification.',
   'stage-contracts': 'Fable stages must have explicit stage contracts and pass conditions.',
@@ -117,13 +118,49 @@ function printWorkflowPlan(plan) {
   console.log(`\n=> ROUTER WORKFLOW PLAN (JSON): ${JSON.stringify(visible)}`);
 }
 
+function uniqueSuggestedSkills(plan) {
+  if (!Array.isArray(plan.suggestedSkills)) return [];
+  return [...new Set(plan.suggestedSkills.filter(skill => typeof skill === 'string' && skill.trim()))];
+}
+
+function enforceSuggestionEvaluation(plan) {
+  if (uniqueSuggestedSkills(plan).length === 0) return;
+  if (!Array.isArray(plan.requiredInvariants)) plan.requiredInvariants = [];
+  if (!plan.requiredInvariants.includes('evaluate-suggestions-before-skip')) {
+    plan.requiredInvariants.push('evaluate-suggestions-before-skip');
+  }
+}
+
+function displayTier(tier) {
+  if (tier === 'tier1') return 'Tier 1';
+  if (tier === 'tier2') return 'Tier 2';
+  if (tier === 'tier3') return 'Tier 3';
+  return tier || 'unclassified';
+}
+
+function printRoutingCheckpoint(plan) {
+  const invariants = Array.isArray(plan.requiredInvariants) ? plan.requiredInvariants : [];
+  const suggestions = uniqueSuggestedSkills(plan);
+
+  console.log('\n=> HARNESS ROUTING CHECKPOINT (REQUIRED VISIBLE STATE):');
+  console.log(`   - Tier: ${displayTier(plan.tier)}`);
+  console.log(`   - Strategy: ${plan.strategy || 'deferred'}`);
+  console.log(`   - Required invariants: ${invariants.length ? invariants.join(', ') : 'none'}`);
+  console.log(`   - Suggested skills: ${suggestions.length ? suggestions.join(', ') : 'none'}`);
+  if (suggestions.length > 0) {
+    console.log('   - Suggestion evaluation: MANDATORY. Before skipping any listed skill, read its complete SKILL.md entry and evaluate USE FOR, DO NOT USE FOR, workflow/basic flow, and hard rules.');
+    console.log('   - Skip evidence: do not reject from only the skill name, description, router summary, or a generic "routine/common task" judgement. If the entry cannot be resolved/read, mark it unresolved/unavailable rather than skipped.');
+    console.log('   - Suggestion disposition: execution is advisory after evaluation. Using one suggestion does not waive read-before-skip for other omitted suggestions. If all are skipped after evaluation, state one brief reason grounded in the evaluated flows in the first visible progress/update message.');
+  }
+}
+
 function printKernelContract(plan) {
   console.log('\n=> REQUIRED HARNESS INVARIANTS:');
   for (const invariant of plan.requiredInvariants || []) {
     console.log(`   - ${invariant}: ${INVARIANT_TEXT[invariant] || 'Required by the selected workflow plan.'}`);
   }
 
-  console.log('\n=> SUGGESTED SKILLS (ADVISORY — no fixed workflow order):');
+  console.log('\n=> SUGGESTED SKILLS (MANDATORY EVALUATION — ADVISORY EXECUTION):');
   if (Array.isArray(plan.suggestedSkills) && plan.suggestedSkills.length > 0) {
     const emitted = new Set();
     for (const skill of plan.suggestedSkills) {
@@ -133,11 +170,12 @@ function printKernelContract(plan) {
       emitted.add(skill);
       if (skill === 'fable-mode') emitted.add('fable-discipline');
     }
+    console.log('   - Read-before-skip: evaluate every suggested skill entry before omission; adopting one suggestion does not waive evaluation of the others.');
     if (plan.strategy && plan.strategy.startsWith('fable-')) {
-      console.log('   - Use these selectively; Tier 3/Fable does not create a universal skill pipeline.');
+      console.log('   - Use these selectively after evaluation; Tier 3/Fable does not create a universal skill pipeline.');
     }
   } else if (plan.strategy === 'direct-single') {
-    console.log('   - No mandatory domain skill. Prefer the bounded direct path and load a focused skill only when it adds value.');
+    console.log('   - No domain skill was suggested. Prefer the bounded direct path and load a focused skill only when it adds value.');
   } else if (plan.strategySelection === 'deferred') {
     console.log('   - Strategy is deferred/unclassified. Do not infer triviality; choose the smallest justified approach from task evidence.');
   } else {
@@ -160,7 +198,7 @@ function printKernelContract(plan) {
     console.log('\n=> ROUTING DEGRADATION: Structured routing is degraded. Keep the strategy deferred unless independent evidence supports a route; do not silently downgrade to Tier 1/direct execution.');
   }
 
-  console.log('\n=> ORCHESTRATION POLICY: Do not enforce workflow order. Enforce workflow invariants from the plan; suggested skills remain advisory. The router plans; execution components execute.');
+  console.log('\n=> ORCHESTRATION POLICY: Do not enforce workflow order. Enforce workflow invariants from the plan. Suggested-skill evaluation is mandatory; execution remains advisory after evaluation. The router plans; execution components execute.');
 }
 
 function run(prompt, stdinPayload) {
@@ -187,6 +225,7 @@ function run(prompt, stdinPayload) {
 
   const contract = readStructuredContract(contractPath);
   applyEnsemblePolicy(contract, resolvePrompt(prompt, stdinPayload));
+  enforceSuggestionEvaluation(contract.workflowPlan);
   try {
     fs.rmSync(contractPath, { force: true });
   } catch (err) {
@@ -194,6 +233,7 @@ function run(prompt, stdinPayload) {
   }
 
   printWorkflowPlan(contract.workflowPlan);
+  printRoutingCheckpoint(contract.workflowPlan);
   printKernelContract(contract.workflowPlan);
 
   if (result.status !== 0) process.exit(result.status === null ? 1 : result.status);

package/scripts/lib/advisory-text.js

@@ -13,25 +13,28 @@ const advisoryInstructions = [
   `these as strong defaults, not guarantees.`,
   ``,
   `## 🚦 MANDATORY ENTRY TRIAGE & ROUTING (ALWAYS RUN FIRST)`,
-  `Every time you receive a new prompt, you MUST load the \`harness-everything\` skill and immediately do the following:`,
-  `1. Run \`npx github:dyphn1/Harness-everything next "<Brief summary of user's prompt>"\` (this prints the same routing recommendation tier-router.js produces - it works from any directory and does not depend on where a local copy of the skill was installed). If the terminal is not available yet, simulate its routing logic from the rules below instead of skipping this step.`,
-  `2. Output a clear, stylized routing checkpoint block at the VERY BEGINNING of your response to the user:`,
+  `Every time you receive a new software/project prompt, you MUST load the \`harness-everything\` skill and immediately do the following:`,
+  `1. Run \`npx github:dyphn1/Harness-everything next "<Brief summary of user's prompt>"\` (this prints the same routing recommendation kernel-router.js produces - it works from any directory and does not depend on where a local copy of the skill was installed). If the terminal is not available yet, apply the same routing contract from the loaded \`harness-everything\` skill instead of skipping this step.`,
+  `2. For EVERY suggested skill, resolve and read its complete \`SKILL.md\` entry before deciding to skip it. Evaluate \`USE FOR\`, \`DO NOT USE FOR\`, workflow/basic flow, and hard rules against the task. If the entry explicitly requires another document to decide applicability, read that required material too. Do not reject a suggestion from only its name, description, router summary, or because the task seems routine/common.`,
+  `3. After that evaluation, execution is advisory: use, combine, reorder, or skip skills as justified. Using one suggestion does not waive read-before-skip for the others. If a suggested skill cannot be resolved/read, mark it unresolved/unavailable instead of silently skipping it.`,
+  `4. Output a clear routing checkpoint near the beginning of your response/update:`,
   `   \`\`\`markdown`,
   `   ## 🚦 Harness OS Routing Checkpoint`,
   `   - **Active Tier**: Tier 1 (Trivial) | Tier 2 (Standard) | Tier 3 (Macro)`,
-  `   - **Rationale**: <1-sentence rationale from the tier router output>`,
-  `   - **Routed Skills, Guides & Actions**:`,
-  `     - \`path/to/skill/or/guide.md\` (<Brief reason why this guide/skill is loaded/used>)`,
+  `   - **Rationale**: <1-sentence rationale from the router output>`,
+  `   - **Required Invariants**: <router invariants>`,
+  `   - **Suggested Skills**: <deduplicated router suggestions or none>`,
+  `   - **Suggestion Evaluation**: <evaluated before skip | pending | unresolved/unavailable>`,
+  `   - **Disposition**: <skills used, or skipped all after evaluation with a brief flow-grounded reason>`,
   `   \`\`\``,
   ``,
   `## 🤖 COGNITIVE COMPLIANCE (NO SILENT DEGRADES FOR NEW FEATURES)`,
-  `- **Newly Added Features / Extensions**: Copilot is highly prone to treating new feature requests as Tier 1 direct edits. If a task introduces *any* new logic, a new API endpoint, or a new file/module, you **MUST NOT** treat it as Tier 1. It **MUST** be treated as a **Tier 2 (Standard Task)** or **Tier 3 (Macro Task)**.`,
-  `- **Tier 2 Activation**: Initialize the \`todo-driven-workflow\` checklist first. Summon Domain Experts based on tech stack. Load and execute the \`tdd\` (Test-Driven Development) skill (write tests first, implement, refactor).`,
-  `- **Tier 3 Activation**: Initialize the \`todo-driven-workflow\` checklist, load \`fable-mode\` and \`fable-discipline\`, run sub-agents via \`multi-agent-workspace\`, and write global docs using \`repo-docs\`.`,
-  `- **Pre-Completion Verification Gate**: Before telling the human the task is done, run \`npx github:dyphn1/Harness-everything verify\` in the project root. If it exits non-zero, fix the failures and run it again before declaring completion. On Claude Code this same check is mechanically enforced by a stop hook; here nothing blocks you from skipping it, so treat it as a real requirement, not a suggestion.`,
-  `- **Memory Summarization (Self-Evolve)**: Upon task completion, you **MUST** run the \`self-evolve\` skill (running \`node self-evolve/scripts/self-regression.js\` or writing memories) to record key insights, lessons learned, and error boundaries so your context builds across sessions.`,
+  `- **Newly Added Features / Extensions**: Do not silently collapse a task that introduces new logic, a new API endpoint, or a new file/module into a trivial direct-edit path. Route it first and justify the tier from task evidence.`,
+  `- **Tier 2 / Tier 3 Suggestions**: There is NO universal TODO/TDD/Fable sequence. Router suggestions are mandatory to evaluate by reading their skill entry, but optional to execute after that evaluation. Choose the smallest applicable set.`,
+  `- **Pre-Completion Verification Gate**: Before telling the human the task is done, run \`npx github:dyphn1/Harness-everything verify\` in the project root. If it exits non-zero, fix the failures and run it again before declaring completion. On Claude Code this same check can be mechanically enforced by a stop hook; here nothing blocks you from skipping it, so treat it as a real requirement, not a suggestion.`,
+  `- **Memory Summarization (Self-Evolve)**: When the task produces a reusable verified lesson, use the \`self-evolve\` flow to persist it; do not manufacture memory for routine work.`,
   `- **Environment Discovery**: Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
-  `- **Rule of 3**: If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the human for direction instead of continuing to guess.`,
+  `- **Rule of 3**: If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and use a fresh diagnosis / zoom-out instead of continuing to guess.`,
   `- **Prefer Editing**: Prefer editing over rewriting; commit logically complete chunks rather than one giant diff.`,
   ``
 ].join('\n');
@@ -144,17 +147,16 @@ function buildCodexGlobalContent() {
     ``,
     `# ${MARKER}`,
     `This file is advisory only - this platform has no hook/execution mechanism to`,
-    `enforce it mechanically (unlike Claude Code's hook-based circuit breaker). Treat`,
-    `these as strong defaults, not guarantees.`,
+    `enforce it mechanically. Treat these as strong defaults, not guarantees.`,
     ``,
     `- Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
-    `- Triage tasks: run \`npx github:dyphn1/Harness-everything next "<summary>"\` for a routing recommendation`,
-    `  (trivial fixes need no plan; standard features need tests; large refactors need an explicit plan`,
-    `  reviewed with the human before implementation).`,
+    `- For software/project work, run \`npx github:dyphn1/Harness-everything next "<summary>"\` before mutation and surface the routing checkpoint.`,
+    `- For EVERY suggested skill, read its complete \`SKILL.md\` entry/basic flow before skipping it. Evaluate \`USE FOR\`, \`DO NOT USE FOR\`, workflow, and hard rules; do not skip from the name/description/router summary alone.`,
+    `- Suggested-skill execution remains optional after evaluation. Using one suggestion does not waive evaluation of the other omitted suggestions; unreadable suggestions are unresolved/unavailable, not silently skipped.`,
+    `- Do not impose a universal TODO/TDD/Fable sequence. Choose the smallest applicable skill set after evaluation.`,
     `- Before declaring a task done, run \`npx github:dyphn1/Harness-everything verify\` and fix any failures`,
     `  it reports - nothing here blocks you from skipping this, so treat it as a real requirement.`,
-    `- If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the`,
-    `  human for direction instead of continuing to guess.`,
+    `- If the same error repeats 3 times in a row, STOP retrying and use a fresh diagnosis / zoom-out.`,
     `- Prefer editing over rewriting; commit logically complete chunks rather than one giant diff.`,
     ``
   ].join('\n');