harness-everything 0.30.6 → 0.30.8

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.30.6",
+      "version": "0.30.8",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.30.6",
+  "version": "0.30.8",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.30.8](https://github.com/dyphn1/Harness-everything/compare/v0.30.7...v0.30.8) (2026-10-07)
+
+### Bug Fixes
+
+* **fable:** align discipline side effects ([#275](https://github.com/dyphn1/Harness-everything/issues/275) [#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([8aa4c99](https://github.com/dyphn1/Harness-everything/commit/8aa4c99778c7f2c70e3ca434fce9ff34d30e7ea7))
+* **fable:** compact contract and preserve advisory divergence ([81a97ad](https://github.com/dyphn1/Harness-everything/commit/81a97ad82c131f406aa2000bcda15e8819802744))
+* **fable:** make build divergence advisory ([#275](https://github.com/dyphn1/Harness-everything/issues/275)) ([45aa418](https://github.com/dyphn1/Harness-everything/commit/45aa418b596e6bb11f8f9a08e0217923263c7594))
+* **fable:** make commit boundaries permission-aware ([#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([c778dd4](https://github.com/dyphn1/Harness-everything/commit/c778dd4f98b3ac4ecd375e2173d0bc839083b153))
+* **fable:** restore semantic contract strength ([df80aa0](https://github.com/dyphn1/Harness-everything/commit/df80aa0d9dac9391258b990329e816f5c06af826))
+* **fable:** restore Waza-compliant contract structure ([e26ffdf](https://github.com/dyphn1/Harness-everything/commit/e26ffdf68d1e492202e131eeebf57665e0e2c269))
+* **fable:** sync compact contract ([946bb27](https://github.com/dyphn1/Harness-everything/commit/946bb27622f6244d55ddd352955ebe2210878278))
+* **fable:** sync discipline side effects ([#275](https://github.com/dyphn1/Harness-everything/issues/275) [#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([e0205c2](https://github.com/dyphn1/Harness-everything/commit/e0205c2063e745a47a58eb70959bfda67e1eebe2))
+* **fable:** sync divergence contract ([#275](https://github.com/dyphn1/Harness-everything/issues/275)) ([f225241](https://github.com/dyphn1/Harness-everything/commit/f225241fe201f5468d58283396a96b3f703d8160))
+* **fable:** sync permission-aware commits ([#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([78b7a32](https://github.com/dyphn1/Harness-everything/commit/78b7a32ba61f759d82ca8d61e297239062ed713c))
+* **fable:** sync semantic contract strength ([01a665d](https://github.com/dyphn1/Harness-everything/commit/01a665d6f95da0d250e4d080409e0ebba8756af7))
+* **fable:** sync Waza-compliant contract ([74619c0](https://github.com/dyphn1/Harness-everything/commit/74619c00c3f1d76438f168dee1353e9fd4a112ef))
+* **git:** compact authorized commit contract ([cd3a3eb](https://github.com/dyphn1/Harness-everything/commit/cd3a3eb1978778c372be03c4611b50fb570ba802))
+* **git:** require commit authorization ([#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([e91f90c](https://github.com/dyphn1/Harness-everything/commit/e91f90cc472ca0310f3bfdbd4fede3f1c89b6884))
+* **git:** restore MUST SHOULD contract strength ([353ff80](https://github.com/dyphn1/Harness-everything/commit/353ff80ee2a17894b76799e96c6a2128a67aa7ee))
+* **git:** restore Waza-compliant contract structure ([4e0db0a](https://github.com/dyphn1/Harness-everything/commit/4e0db0a173c0fa42695e0cbccf963186dbee1d35))
+* **git:** sync commit authorization ([#277](https://github.com/dyphn1/Harness-everything/issues/277)) ([168fd1f](https://github.com/dyphn1/Harness-everything/commit/168fd1f69eed2f3246ca0eb2b7f5e457a1f8891d))
+* **git:** sync compact commit contract ([f4bd248](https://github.com/dyphn1/Harness-everything/commit/f4bd2487d04e934014acb264275e1b694053364f))
+* **git:** sync MUST SHOULD contract strength ([f2e01f3](https://github.com/dyphn1/Harness-everything/commit/f2e01f32a6174ea14c90751344a9357c32db2b2c))
+* **git:** sync Waza-compliant contract ([dc73922](https://github.com/dyphn1/Harness-everything/commit/dc73922f7a2ac708ae319dfd29d3c57ccccfb3ba))
+* **grill:** compact explicit handoff contract ([8aa0f3e](https://github.com/dyphn1/Harness-everything/commit/8aa0f3effbc523c1951a3f3697cb4939eab01b99))
+* **grill:** preserve explicit docs handoff ([#274](https://github.com/dyphn1/Harness-everything/issues/274)) ([8cc7b4f](https://github.com/dyphn1/Harness-everything/commit/8cc7b4fe84fb628234d2142d4c12d6748aa23bbd))
+* **grill:** preserve explicit spec handoff ([#274](https://github.com/dyphn1/Harness-everything/issues/274)) ([ffd3f45](https://github.com/dyphn1/Harness-everything/commit/ffd3f455c45049437a15c7ca69b686b5a155412c))
+* **grill:** sync compact handoff contract ([900f03a](https://github.com/dyphn1/Harness-everything/commit/900f03a9c0fc6a14d6ce525ae6edd3fab6c27967))
+* **grill:** sync explicit docs handoff ([#274](https://github.com/dyphn1/Harness-everything/issues/274)) ([3501bc5](https://github.com/dyphn1/Harness-everything/commit/3501bc54fb1fc905a366f6f26d816ca9b1157503))
+* **grill:** sync explicit spec handoff ([#274](https://github.com/dyphn1/Harness-everything/issues/274)) ([4bf3c58](https://github.com/dyphn1/Harness-everything/commit/4bf3c58ac7f333eaf3a263ba1c61d5ea9c27a765))
+
+## [0.30.7](https://github.com/dyphn1/Harness-everything/compare/v0.30.6...v0.30.7) (2026-10-07)
+
+### Bug Fixes
+
+* **action-gate:** reject dynamic scratch-target exemptions ([#283](https://github.com/dyphn1/Harness-everything/issues/283)) ([f722968](https://github.com/dyphn1/Harness-everything/commit/f722968021846a804fa8fceaddd9983addff51e7))
+* **action-gate:** use explicit shell-expansion marker check ([f02a105](https://github.com/dyphn1/Harness-everything/commit/f02a105e007104d20cde8fe46d24668624f7b343))
+* **action-gate:** use explicit shell-expansion marker check ([bedf24b](https://github.com/dyphn1/Harness-everything/commit/bedf24b1d2774e1d997f4b5c3f1f5d3c90694311))
+* **fable:** keep advisory replan contract within skill token budget ([b593c49](https://github.com/dyphn1/Harness-everything/commit/b593c49862d779f20919f8f1a7ff72043d76b637))
+* **fable:** keep advisory replan contract within skill token budget ([da6c5e8](https://github.com/dyphn1/Harness-everything/commit/da6c5e8f238d5dcae9632a5db0e71786d7dc5fe7))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([64de668](https://github.com/dyphn1/Harness-everything/commit/64de668e91300e1c7f68ca07ebb08d87b5595c1c))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([241cf46](https://github.com/dyphn1/Harness-everything/commit/241cf461baca6a6e739aa5114330ac1e20c0195b))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([d834d9f](https://github.com/dyphn1/Harness-everything/commit/d834d9fffbae5d40583c1e0e41a1da1f03531382))
+* **fable:** make replan guidance non-blocking ([#273](https://github.com/dyphn1/Harness-everything/issues/273)) ([1430afe](https://github.com/dyphn1/Harness-everything/commit/1430afe9a96a1b849d18982644193bf7251264b1))
+* **fable:** preserve per-stage artifact and pass-check contract ([2c4feaf](https://github.com/dyphn1/Harness-everything/commit/2c4feafd503881296a8b656d2b6c8257db68be41))
+* **fable:** preserve per-stage artifact and pass-check contract ([d88a0b6](https://github.com/dyphn1/Harness-everything/commit/d88a0b6b054ca0810563519eed2a1d494c8b3e15))
+* **fable:** remove remaining two-replan caps from fable references ([63f9263](https://github.com/dyphn1/Harness-everything/commit/63f9263f3dd712c39ec49aa977e0229dc750bb52))
+* **find-skills:** retain authority boundary in reference contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([9a5ed99](https://github.com/dyphn1/Harness-everything/commit/9a5ed99737be4fe0b8631370379eead2d54f6bf9))
+* **find-skills:** retain authority boundary in reference contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([3e41033](https://github.com/dyphn1/Harness-everything/commit/3e410339df82dafccd2cef094b00e4efd7f4e2d7))
+* **find-skills:** retain authority boundary in skill contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([3d01cd7](https://github.com/dyphn1/Harness-everything/commit/3d01cd7633261851529b214dbc01664b2a18a915))
+* **find-skills:** retain authority boundary in skill contract ([#276](https://github.com/dyphn1/Harness-everything/issues/276)) ([2112e3a](https://github.com/dyphn1/Harness-everything/commit/2112e3a04eb3c90786aa3316d2735d24435fc9f0))
+
 ## [0.30.6](https://github.com/dyphn1/Harness-everything/compare/v0.30.5...v0.30.6) (2026-10-06)
 
 ### Bug Fixes

package/ci/mechanism-2ad-action-gate-classifier-hardening.test.js

@@ -84,6 +84,20 @@ try {
   // fail-open path: the gate cannot prove that the target is scratch space.
   matched(table, 'rm -rf "$S"', 'recursive-delete');
 
+  // A repository checkout may itself live below os.tmpdir() (e.g. a review worktree).
+  // Unknown paths are not proven scratch paths merely because cwd is scratch.
+  const scratchCwd = path.join(sessionDir, 'scratch');
+  matched(table, 'rm -rf "$S"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "${S}"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "$HOME/important"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "~/important"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'rm -rf "*.txt"', 'recursive-delete', 'Bash', scratchCwd);
+  matched(table, 'ri -Recurse -Force "$env:TARGET"', 'powershell-recursive-force-delete', 'PowerShell', scratchCwd);
+  matched(table, 'rm -r -fo "%TEMP%/important"', 'powershell-recursive-force-delete', 'PowerShell', scratchCwd);
+  // A provably literal scratch path remains allowed even from the same cwd.
+  allowed(table, `rm -rf "${path.join(scratchCwd, 'output')}"`, 'Bash', scratchCwd);
+
+
   console.log('PASS: destructive-command classifier covers confirmed bypasses while suppressing quoted-text false positives');
 } finally {
   fs.rmSync(temp, { recursive: true, force: true });

package/ci/prompt-contract-regressions.test.js

@@ -10,6 +10,109 @@ function read(rel) {
   return fs.readFileSync(path.join(ROOT, rel), 'utf8');
 }
 
+// #273: Fable replan counts are advisory, never execution hard-stops.
+// Only repeated same-signature failures invoke mandatory Rule-of-3 reflection.
+for (const [canonical, packaged] of [
+  ['fable-mode/SKILL.md', 'plugins/harness-everything/skills/fable-mode/SKILL.md'],
+  ['fable-mode/fable-opus/SKILL.md', 'plugins/harness-everything/skills/fable-mode/fable-opus/SKILL.md'],
+]) {
+  const body = read(canonical);
+  assert.strictEqual(read(packaged), body, canonical + ' packaged contract matches');
+  assert.ok(/advisory replan/i.test(body), canonical + ' must describe replans as advisory');
+  assert.ok(/Rule-of-3/i.test(body), canonical + ' must preserve same-signature failure reflection');
+  assert.ok(!/at most two (?:full )?replans/i.test(body), canonical + ' must not imply a two-replan hard cap');
+}
+for (const rel of [
+  'fable-mode/references/execution-phases.md',
+  'plugins/harness-everything/skills/fable-mode/references/execution-phases.md',
+  'docs/workflows/fable-mode.md',
+]) {
+  assert.ok(!/(?:at most|no more than) two (?:full )?replans/i.test(read(rel)), rel + ' must not imply a two-replan hard cap');
+}
+const orchestratorContract = read('fable-mode/agents/fable-orchestrator.md');
+assert.ok(/maxReplans[\s\S]{0,60}is advisory/i.test(orchestratorContract), 'orchestrator keeps advisory replan guidance');
+assert.ok(/do not block execution/i.test(orchestratorContract), 'orchestrator does not block on replan count');
+
+// #275: build divergence is a diagnostic signal, not a second hard-stop.
+// Mandatory blocking/reflection remains limited to Rule-of-3 or permission boundaries.
+const fableDiscipline = read('fable-discipline/SKILL.md');
+assert.strictEqual(read('plugins/harness-everything/skills/fable-discipline/SKILL.md'), fableDiscipline, 'fable-discipline packaged contract matches canonical');
+assert.ok(/divergence is a warning signal/i.test(fableDiscipline), 'fable-discipline must classify divergence as warning guidance');
+assert.ok(/does not hard-stop execution/i.test(fableDiscipline), 'divergence must not create an independent hard stop');
+assert.ok(/Rule-of-3 owns mandatory reflection/i.test(fableDiscipline), 'Rule-of-3 remains the mandatory reflection owner');
+assert.ok(!/HALTS execution immediately/i.test(fableDiscipline), 'fable-discipline must not retain the divergent-build hard halt');
+assert.ok(!/If build errors diverge, HALT/i.test(fableDiscipline), 'fable-discipline must not issue an immediate divergence halt');
+
+// #274: grill skills may recommend the explicit publication/ticket commands,
+// but must not auto-invoke state-mutating explicit-only skills.
+const toSpec = read('to-spec/SKILL.md');
+const toTickets = read('to-tickets/SKILL.md');
+assert.ok(/Explicit `?\/to-spec`?; never auto-run/i.test(toSpec), 'to-spec remains explicit-only');
+assert.ok(/Explicit `?\/to-tickets`? only/i.test(toTickets), 'to-tickets remains explicit-only');
+for (const [canonical, packaged] of [
+  ['grill-me/SKILL.md', 'plugins/harness-everything/skills/grill-me/SKILL.md'],
+  ['grill-with-docs/SKILL.md', 'plugins/harness-everything/skills/grill-with-docs/SKILL.md'],
+]) {
+  const body = read(canonical);
+  assert.strictEqual(read(packaged), body, canonical + ' packaged contract matches');
+  assert.ok(/explicit `?\/to-spec`?/i.test(body), canonical + ' must surface the explicit to-spec handoff');
+  assert.ok(/Never auto-run `to-spec` or `to-tickets`/i.test(body), canonical + ' must preserve explicit-only publication/ticket gates');
+}
+assert.ok(!/on consensus, invoke `to-spec`/i.test(read('grill-me/SKILL.md')), 'grill-me must not auto-invoke to-spec');
+for (const [canonical, packaged] of [
+  ['grill-me/references/grilling-playbook.md', 'plugins/harness-everything/skills/grill-me/references/grilling-playbook.md'],
+  ['grill-with-docs/references/session-playbook.md', 'plugins/harness-everything/skills/grill-with-docs/references/session-playbook.md'],
+]) {
+  const body = read(canonical);
+  assert.strictEqual(read(packaged), body, canonical + ' packaged reference matches');
+  assert.ok(/recommend explicit `?\/to-spec`?/i.test(body), canonical + ' keeps explicit specification handoff');
+  assert.ok(!/MUST[^\n]*hand off to `to-spec/i.test(body), canonical + ' must not mandate automatic to-spec handoff');
+}
+
+for (const rel of [
+  'docs/workflows/grill-me.md',
+  'docs/workflows/grill-with-docs.md',
+]) {
+  const body = read(rel);
+  assert.ok(/suggest|recommend/i.test(body) && /explicit `?\/to-spec`?/i.test(body), rel + ' must recommend an explicit to-spec command');
+  assert.ok(/explicit `?\/to-spec`? invocation/i.test(body), rel + ' must preserve the explicit invocation gate');
+  assert.ok(/not auto-run|does not invoke|not auto-invoked|does not publish automatically/i.test(body), rel + ' must reject automatic explicit-only handoff');
+  assert.ok(!/On consensus, `?to-spec`? invoked/i.test(body), rel + ' must not auto-invoke to-spec on consensus');
+  assert.ok(!/aligned design to `?to-spec`?; execution to `?to-tickets/i.test(body), rel + ' must not encode automatic downstream handoff');
+}
+
+
+
+// #277: completing a task phase does not authorize a Git commit.
+// Commit boundaries are guidance unless the user or active host/workflow grants permission.
+const gitCommit = read('git-commit/SKILL.md');
+const gitCommitFlow = read('git-commit/references/commit-flow.md');
+const fableDisciplineRules = read('fable-discipline/references/discipline-rules.md');
+assert.strictEqual(read('plugins/harness-everything/skills/git-commit/SKILL.md'), gitCommit, 'git-commit packaged contract matches canonical');
+assert.strictEqual(read('plugins/harness-everything/skills/git-commit/references/commit-flow.md'), gitCommitFlow, 'git-commit packaged flow matches canonical');
+assert.strictEqual(read('plugins/harness-everything/skills/fable-discipline/references/discipline-rules.md'), fableDisciplineRules, 'fable-discipline packaged rules match canonical');
+assert.ok(/task phase alone is not authorization/i.test(gitCommit), 'phase completion must not authorize a commit');
+assert.ok(/commit authorization first/i.test(gitCommit), 'git-commit must gate mutation on authorization');
+assert.ok(/User \/ Host-Authorized Commit/i.test(gitCommitFlow), 'commit flow must begin from explicit authorization');
+assert.ok(/Do Not Commit; Surface Status/i.test(gitCommitFlow), 'unauthorized flow must stop before mutation');
+assert.ok(/commits are authorized/i.test(fableDiscipline), 'fable discipline only applies atomic commits after authorization');
+assert.ok(/otherwise leave changes uncommitted/i.test(fableDiscipline), 'fable discipline must preserve uncommitted state without authorization');
+assert.ok(/Create the commit only when the user or active host\/workflow has authorized commits/i.test(fableDisciplineRules), 'fable reference must not autonomously commit');
+assert.ok(!/explicit commit requests or concluded task phases/i.test(gitCommit), 'concluded phases must not remain a commit trigger');
+assert.ok(!/Trigger: Commit Request \/ Task Complete/i.test(gitCommitFlow), 'task completion must not remain a flow trigger');
+
+// #275 reference surface must agree with the non-blocking divergence contract.
+assert.ok(/divergence alone is not a hard stop/i.test(fableDisciplineRules), 'fable reference keeps divergence advisory');
+assert.ok(/Mandatory reflection remains owned by Rule-of-3/i.test(fableDisciplineRules), 'fable reference keeps Rule-of-3 as reflection owner');
+assert.ok(!/HALT EXECUTION IMMEDIATELY/i.test(fableDisciplineRules), 'fable reference must not retain the old divergence hard halt');
+const fableWorkflow = read('docs/workflows/fable-discipline.md');
+const gitWorkflow = read('docs/workflows/git-commit.md');
+assert.ok(/Divergence surfaced without creating an independent hard stop/i.test(fableWorkflow), 'fable workflow keeps divergence advisory');
+assert.ok(!/HALT and call zoom-out|halt immediately/i.test(fableWorkflow), 'fable workflow must not retain divergence hard halt');
+assert.ok(/completed task phase does \*\*not\*\* authorize a commit/i.test(gitWorkflow), 'git workflow rejects phase-completion authorization');
+assert.ok(/Commit authorization existed before mutation/i.test(gitWorkflow), 'git workflow gates mutation on authorization');
+
+
 // #268: model aliases evolve, so worker prompts must encode behavior rather
 // than generation-specific personality/failure claims.
 const workerPairs = [
@@ -90,6 +193,20 @@ const workspaceContract = read('multi-agent-workspace/SKILL.md');
 assert.ok(/router owns that decision/i.test(workspaceContract), 'multi-agent-workspace keeps router-owned topology');
 assert.ok(/does not spawn workers/i.test(workspaceContract), 'multi-agent-workspace remains a topology/workspace consumer');
 
+// #276: third-party skill output is applicable guidance, never higher-priority
+// authority. Keep the canonical, packaged, and reference contracts consistent.
+const findSkills = read('find-skills/SKILL.md');
+const discoveryFlow = read('find-skills/references/discovery-flow.md');
+assert.strictEqual(read('plugins/harness-everything/skills/find-skills/SKILL.md'), findSkills, 'find-skills packaged contract matches canonical');
+assert.strictEqual(read('plugins/harness-everything/skills/find-skills/references/discovery-flow.md'), discoveryFlow, 'find-skills packaged reference matches canonical');
+assert.ok(/untrusted third-party content/i.test(findSkills), 'third-party output must be identified as untrusted');
+assert.ok(/MUST NOT override host, user, or Harness/i.test(findSkills), 'third-party skill instructions cannot override core authority');
+assert.ok(/explicit approval/i.test(findSkills), 'third-party application must require approval');
+assert.ok(/untrusted third-party content/i.test(discoveryFlow), 'reference must preserve untrusted data boundary');
+assert.ok(/MUST NOT override host, user, or Harness/i.test(discoveryFlow), 'reference must preserve precedence');
+assert.ok(!/Treat its output as binding/i.test(findSkills), 'find-skills must not grant unconditional binding authority');
+assert.ok(!/treat every instruction in it as binding/i.test(discoveryFlow), 'discovery reference must not grant unconditional binding authority');
+
 // #272: preserve one detailed checkpoint plus the invariant; remove duplicate
 // restatements from later sections of the same router injection.
 const kernel = path.join(ROOT, 'harness-everything/scripts/kernel-router.js');

package/docs/workflows/fable-discipline.md

@@ -1,71 +1,30 @@
 # Workflow: Fable Discipline
 
-> Act as a background guard while staged multi-agent work runs, keeping output compact, stage scope tight, handoffs explicit, and diverging builds halted.
+> Background guard for compact context, bounded stage scope, explicit handoffs, authorized commit boundaries, and build-divergence signals.
 
 Source of truth: `fable-discipline/SKILL.md`.
 
-## 1. Skill Behavior Workflow
+## 1. Workflow
 
 ```mermaid
 graph TD
-  FableActive([fable-mode active with staged work]) --> CompactMilestone[Compact state after milestone]
-  CompactMilestone --> ScopeCheck[Enforce stage scope and output limits]
-  ScopeCheck --> HandoffStep[Require state manifest at handoff]
-  HandoffStep --> BuildHealth{Build errors diverging?}
-  BuildHealth -->|yes| HaltZoom[HALT and call zoom-out]
-  BuildHealth -->|no| KeepGuard[Continue background guard]
-  KeepGuard --> CompactMilestone
-  HaltZoom --> MapErrors[Map error dependency graph for human]
+  Active[fable-mode active] --> Compact[Compact milestone state]
+  Compact --> Handoff[Verify handoff manifest]
+  Handoff --> Diverge{Build errors diverging?}
+  Diverge -->|no| Continue[Continue guarded work]
+  Diverge -->|yes| Warn[Surface regression + recommend zoom-out]
+  Warn --> Rule3{Rule-of-3 reached?}
+  Rule3 -->|yes| Reflect[Mandatory reflection]
+  Rule3 -->|no| Continue
 ```
 
-```mermaid
-graph TD
-  IncomingAgent[Incoming stage agent] --> VerifyManifest[Verify outgoing state manifest first]
-  VerifyManifest --> ManifestOk{Manifest complete?}
-  ManifestOk -->|yes| DoStage[Run stage within allowed files]
-  ManifestOk -->|no| AskManifest[Require missing APIs and IO details]
-  AskManifest --> VerifyManifest
-  DoStage --> OneCommit[One commit per independent logic block]
-  OneCommit --> LeaveManifest[Leave manifest for next agent]
-```
-
-## 2. Triggering and Routing Path
-
-```mermaid
-graph LR
-  FableMode[fable-mode active] --> FableDisc[fable-discipline shadow guard]
-  FableDisc --> WorkspaceGuard[Constrain multi-agent-workspace mutations]
-  WorkspaceGuard --> FableMode
-  FableDisc --> DivergedBuild{Diverging build errors?}
-  DivergedBuild -->|yes| ZoomOut[zoom-out]
-  DivergedBuild -->|no| FableMode
-```
-
-## 3. Real-World Use Case
-
-Long architectural migration runs under `fable-mode` with sub-agents handling separate stages.
-
-1. After each milestone, compact decisions and drop unneeded history; avoid broad regex and avoid reading irrelevant files over 1000 lines.
-2. Confirm working directory before touching core architecture; keep one commit per independent logic block.
-3. Outgoing agent leaves a manifest with completed APIs and expected inputs/outputs; incoming agent verifies it first.
-4. If fixes create more breakage, halt immediately, call `zoom-out`, and map the error dependency graph instead of continued patching.
-
-```mermaid
-graph TD
-  LongTask[Migration stage completes] --> CompactState[Compact milestone state]
-  CompactState --> CheckBloat[Check for bloat or oversized reads]
-  CheckBloat --> Handoff[Write and verify handoff manifest]
-  Handoff --> BuildCheck{Build diverging?}
-  BuildCheck -->|yes| HaltNow[HALT and zoom-out]
-  BuildCheck -->|no| NextStage[Start next stage guarded]
-```
+Commit boundaries are guidance only. Create commits only when the user or active host/workflow has authorized them; otherwise leave changes uncommitted.
 
-## 4. Verification Check
+## 2. Verification
 
-- [ ] Ran only as a background shadow for the whole `fable-mode` duration; not used standalone, not used for small tasks or routine single-file edits
-- [ ] After each milestone, state was compacted and unneeded history dropped; no broad regex without precise conditions and no irrelevant 1000+ line reads
-- [ ] Working directory was confirmed before core changes, with one commit per independent logic block
-- [ ] Every sub-agent handoff via `multi-agent-workspace` left a state manifest with completed APIs and expected inputs/outputs, verified by the incoming agent first
-- [ ] On diverging build errors, execution halted immediately and called `zoom-out` with an error dependency map instead of continued patching
-- [ ] Made no direct state mutations of its own; only constrained `fable-mode` and `multi-agent-workspace` mutations
-- [ ] Detail followed `fable-discipline/references/discipline-rules.md` where needed
+- [ ] Milestone state compacted and irrelevant broad reads avoided.
+- [ ] Handoff manifest written and verified.
+- [ ] Divergence surfaced without creating an independent hard stop.
+- [ ] Rule-of-3 remains the mandatory reflection owner.
+- [ ] Commits occur only with user/host authorization.
+- [ ] Detail follows `fable-discipline/references/discipline-rules.md`.

package/docs/workflows/fable-mode.md

@@ -84,7 +84,7 @@ worker. A material confirmed blocker may stop the current stage immediately. Rep
 matching execution failures use the separate Rule-of-3 path: zoom out, reflect, then
 `RESUME` on a new approach or `ESCALATE` when a real decision is required.
 
-At most two full replans are allowed before unresolved blockers are escalated rather than hidden behind endless restructuring.
+Replan counts (`maxReplans`) are advisory and never halt execution on their own; unresolved blockers are escalated rather than hidden behind endless restructuring, and three same-signature failures still trigger the mandatory Rule-of-3 `zoom-out`.
 
 ## 5. Completion Boundary
 

package/docs/workflows/git-commit.md

@@ -1,79 +1,33 @@
 # Workflow: Git Commit
 
-> Create clean Angular-style commit messages for an explicit commit request or a finished task phase, after checking repo state, submodules, and staged changes.
+> Create and verify an Angular-style commit only after the user or active host/workflow authorizes the mutation.
 
 Source of truth: `git-commit/SKILL.md`.
 
-## 1. Skill Behavior Workflow
+## 1. Workflow
 
 ```mermaid
 graph TD
-  CommitTrig([Commit requested or phase concluded]) --> StatusCheck[Run git status]
-  StatusCheck --> RepoOk{Git repo present?}
-  RepoOk -->|no| InitOffer[Offer git init or skip]
-  RepoOk -->|yes| SubCheck[Check submodule changes per SUBMODULES guide]
-  SubCheck --> SubDirty{Submodules changed?}
-  SubDirty -->|yes| SubFirst[Commit submodules first]
-  SubDirty -->|no| DiffCheck[Run git diff-cached]
-  SubFirst --> DiffCheck
-  DiffCheck --> StagedOk{Anything staged?}
-  StagedOk -->|no| PromptStage[Prompt user and stage targeted files]
-  StagedOk -->|yes| FormatMsg[Format type-scope-subject message]
-  PromptStage --> FormatMsg
-  FormatMsg --> VerifyLog[Commit then verify with git log -1]
-  VerifyLog --> DoneClean([Tree updated and clean])
+  Trigger[Commit requested / host-authorized] --> Auth{Commit authorized?}
+  Auth -->|no| Stop[Do not commit; surface status]
+  Auth -->|yes| Status[git status]
+  Status --> Diff[git diff --cached]
+  Diff --> Staged{Anything staged?}
+  Staged -->|no| Ask[Prompt user; stage only authorized targets]
+  Staged -->|yes| Format[Format Angular message]
+  Ask --> Format
+  Format --> Commit[git commit]
+  Commit --> Verify[git log -1]
 ```
 
-```mermaid
-graph TD
-  FormatSimple[Formatted Angular message] --> EscCheck{Simple single line?}
-  EscCheck -->|yes| DirectM[git commit -m]
-  EscCheck -->|no multiline or Windows| TempF[Write commit-msg file then git commit -F and cleanup]
-  DirectM --> LogOne[git log -1 verifies commit]
-  TempF --> LogOne
-  LogOne --> CleanTree([Working tree clean])
-```
-
-## 2. Triggering and Routing Path
-
-```mermaid
-graph LR
-  UserReq[User requests commit] --> GitSkill[git-commit SKILL]
-  PhaseDone[Task phase concludes with staged diff] --> GitSkill
-  GitSkill --> StatusGate[git status gate]
-  StatusGate --> SubGuide[guides SUBMODULES.md if needed]
-  SubGuide --> StyleGuide[guides ANGULAR_STYLE.md formatting]
-  StyleGuide --> CommitVerify[Commit and git log -1 check]
-```
-
-## 3. Real-World Use Case
-
-Developer finishes an auth fix and asks for a commit.
-
-1. Run `git status`; if not a repo, offer `git init` or skip.
-2. If submodules changed, commit those first per `git-commit/guides/SUBMODULES.md`.
-3. Run `git diff --cached`; if nothing staged, prompt before staging targeted files.
-4. Format `<type>(<scope>): <subject>` per `git-commit/guides/ANGULAR_STYLE.md`.
-5. Use `git commit -m` for a simple line, or `.git-commit-msg.txt` + `git commit -F` with cleanup for multiline/Windows, then verify with `git log -1`.
-
-```mermaid
-graph TD
-  DevDone[Auth fix finished and staged] --> CheckStatus[Run git status and cached diff]
-  CheckStatus --> FmtMsg[Format feat-auth style message]
-  FmtMsg --> PickMethod{Multiline or Windows?}
-  PickMethod -->|no| CommitM[git commit -m]
-  PickMethod -->|yes| CommitF[git commit -F with temp file]
-  CommitM --> VerifyOne[git log -1]
-  CommitF --> VerifyOne
-  VerifyOne --> CleanDone([Committed and verified])
-```
+A completed task phase does **not** authorize a commit.
 
-## 4. Verification Check
+## 2. Verification
 
-- [ ] `git status` ran first; non-repo offered `git init` or skip, and empty staging prompted the user instead of committing nothing
-- [ ] Submodule changes were handled first per `git-commit/guides/SUBMODULES.md`
-- [ ] Staged diff was reviewed with `git diff --cached`, with targeted staging only after confirmation
-- [ ] Message followed `<type>(<scope>): <subject>` per `git-commit/guides/ANGULAR_STYLE.md`
-- [ ] Multiline/Windows path used `.git-commit-msg.txt` + `git commit -F` with cleanup; simple path used `git commit -m`; result verified with `git log -1`
-- [ ] No branch, rebase, merge, or push was performed, and no staging happened without confirmation
-- [ ] Detail followed `git-commit/references/commit-flow.md` where needed
+- [ ] Commit authorization existed before mutation.
+- [ ] `git status` and `git diff --cached` were inspected.
+- [ ] Only authorized targeted files were staged.
+- [ ] Message follows `<type>(<scope>): <subject>`.
+- [ ] Result verified with `git log -1`.
+- [ ] No branch/rebase/merge/push side effects were introduced.
+- [ ] Detail follows `git-commit/references/commit-flow.md`.

package/docs/workflows/grill-me.md

@@ -1,6 +1,6 @@
 # Workflow: Grill Me
 
-> A demanding challenger that pressure-tests vague plans and architectures one question at a time, exposes loopholes and undefined boundaries, counters sycophantic agreement, keeps the CONTEXT.md glossary current, and passes settled decisions to to-spec for formal specs and ADRs.
+> A demanding challenger that pressure-tests vague plans and architectures one question at a time, keeps the CONTEXT.md glossary current, and recommends an explicit `/to-spec` handoff after consensus.
 
 Source of truth: `grill-me/SKILL.md`.
 
@@ -15,8 +15,11 @@ graph TD
   ResolveBranch --> UpdateGlossary["Update CONTEXT.md glossary inline"]
   UpdateGlossary --> ConsensusCheck{"Consensus on all branches?"}
   ConsensusCheck -->|No| AskOne
-  ConsensusCheck -->|Yes| HandoffSpec["Hand off to to-spec to preview outline and publish"]
-  HandoffSpec --> RouteExec["Route execution to to-tickets, fable-mode, or tdd"]
+  ConsensusCheck -->|Yes| SuggestSpec["Recommend explicit /to-spec"]
+  SuggestSpec --> InvokeSpec{"User explicitly invokes /to-spec?"}
+  InvokeSpec -->|No| Await["Keep aligned decisions; await explicit command"]
+  InvokeSpec -->|Yes| ToSpec["to-spec previews outline and publishes under its approval gate"]
+  ToSpec --> SuggestExec["Suggest /to-tickets, fable-mode, or tdd as appropriate"]
 ```
 
 ## 2. Triggering and Routing Path
@@ -26,10 +29,11 @@ graph LR
   VaguePlan["Input: vague plan proposal"] --> GrillMe["grill-me / SKILL.md"]
   EvaluateArch["Input: evaluate architecture request"] --> GrillMe
   ExplicitAsk["Input: explicit grill me request"] --> GrillMe
-  GrillMe --> ToSpec["to-spec: preview outline and publish PRD, CLI/API reference, Schema doc, or ADR"]
-  ToSpec --> ToTickets["to-tickets for execution"]
-  ToSpec --> FableMode["fable-mode for execution"]
-  ToSpec --> TDD["tdd for execution"]
+  GrillMe --> SuggestSpec["Suggest explicit /to-spec"]
+  SuggestSpec --> InvokeGate{"Explicit /to-spec invoked?"}
+  InvokeGate -->|No| Wait["Stop at recommendation"]
+  InvokeGate -->|Yes| ToSpec["to-spec preview / publication flow"]
+  ToSpec --> SuggestRoutes["Suggest /to-tickets, fable-mode, or tdd"]
 ```
 
 ## 3. Real-World Use Case
@@ -42,10 +46,13 @@ graph TD
   A1 --> Glossary1["Update CONTEXT.md glossary for sync and lock terms"]
   Glossary1 --> Q2["Q2: What are boundary conditions for partial state?"]
   Q2 --> Consensus["Consensus reached on failure and boundary handling"]
-  Consensus --> SpecHandoff["to-spec publishes ADR and spec"]
+  Consensus --> Recommend["Recommend explicit /to-spec"]
+  Recommend --> UserInvoke{"User invokes /to-spec?"}
+  UserInvoke -->|No| End["Preserve consensus; no publication"]
+  UserInvoke -->|Yes| Spec["to-spec previews and publishes ADR/spec"]
 ```
 
-Concrete example: a developer proposes a direct table-sync cron job. `grill-me` scans `CONTEXT.md` and related code, asks one question about mid-sync failure, resolves it, updates the glossary, asks the next question about monitoring and boundary conditions, then hands the hardened decisions to `to-spec` for a PRD or ADR. Execution follows via `to-tickets`, `fable-mode`, or `tdd`.
+Concrete example: a developer proposes a direct table-sync cron job. `grill-me` resolves the design one question at a time and updates glossary terms. Once consensus is reached, it recommends explicit `/to-spec`; it does not publish automatically. Only after that command is invoked does `to-spec` enter its preview/publication flow. Any later execution route is suggested rather than auto-invoked.
 
 Deep detail: `grill-me/references/grilling-playbook.md`.
 
@@ -54,7 +61,8 @@ Deep detail: `grill-me/references/grilling-playbook.md`.
 - [ ] Exactly ONE question asked at a time; questionnaires prohibited
 - [ ] Each question carries the agent's insight and its branch is resolved before advancing
 - [ ] Questions use the project's domain model and terminology from `CONTEXT.md`, `README.md`, and `docs/adr/`
-- [ ] `CONTEXT.md` glossary updated inline as terms resolve; document creation left to `to-spec`
-- [ ] On consensus, `to-spec` invoked to preview outline and publish PRD, CLI/API reference, Schema doc, or ADR
-- [ ] No code implementation or ticket breakdown inside this skill; execution routed to `to-tickets`, `fable-mode`, or `tdd`
+- [ ] `CONTEXT.md` glossary updated inline as terms resolve
+- [ ] On consensus, explicit `/to-spec` is recommended, not auto-run
+- [ ] Publication occurs only after explicit `/to-spec` invocation and its approval flow
+- [ ] Execution routes such as `/to-tickets`, `fable-mode`, or `tdd` are suggested; explicit-only skills are not auto-invoked
 - [ ] Not used for casual Q and A, direct spec writing, or ticket breakdown of an approved spec

package/docs/workflows/grill-with-docs.md

@@ -1,6 +1,6 @@
 # Workflow: Grill With Docs
 
-> Tests a plan against the recorded domain language and past decisions, tightens fuzzy terminology into canonical terms, and writes CONTEXT.md and ADR updates inline as choices settle.
+> Tests a plan against recorded domain language and decisions, sharpens terminology, updates CONTEXT.md/ADRs inline, and recommends explicit downstream commands after alignment.
 
 Source of truth: `grill-with-docs/SKILL.md`.
 
@@ -15,8 +15,12 @@ graph TD
   InlineUpdate --> ADRGate{"ADR warranted: hard to reverse plus surprising without context plus real trade-off?"}
   ADRGate -->|Yes| WriteADR["Offer and write ADR at resolved location"]
   ADRGate -->|No| SkipADR["Skip ADR; keep pure glossary"]
-  WriteADR --> Handoff["Hand off aligned design to to-spec"]
-  SkipADR --> Handoff
+  WriteADR --> SuggestSpec["Recommend explicit /to-spec"]
+  SkipADR --> SuggestSpec
+  SuggestSpec --> InvokeSpec{"User explicitly invokes /to-spec?"}
+  InvokeSpec -->|No| Await["Keep aligned design; await explicit command"]
+  InvokeSpec -->|Yes| ToSpec["to-spec enters preview / publication flow"]
+  ToSpec --> SuggestExec["Suggest /to-tickets, fable-mode, or tdd as appropriate"]
 ```
 
 ## 2. Triggering and Routing Path
@@ -24,11 +28,12 @@ graph TD
 ```mermaid
 graph LR
   DomainStress["Input: stress-testing a plan against domain language and documented decisions"] --> GWD["grill-with-docs / SKILL.md"]
-  GWD --> GrillMe["grill-me for unverified design"]
-  GWD --> ToSpec["to-spec for aligned design"]
-  ToSpec --> ToTickets["to-tickets for execution"]
-  ToSpec --> FableMode["fable-mode for execution"]
-  ToSpec --> TDD["tdd for execution"]
+  GWD --> GrillMe["Recommend grill-me for unverified design"]
+  GWD --> SuggestSpec["For aligned design, suggest explicit /to-spec"]
+  SuggestSpec --> InvokeGate{"Explicit /to-spec invoked?"}
+  InvokeGate -->|No| Wait["Stop at recommendation"]
+  InvokeGate -->|Yes| ToSpec["to-spec preview / publication flow"]
+  ToSpec --> SuggestRoutes["Suggest /to-tickets, fable-mode, or tdd"]
 ```
 
 ## 3. Real-World Use Case
@@ -40,10 +45,13 @@ graph TD
   Conflict --> Scenario["Scenario test: burst retry against overload protection limit"]
   Scenario --> GlossaryFix["Inline glossary fix to canonical terms"]
   GlossaryFix --> ADRDecision["ADR offered because limit change is hard to reverse and involves trade-off"]
-  ADRDecision --> AlignedHandoff["Aligned design to to-spec; execution to to-tickets, fable-mode, or tdd"]
+  ADRDecision --> Recommend["Recommend explicit /to-spec; suggest execution routes separately"]
+  Recommend --> Invoke{"User invokes /to-spec?"}
+  Invoke -->|No| End["Keep aligned design; no spec publication"]
+  Invoke -->|Yes| Spec["to-spec preview / publication flow"]
 ```
 
-Concrete example: a retry-limit change is checked against the existing rate-limiting ADR and code. Fuzzy retry language is sharpened, the glossary is fixed inline, and only because the decision is hard to reverse and surprising without context is an ADR written. An unverified design would go to `grill-me` first instead.
+Concrete example: a retry-limit change is checked against the existing rate-limiting ADR and code. Fuzzy language is sharpened and the glossary is fixed inline. Once alignment is complete, the skill recommends explicit `/to-spec`; it does not invoke publication or ticket generation automatically. An unverified design is directed back to `grill-me` first.
 
 Deep detail: `grill-with-docs/references/session-playbook.md`. Formats: `grill-with-docs/ADR-FORMAT.md`, `grill-with-docs/CONTEXT-FORMAT.md`.
 
@@ -54,6 +62,7 @@ Deep detail: `grill-with-docs/references/session-playbook.md`. Formats: `grill-w
 - [ ] Relationships tested with concrete scenarios and claims cross-checked against code
 - [ ] Context glossary updated inline, never batched
 - [ ] ADR offered only when hard to reverse plus surprising without context plus a real trade-off
-- [ ] ADRs meet the 3-part bar; handoff to `to-spec` after alignment
-- [ ] Routing respected: unverified design to `grill-me`; aligned design to `to-spec`; execution to `to-tickets`, `fable-mode`, or `tdd`
+- [ ] After alignment, explicit `/to-spec` is recommended rather than auto-run
+- [ ] Specification publication requires explicit `/to-spec` invocation
+- [ ] `/to-tickets`, `fable-mode`, and `tdd` are suggestions; explicit-only skills are not auto-invoked
 - [ ] Not used for verifying unstable designs without a grilling pass, and not used for spec publishing without grilling

package/evals/fable-discipline/tasks/positive-trigger.yaml

@@ -1,6 +1,6 @@
 id: positive-fable-discipline-001
 name: On-scope prompt triggers fable-discipline
-description: "Enforce fable-mode's context discipline as a shadow guard. Use when running staged multi-agent loops to prevent context bloat, cap per-stage output size, keep each stage within its physical token boundaries, and stop agents from reading files outside the current stage's scope."
+description: Enforce fable-mode context discipline as a shadow guard. Use for staged multi-agent loops to compact state, constrain stage scope, verify handoffs, and surface build divergence without adding an independent hard stop.
 tags:
   - positive-trigger
 inputs:

package/evals/git-commit/tasks/positive-trigger.yaml

@@ -1,6 +1,6 @@
 id: positive-git-commit-001
 name: On-scope prompt triggers git-commit
-description: "Generate Angular-style commit messages after verifying the environment, submodules, and staged files; use for explicit commit requests or concluded task phases."
+description: "Generate Angular-style commit messages after verifying repo state, submodules, and staged files. Use only for a user-requested or host/workflow-authorized commit; task completion alone is not authorization."
 tags:
   - positive-trigger
 inputs:

package/evals/grill-me/tasks/positive-trigger.yaml

@@ -1,6 +1,6 @@
 id: positive-grill-me-001
 name: On-scope prompt triggers grill-me
-description: "Acts as a relentless challenger to stress-test plans and architectures by interrogating one question at a time, finding loopholes, combating AI sycophancy, updating the CONTEXT.md glossary in real time, and handing off resolved decisions to to-spec for formal specs/ADRs."
+description: Stress-test plans and architectures one question at a time, expose blind spots, update domain terminology, and suggest an explicit to-spec handoff when alignment is complete.
 tags:
   - positive-trigger
 inputs: