harness-everything 0.30.7 → 0.30.9

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.7",
+      "version": "0.30.9",
       "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.7",
+  "version": "0.30.9",
   "author": {
     "name": "Miya Daniel"
   },

package/.github/workflows/ci.yml

@@ -29,6 +29,37 @@ jobs:
       - name: Run focused mutation checks
         run: npm run test:mutations
 
+  # Pin the patched version: floating Node 24 already passed before #284.
+  system-one-windows-node24-patched:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '24.20.0'
+      - name: Verify exact patched runtime
+        run: node -e "if (process.versions.node !== '24.20.0') process.exit(1)"
+      - name: Exercise real evaluator subprocess and repeated resident teardown
+        run: node --test ci/mechanism-system-one-resident.test.js
+
+  # Node >=22 also includes the odd-numbered Node 23 line. Keep its
+  # documented Windows shutdown failure visible, without narrowing engines.
+  system-one-windows-node-legacy-policy:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node: ['23.6.0', '24.15.0']
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: ${{ matrix.node }}
+      - name: Verify exact affected runtime
+        run: node -e "if (process.versions.node !== '${{ matrix.node }}') process.exit(1)"
+      - name: Confirm explicit RS13 skip with version-policy unit coverage
+        run: node --test --test-name-pattern="S1-RS00|S1-RS13" ci/mechanism-system-one-resident.test.js
+
   runtime-floor:
     runs-on: ubuntu-latest
     steps:

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.30.9](https://github.com/dyphn1/Harness-everything/compare/v0.30.8...v0.30.9) (2026-10-08)
+
+### Bug Fixes
+
+* **system-one:** cover Windows Node 23 shutdown regression ([75ef983](https://github.com/dyphn1/Harness-everything/commit/75ef9833e4fcfb697c8323836f08eed3dfc7ff8d))
+* **test:** correct Windows Node version policy regex ([c0b63cc](https://github.com/dyphn1/Harness-everything/commit/c0b63cc3f18dc7126e4680f4fa7682ea2a4729ef))
+
+## [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

package/README.md

@@ -48,7 +48,7 @@ The exact "Harness" behavior depends on the installation surface. Claude Code ha
 
 Harness integrates directly into your workspace. There is no heavy daemon, no paid external APIs, and zero configuration required.
 
-**Runtime:** Harness supports **Node.js 22+**. Node.js **24** is the primary development and CI runtime (`.nvmrc`). The generated current-state runtime/workflow summary is [docs/repository-contract.md](docs/repository-contract.md).
+**Runtime:** Harness supports **Node.js 22+** (including odd-numbered versions); Node.js **24** is the primary development and CI runtime (`.nvmrc`). **On Windows, System One evaluator subprocess verification should use Node 22 or Node 24.20+**. Node 23.x has a documented Windows process-shutdown assertion ([nodejs/node#56645](https://github.com/nodejs/node/issues/56645)); Node 24.0–24.19 predates the backported libuv fix ([nodejs/node#61999](https://github.com/nodejs/node/pull/61999)) and may likewise crash at process exit (`0xC0000409`). RS13 visibly skips **only** on those Windows versions while retaining the real evaluator subprocess elsewhere. A skip is not a pass or evidence of a fixed Node runtime. CI pins Windows Node 23.6.0 and 24.15.0 to validate their skip policy, and Node 24.20.0 to run the complete subprocess/regression suite. These tests do not reduce the package's general `>=22` engine compatibility claim. The generated current-state runtime/workflow summary is [docs/repository-contract.md](docs/repository-contract.md).
 
 ```bash
 # Option A: Claude Code plugin (marketplace manifest included)

package/ci/fixtures/system-one-resident-stub.py

@@ -1,5 +1,6 @@
 """Stub scorer behind the real resident server code; never model-quality evidence."""
 import importlib.util
+import json
 from pathlib import Path
 import sys
 import time
@@ -28,4 +29,9 @@ def factory(weights, manifest):
 if __name__ == '__main__':
     if sys.argv[1:2] != ['--serve']:
         sys.exit(2)
-    sys.exit(adapter.serve_main(sys.argv[2:], scorer_factory=factory))
+    result = adapter.serve_main(sys.argv[2:], scorer_factory=factory)
+    # Deterministic teardown fixture: the state/socket are closed, but PID is
+    # deliberately alive to distinguish state unlink from full process exit.
+    if json.loads(sys.argv[2]).get('modelId') == 'stub-exit-linger':
+        time.sleep(0.5)
+    sys.exit(result)

package/ci/mechanism-system-one-resident.test.js

@@ -29,10 +29,57 @@ function fixture(modelId = 'stub', extra = {}) {
   const deps = { command: m => { spawns.push(m.modelId); return [python, [stub, '--serve']]; } };
   return { dir, manifest, manifestPath, spawns, deps };
 }
+// State-file unlink precedes process exit. Windows cleanup must wait for the
+// captured resident PID, not merely for the disappearance of its state file.
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (err) { return err.code === 'EPERM'; }
+}
 function cleanup(f) {
-  try { resident.stop(f.manifest, f.manifestPath); } catch (_) { /* best effort */ }
-  fs.rmSync(f.dir, { recursive: true, force: true });
+  const { state } = resident.stateFiles(f.manifest, f.manifestPath);
+  const server = resident.readState(state);
+  try { resident.stop(f.manifest, f.manifestPath); } catch (_) { /* best effort after an assertion failure */ }
+  const deadline = Date.now() + 7500;
+  while ((fs.existsSync(state) || (process.platform === 'win32' && server && pidAlive(server.pid)))
+      && Date.now() < deadline) sleep(25);
+  assert.equal(fs.existsSync(state), false, 'resident state must disappear before fixture removal');
+  if (process.platform === 'win32' && server) {
+    assert.equal(pidAlive(server.pid), false, `detached resident PID ${server.pid} survived shutdown`);
+  }
+  fs.rmSync(f.dir, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+}
+// Windows Node 23 (nodejs/node#56645) and Node 24 before the fix in
+// 24.20.0 (nodejs/node#61999) can abort during libuv/process shutdown.
+// Preserve RS13's actual evaluator subprocess on unaffected runtimes.
+function windowsNodeShutdownIssue(platform, version) {
+  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  if (platform !== 'win32' || !parts) return false;
+  const major = Number(parts[1]);
+  if (major === 23) {
+    return 'Windows Node 23.x has a known process-shutdown assertion (nodejs/node#56645); use Node 22 or Node 24.20+';
+  }
+  if (major === 24 && Number(parts[2]) < 20) {
+    return 'Windows Node 24 < 24.20.0 lacks upstream shutdown fix nodejs/node#61999; use Node 24.20+ or Node 22';
+  }
+  return false;
 }
+const nodeShutdownIssue = windowsNodeShutdownIssue(process.platform, process.versions.node);
+
+test('S1-RS00 Windows Node 23 and 24 shutdown compatibility boundary', () => {
+  for (const version of ['23.0.0', '23.4.0', '23.6.0', '23.11.1']) {
+    assert.match(windowsNodeShutdownIssue('win32', version), /Node 23/);
+    assert.equal(windowsNodeShutdownIssue('linux', version), false);
+    assert.equal(windowsNodeShutdownIssue('darwin', version), false);
+  }
+  for (const version of ['24.0.0', '24.15.0', '24.18.0', '24.19.9']) {
+    assert.match(windowsNodeShutdownIssue('win32', version), /Node 24/);
+    assert.equal(windowsNodeShutdownIssue('linux', version), false);
+  }
+  for (const version of ['22.16.0', '24.20.0', '24.21.0', '25.0.0', '26.0.0', 'bogus']) {
+    assert.equal(windowsNodeShutdownIssue('win32', version), false, version);
+  }
+});
+
 // A client view whose state file names the live server with a wrong token. The server polls only its own
 // state file and exits once that file stops naming it, so rewriting it would race the wrong-token request.
 function wrongTokenView(f) {
@@ -295,7 +342,7 @@ test('S1-RS12 the evaluator times the async path: no worker thread per warm scor
   } finally { cleanup(f); }
 });
 
-test('S1-RS13 manifest acceptance thresholds are validated, carried by scored results and applied by the evaluator', async () => {
+test('S1-RS13 manifest acceptance thresholds are validated, carried by scored results and applied by the evaluator', { skip: nodeShutdownIssue }, async () => {
   const acceptance = { minConfidence: 0.6, minMargin: 0.3 };
   const base = fixture();
   try {
@@ -344,3 +391,23 @@ test('S1-RS14 resident transport names its adapter and stays inside the scripts
     assert.throws(() => resident.defaultCommand({ ...f.manifest, adapter: '../evil.py' }));
   } finally { cleanup(f); }
 });
+
+
+// The test server keeps its PID alive for 500 ms after state-file unlink.
+// A state-only teardown passes too early, whereas PID-aware cleanup cannot.
+test('S1-RS15 repeated teardown waits for resident PID and removes every fixture', () => {
+  for (let round = 0; round < 6; round++) {
+    const f = fixture('stub-exit-linger');
+    let pid;
+    try {
+      assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+      const state = resident.readState(resident.stateFiles(f.manifest, f.manifestPath).state);
+      assert.ok(state && state.pid > 0);
+      pid = state.pid;
+    } finally { cleanup(f); }
+    assert.equal(fs.existsSync(f.dir), false, `fixture remained after teardown ${round}`);
+    if (process.platform === 'win32') {
+      assert.equal(pidAlive(pid), false, `resident PID ${pid} leaked in teardown ${round}`);
+    }
+  }
+});

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

@@ -33,6 +33,86 @@ 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 = [

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/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