harness-everything 0.30.7 → 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.7",
+      "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.7",
+  "version": "0.30.8",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 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

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

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:

package/fable-discipline/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: 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.
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.30.8
 ---
 
 # Fable Discipline (Macro Task Discipline & Safety Net)
@@ -13,29 +13,29 @@ metadata:
 
 | Component | Specification |
 | :--- | :--- |
-| **Trigger / Input** | Background shadow for the whole duration `fable-mode` is active — not a standalone one-shot trigger. |
-| **Expected Output** | State compaction after milestones; one Git commit per independent logic block; a state manifest at every sub-agent handoff. |
+| **Trigger / Input** | Background shadow for the whole duration `fable-mode` is active — not a standalone trigger. |
+| **Expected Output** | State compaction after milestones; authorized commit-boundary guidance; a state manifest at every sub-agent handoff. |
 | **State Mutations** | None of its own — constrains how `fable-mode` and `multi-agent-workspace` mutate state. |
-| **Enforcement Gate** | **HALTS execution immediately** if build errors diverge (more fixes → more breakage); forces `zoom-out` instead of continued patching. |
+| **Enforcement Gate** | Build divergence is a warning signal: surface it and recommend `zoom-out`. Rule-of-3 owns mandatory reflection. |
 
-Shadow guard for `fable-mode`: MUST run in the background for its whole duration.
+Shadow guard for `fable-mode`: **MUST** run in the background for its whole duration.
 
 ## USE FOR:
 - Long architectural tasks under `fable-mode`
 - Compacting state after milestones
 - Sub-agent handoffs via `multi-agent-workspace`
-- Halting on diverging build errors
+- Surfacing diverging build errors
 
 ## DO NOT USE FOR:
-- Small tasks where `fable-mode` is not active
-- Standalone one-shot invocation (background shadow skill)
+- Small tasks where `fable-mode` is inactive
+- Standalone one-shot invocation
 - Routine single-file edits
 
 ## Core Rules
 
-1. **Anti-context bloat**: After each milestone, compact state and decisions; drop unneeded history. No broad regex without precise conditions; no reading irrelevant files over 1000 lines.
-2. **Physical boundaries**: Know your CWD before touching core architecture; one Git commit per independent logic block.
-3. **Agent handoff**: Outgoing agents MUST leave a state manifest (completed APIs, expected inputs/outputs); incoming agents MUST verify it first.
-4. **Circuit breaker**: If build errors diverge, HALT, call `zoom-out`, and map the error dependency graph for the human.
+1. **Anti-context bloat**: After each milestone, **MUST** compact state and decisions; avoid irrelevant broad reads.
+2. **Physical boundaries**: **MUST** know the CWD. If commits are authorized, independent logic blocks **SHOULD** remain separate; otherwise leave changes uncommitted.
+3. **Agent handoff**: Outgoing agents **MUST** leave a state manifest; incoming agents **MUST** verify it first.
+4. **Divergence signal**: **MUST** surface diverging errors and recommend `zoom-out`; **SHOULD** map the dependency graph. Divergence alone does not hard-stop execution.
 
 Deep dive: <this-skill-dir>/references/discipline-rules.md

package/fable-discipline/references/discipline-rules.md

@@ -9,14 +9,14 @@ When executing large architectural tasks, conversation logs expand rapidly, lead
 
 ## 2. Strict Physical Boundaries
 - **Environment Isolation**: Before modifying any core architecture, ensure you are clearly aware of the Current Working Directory (CWD).
-- **Atomic Commits**: You are NOT allowed to modify dozens of files at once before testing. For every independently functioning logic block completed, advise the human to create a Git Commit as a safe save point.
+- **Atomic Commit Boundaries**: Do not modify dozens of files at once before testing. Treat each independently functioning logic block as a suggested commit boundary. Create the commit only when the user or active host/workflow has authorized commits; otherwise leave changes uncommitted and surface the boundary.
 
 ## 3. Agent Handoff Protocol
 When `fable-mode` spawns and switches between different sub-agents via `multi-agent-workspace`, strict handoff discipline must be observed:
 - **State Manifest**: The previous agent MUST leave a clear state record (e.g., what APIs were completed, expected inputs/outputs).
 - **Contract Testing**: The very first step for the succeeding agent is to verify if the state manifest left by the previous agent is correct.
 
-## 4. Ultimate Circuit Breaker: Indefinite Halt
+## 4. Divergence Signal
 - Large tasks easily generate the sunk cost fallacy of "I think it's almost fixed, let me try one more time."
-- If the system's Build Errors exhibit a divergent trend (the more you fix, the more it breaks), **HALT EXECUTION IMMEDIATELY**.
-- Call `zoom-out`, organize the error dependency graph for the human, and seek architectural-level refactoring advice.
+- If Build Errors exhibit a divergent trend (the more you fix, the more it breaks), surface the regression immediately and recommend `zoom-out`; divergence alone is not a hard stop.
+- Organize the error dependency graph for the human. Mandatory reflection remains owned by Rule-of-3 after repeated same-signature failures, or by explicit user/host permission boundaries.