opensquid 0.5.395

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "opensquid",
+  "version": "0.5.395",
+  "description": "Continuity layer for coding agents: durable memory, dependency-aware task state, workflow gates, and inspectable packs over MCP.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "opensquid": "./dist/cli.js",
+    "opensquid-hook-posttooluse": "./dist/runtime/hooks/post-tool-use.js",
+    "opensquid-hook-pretooluse": "./dist/runtime/hooks/pre-tool-use.js",
+    "opensquid-hook-sessionend": "./dist/runtime/hooks/session-end.js",
+    "opensquid-hook-sessionstart": "./dist/runtime/hooks/session-start.js",
+    "opensquid-hook-stop": "./dist/runtime/hooks/stop.js",
+    "opensquid-hook-userpromptsubmit": "./dist/runtime/hooks/user-prompt-submit.js",
+    "opensquid-mcp": "./dist/mcp/server.js",
+    "opensquid-chat-bridge-mcp": "./dist/mcp/chat-bridge-server.js"
+  },
+  "files": [
+    "dist",
+    "schemas",
+    "packs/builtin",
+    "docs/pack-runtime.md",
+    "docs/skill-grammar-guide.md",
+    "docs/load-budget.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.33.2",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "E2E=1 vitest run test/e2e/drift-prevention.e2e.test.ts",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepush": "bash scripts/pre-push.sh",
+    "prepare": "bash scripts/install-git-hooks.sh",
+    "schemas": "tsx scripts/emit-schemas.ts",
+    "sync-fixtures": "tsx scripts/sync-fixtures-from-live.ts",
+    "prepublishOnly": "pnpm schemas && pnpm build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agent",
+    "agent-memory",
+    "workgraph",
+    "workflow-gates",
+    "continuity",
+    "claude-code",
+    "codex",
+    "anti-self-grading"
+  ],
+  "author": "Sangmin Lee <sangmlee23@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smlee/opensquid.git"
+  },
+  "bugs": {
+    "url": "https://github.com/smlee/opensquid/issues"
+  },
+  "homepage": "https://opensquid.tools",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "@libsql/client": "^0.14.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@types/tar": "^7.0.87",
+    "chevrotain": "^11.2.0",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "fastembed": "^2.1.0",
+    "grammy": "^1.43.0",
+    "lru-cache": "^11.5.0",
+    "minimatch": "^10.0.0",
+    "mustache": "^4.2.0",
+    "node-cron": "^3.0.3",
+    "picocolors": "^1.0.0",
+    "proper-lockfile": "^4.1.2",
+    "re2js": "^2.8.3",
+    "semver": "^7.6.0",
+    "tar": "^7.5.16",
+    "yaml": "^2.5.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/mustache": "^4.2.6",
+    "@types/node": "^20.14.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/semver": "^7.7.1",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "ajv": "^8.20.0",
+    "eslint": "^9.10.0",
+    "eslint-plugin-import": "^2.30.0",
+    "prettier": "^3.3.0",
+    "tsx": "^4.22.3",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.59.4",
+    "vitest": "^2.0.0",
+    "zod-to-json-schema": "^3.23.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.0",
+    "@anthropic-ai/sdk": "^0.30.0",
+    "@slack/socket-mode": "^2.0.0",
+    "@slack/web-api": "^7.0.0",
+    "discord.js": "^14.16.0",
+    "openai": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@slack/socket-mode": {
+      "optional": true
+    },
+    "@slack/web-api": {
+      "optional": true
+    },
+    "discord.js": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    }
+  },
+  "pnpm": {
+    "overrides": {
+      "onnxruntime-node": "1.26.0"
+    }
+  }
+}

package/packs/builtin/coding-flow/PROFILES.md

@@ -0,0 +1,39 @@
+# coding-flow — track-type region profiles (FU.3)
+
+One FSM; a **track-type** is a required-region _profile_ the guards consult — not a
+separate machine. `enter-scoping` classifies the scope-authoring prompt and records
+`coding-flow-track` (session state); each region-guard fires only when its region is in
+the active profile.
+
+| track-type | regions                  | meaning                                      |
+| ---------- | ------------------------ | -------------------------------------------- |
+| `feature`  | SCOPE · AUTHOR · EXECUTE | a new capability (full track) — **default**  |
+| `fix`      | SCOPE · EXECUTE          | research + 7-phase, no task decomposition    |
+| `doc`      | SCOPE · EXECUTE          | same shape; audit phase = "render / observe" |
+| `trivial`  | SCOPE · EXECUTE          | already-scoped mechanical edit               |
+
+## Which region-guard consults the profile
+
+- **SCOPE** (`scope-before-code`) — requires SCOPE-complete for **every** profile (code
+  always needs research). Profile-independent in practice.
+- **AUTHOR** (`taskcreate-spec-required`) — requires AUTHOR. Fires **only** when the track
+  is NOT `fix`/`doc`/`trivial`. The single profile-dependent gate.
+- **EXECUTE** (`phase-logged-before-commit`) — requires EXECUTE. Universal.
+
+## Fail-safe
+
+- Classification is recorded by `enter-scoping`, which RESETS `coding-flow-track` to
+  `feature` on every scope entry before any keyword downgrade — a stale `fix` value can
+  never leak into a later `feature` task.
+- **GF.5 (F5) — mixed-intent guard.** A downgrade to `fix`/`doc`/`trivial` fires ONLY
+  when the prompt carries NO feature-intent keyword
+  (`build|add|feature|implement|refactor|new (feature|module|endpoint)`). A mixed prompt
+  ("build X and fix Y") stays `feature` (strictest), so one stray keyword can't disable
+  the AUTHOR gate for the whole session. The feature list is deliberately narrow (no
+  `change`/`update`/`edit`) so a pure fix/doc track still downgrades.
+- An unset/unclassified track reads as `null`; `null != "fix"` is true, so the AUTHOR gate
+  still fires. **Default = `feature` = strictest.** Misclassification never under-gates.
+
+`trivial` currently shares `fix`/`doc`'s AUTHOR-skip behavior (all three are non-AUTHOR);
+the SCOPE+EXECUTE columns above document intent for a future profile that also relaxes
+SCOPE — not yet wired (SCOPE stays universal today).

package/packs/builtin/coding-flow/fsm.yaml

@@ -0,0 +1,52 @@
+# coding-flow lifecycle — the general problem-solving behavior pattern as ONE total
+# FSM. Three gated stages (each handed off to the next, each with a CONTENT gate):
+#
+#   SCOPE          scoping → researching → researched      gate: guess-audit (+ 3 sections)
+#   TASK AUTHORING spec_authored → spec_complete → tasks_loaded   gate: spec-audit (11-field + real code)
+#   CODE           phases_in_flight → phases_complete      gate: phase-log (7 phases before commit)
+#
+# "Coding" is the active gate profile, not the FSM's identity — this lifecycle is
+# domain-general. The machine is total (a non-matching event is an explicit stay,
+# validated by validateFsm). The unified SCOPE→AUTHOR→EXECUTE lifecycle.
+# Spec: docs/tasks/T-fsm-unify.md (§1 union design, decisions D1–D7).
+initial: idle
+states:
+  - idle
+  - scoping
+  - researching
+  - researched
+  - spec_authored
+  - spec_complete
+  - tasks_loaded
+  - phases_in_flight
+  - phases_complete
+transitions:
+  # ── SCOPE region ─────────────────────────────────────────────
+  - { from: idle, on: scope_start, to: scoping }
+  - { from: idle, on: research_done, to: researched } # robustness: pre-research write with no scope prompt
+  - { from: scoping, on: research_done, to: researched }
+  - { from: researching, on: research_done, to: researched }
+  # researched --guess_found--> researching (the D3 loop-back) is now a `loopback_gate`
+  # FLOW template in manifest.yaml (T-FC2); flows_compiler merges it in before validateFsm.
+  # ── TASK AUTHORING region ────────────────────────────────────
+  - { from: researched, on: spec_drafted, to: spec_authored } # a docs/tasks/T-*.md written (unverified)
+  - { from: spec_authored, on: spec_verified, to: spec_complete } # spec-audit passed: 11 fields + real code (D7)
+  - { from: spec_complete, on: tasks_loaded, to: tasks_loaded } # TaskCreate w/ provenance, only when AUTHOR-complete
+  # ── CODE region ──────────────────────────────────────────────
+  - { from: tasks_loaded, on: phase_started, to: phases_in_flight }
+  - { from: phases_in_flight, on: phases_done, to: phases_complete }
+  # ── Task-start reset (FU.11) ─────────────────────────────────
+  # Activating a new UNSCOPED task resets the machine to scoping (from ANY state)
+  # so the always-on scope gate re-arms per task — the FSM is session-level, so
+  # without this a new task rides the prior task's phases_complete. step() supports
+  # from: '*' (src/runtime/fsm.ts). Fired ONLY by the task-start guard, which gates
+  # it strictly on TaskUpdate(in_progress) + has_generated_spec == false.
+  - { from: '*', on: task_unscoped, to: scoping }
+  # ── New-track re-arm (GF.7, F10) ─────────────────────────────
+  # A run that reached phases_complete is DONE; a fresh scope-authoring prompt then
+  # starts a NEW track. Without this, scope_start (valid only from idle) is a silent
+  # no-op from the terminal state, so the SCOPE gate never re-engages for new work in
+  # a live session. ONLY phases_complete re-arms — scope_start stays a no-op from
+  # mid-run states (scoping/researching/spec_*/tasks_loaded/phases_in_flight), so a
+  # stray scope keyword cannot reset an in-flight authoring run.
+  - { from: phases_complete, on: scope_start, to: scoping }

package/packs/builtin/coding-flow/manifest.yaml

@@ -0,0 +1,29 @@
+name: coding-flow
+version: 0.1.0
+scope: workflow
+goal: >-
+  Ship the simplest correct solution, found by understanding before building:
+  SCOPE (research to teach-back depth, proven against alternatives + failure modes
+  + empirical spikes) → TASK AUTHORING (11-field decomposition, audited) → CODE
+  (the 7 phases). The general problem-solving lifecycle as one total-transition FSM
+  with three gated stages. Governing principles: docs/lexicon.md (Simplicity,
+  no-implicit-state).
+description: >-
+  The unified, FSM-driven problem-solving discipline. One behavior-pattern lifecycle
+  (fsm.yaml) with three gated stages — SCOPE, TASK AUTHORING, CODE — each enforced by
+  a content gate (guess-audit, spec-audit, phase-log), not just a presence marker.
+  "Coding" is the active gate profile, NOT the FSM's identity — the lifecycle is
+  domain-general. The unified workflow gate. Spec: docs/tasks/T-fsm-unify.md.
+evolves: true
+# No detected_by gate: opt-in via active.json IS the pin. A `detected_by:
+# [user_pinned]` clause would silently DISABLE an opted-in pack (the user_pinned
+# DetectionContext signal is never populated — the EWG.3.1 lesson, see
+# docs/pack-runtime.md §1.4).
+
+# T-FC2 — the SCOPE guess-audit loop-back (researched --guess_found--> researching,
+# D3) is a reusable quality-gate re-do pattern, so it is declared as a `loopback_gate`
+# FLOW template here instead of a hand-written transition in fsm.yaml. flows_compiler
+# expands it and merges it into the fsm.yaml machine BEFORE validateFsm.
+flows:
+  - template: loopback_gate
+    params: { state: researched, trigger: guess_found, back_to: researching }

package/packs/builtin/coding-flow/skills/entry-and-handoffs/skill.yaml

@@ -0,0 +1,246 @@
+# entry-and-handoffs — the prompt_submit guards: enter the lifecycle on
+# scope-authoring intent, and emit the stage→stage handoff directives (the
+# connective tissue between the three peer stages): enter-scoping + the stage→stage
+# handoffs. The handoff targets point at the unified state
+# names (spec_complete, not spec_authored, for the AUTHOR→tasks handoff). FU.3 adds
+# the track-type classification to `enter-scoping`.
+name: entry-and-handoffs
+load: preload
+when_to_load: []
+triggers:
+  - kind: prompt_submit
+rules:
+  # Enter the lifecycle: a scope-authoring prompt advances idle → scoping.
+  - id: enter-scoping
+    process:
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - '\bspec(?:c?ing|ced)?\b'
+            - '\bscope\b'
+            - '\bnew\s+(?:task|track)\b'
+            - '\badd\s+(?:a\s+|another\s+)?(?:task|track)\b'
+            - '\bdesign\b'
+            - '\bplan\b'
+        as: intent
+      - call: advance_fsm
+        if: 'len(intent.matched) > 0'
+        args:
+          event: scope_start
+      # FU.3: record the track-type so the AUTHOR gate can consult it. RESET to the
+      # strict default (feature) on every scope entry FIRST — so a stale fix/doc/
+      # trivial value from a prior track can never under-gate a later feature task —
+      # then downgrade on a keyword match (later writes win; fix/doc/trivial all skip
+      # AUTHOR equally, so ambiguity among them is harmless). Unset/feature/stale =
+      # feature = strictest (read_state(absent)→null, null != "fix" → gate fires).
+      - call: write_state
+        if: 'len(intent.matched) > 0'
+        args:
+          key: coding-flow-track
+          value: feature
+      # GF.5 (F5): a feature-intent probe. A downgrade to fix/doc/trivial applies ONLY
+      # when NO feature-intent keyword is present — a mixed-intent prompt ("build X and
+      # fix Y") stays `feature` (strictest), so one stray keyword can't disable the
+      # AUTHOR gate for the whole session. The list is deliberately narrow (no
+      # change/update/edit) so a pure fix/doc track still downgrades.
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - '\b(?:build|add|feature|implement|refactor|new\s+(?:feature|module|endpoint))\b'
+        as: featm
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - '\b(?:fix|bug|patch|de-?flake|hotfix|regression|broken)\b'
+        as: fixm
+      - call: write_state
+        if: 'len(intent.matched) > 0 && len(fixm.matched) > 0 && len(featm.matched) == 0'
+        args:
+          key: coding-flow-track
+          value: fix
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - '\b(?:doc|docs|documentation|readme|changelog|comment)\b'
+        as: docm
+      - call: write_state
+        if: 'len(intent.matched) > 0 && len(docm.matched) > 0 && len(featm.matched) == 0'
+        args:
+          key: coding-flow-track
+          value: doc
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - '\b(?:trivial|typo|rename|whitespace|mechanical)\b'
+        as: trivm
+      - call: write_state
+        if: 'len(intent.matched) > 0 && len(trivm.matched) > 0 && len(featm.matched) == 0'
+        args:
+          key: coding-flow-track
+          value: trivial
+  # GF.1 (F9) — the re-scope NUDGE, surfaced on prompt_submit (where directives are
+  # delivered) for the `scoping` state. Fires after `enter-scoping` advanced idle→scoping
+  # (or after task-start's task_unscoped reset, or GF.7's phases_complete re-arm landed
+  # the FSM in scoping). Replaces the directive task-start tried to emit on tool_call
+  # (dropped). Points the agent at the scope-architect persona to author the pre-research.
+  - id: handoff-rescope-nudge
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: verdict
+        if: 'st == "scoping"'
+        args:
+          level: directive
+          next_action:
+            profession: scope-architect
+            rationale: >-
+              SCOPE armed (state: scoping). Author the pre-research artifact to
+              teach-back depth (alternatives + failure modes + spikes), resolving every
+              open question, BEFORE any code. METHOD: do your recall + Read + Grep
+              (>=3 calls) in THIS turn, then write the pre-research ONCE — do not
+              stub-then-edit across turns (the depth gate counts research per-turn).
+              Hand off to the scope-architect persona.
+  # SCOPE done → hand off to the task-spec-author persona.
+  - id: handoff-research-to-spec
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: read_state
+        args:
+          key: coding-flow-pre-research-path
+        as: prp
+      - call: verdict
+        if: 'st == "researched"'
+        args:
+          level: directive
+          next_action:
+            profession: task-spec-author
+            args:
+              pre_research_path: '{{prp}}'
+            rationale: >-
+              SCOPE complete (state: researched). Hand off to the task-spec-author
+              persona to consume the pre-research artifact and author the track
+              spec — all 11 fields, real code. Do NOT hand-author the decomposition.
+  # AUTHOR done (spec passed the audit) → hand off to task creation.
+  - id: handoff-spec-to-tasks
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: read_state
+        args:
+          key: coding-flow-spec-path
+        as: sp
+      - call: verdict
+        if: 'st == "spec_complete"'
+        args:
+          level: directive
+          next_action:
+            tool: TaskCreate
+            args:
+              spec_path: '{{sp}}'
+            rationale: >-
+              TASK AUTHORING complete (state: spec_complete — the spec passed the
+              11-field + real-code audit). TaskCreate each "### Task" block with
+              metadata.taskId + metadata.spec = the spec's absolute path.
+  # EXECUTE in flight but incomplete → resume phase logging.
+  - id: handoff-resume-phases
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: workflow_phases_complete
+        as: phases
+      - call: verdict
+        if: 'st == "phases_in_flight" && phases.complete == false'
+        args:
+          level: directive
+          next_action:
+            tool: mcp__opensquid__log_phase
+            rationale: >-
+              CODE in flight (state: phases_in_flight) but the 7-phase workflow is
+              incomplete for the active task. Resume at the next unlogged phase;
+              log_phase as each completes.
+  # AF.3 — the EXECUTE loop driver. A task's 7-layer is complete (phases_complete):
+  # report it, then straight to the next task. (Directives only surface at prompt_submit,
+  # so the loop driver lives here, not in phase-advance.)
+  - id: handoff-task-complete
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: workflow_phases_complete
+        as: phases
+      - call: verdict
+        if: 'st == "phases_complete" && phases.complete == true'
+        args:
+          level: directive
+          next_action:
+            tool: mcp__opensquid-chat__chat_send
+            args:
+              channel: 'project:telegram'
+            rationale: >-
+              Task 7-layer COMPLETE (state: phases_complete). Send the plain-header per-task
+              completion report to the main chat (topic 15), THEN immediately
+              TaskUpdate(<next pending task>, in_progress) and continue — NO pause. Loop
+              until the backlog is depleted.
+  # G-a (T-FLOW-REARM-GATE-HOLES / RH.1) — the STRUCTURAL SCOPE re-arm. Closes the hole
+  # where new work described in PLAIN LANGUAGE (no scope keyword) never re-armed the flow:
+  # the FSM stayed parked at phases_complete, where run-active =
+  # `FSM!=idle && (open>0 || FSM!=phases_complete)` reads FALSE, so the pause-gates
+  # switched OFF and the agent could permission-fish un-gated (the 2026-06-04 leak). A
+  # depleted terminal state (phases_complete + empty backlog) means the prior track is DONE,
+  # so the NEXT prompt begins a new interaction → re-arm SCOPE on a STRUCTURAL fact (state +
+  # backlog count), NOT a keyword guess. Two design points make this safe:
+  #   • Placed LAST (after handoff-task-complete) so the completion-report directive fires
+  #     FIRST on the post-completion prompt — the report is owed before re-arming (AF.3).
+  #   • Gated on open.count == 0, so the backlog LOOP (open>0) is untouched —
+  #     handoff-task-complete still drives report→next-task at phases_complete.
+  # Scoped to phases_complete (NOT idle) for minimal blast radius. scope_start is a no-op
+  # from every mid-run state (only idle/phases_complete have the transition — fsm.yaml), so
+  # this can never reset an in-flight run. Landing in scoping is safe: it is the interactive
+  # phase (Stop + AskUserQuestion allowed; scope-before-code only bites a real code Write).
+  - id: rearm-on-depletion
+    process:
+      - call: read_fsm_state
+        as: st
+      - call: open_task_count
+        as: open
+      - call: advance_fsm
+        if: 'st == "phases_complete" && open.count == 0'
+        args:
+          event: scope_start
+      # Strict default for the re-armed track: a plain-language track can't be classified,
+      # so gate it at the strictest profile (feature). Mirrors enter-scoping's reset.
+      - call: write_state
+        if: 'st == "phases_complete" && open.count == 0'
+        args:
+          key: coding-flow-track
+          value: feature
+  # FU.2 (T-FLOW-UNSKIPPABLE / D2) — scope-sprawl escalation. The SCOPE phase is
+  # otherwise ungated, so a sprawling, oscillating scope (many prompts, no converging
+  # pre-research) is invisible. scope_dwell_tick increments a per-session counter while
+  # the FSM is in scoping/researching (resets when it leaves), and at the threshold (3)
+  # returns nudge=true → surface a "converge: write ONE pre-research" directive. SOFT
+  # (surface, never block) — research legitimately takes multiple turns; this nudges
+  # convergence, it does not forbid investigation.
+  - id: scope-sprawl-nudge
+    process:
+      - call: scope_dwell_tick
+        as: dwell
+      - call: verdict
+        if: 'dwell.nudge == true'
+        args:
+          level: directive
+          message: >-
+            CONVERGE THE SCOPE: you have spent several turns in the SCOPE phase without a
+            converging pre-research artifact. Stop open-ended investigation now — write ONE
+            `docs/research/T-*-pre-research-*.md` capturing the findings + the chosen design,
+            and advance to AUTHOR. (Questions belong in scope, but the scope must CONVERGE,
+            not sprawl.)
+prose: |
+  Entry + the four forward handoffs, one per stage boundary (incl. the EXECUTE→report→
+  next-task loop driver, AF.3). State-driven via read_fsm_state — the directive at each
+  milestone points the agent (and its persona) at the next stage's action.

package/packs/builtin/coding-flow/skills/execute-gate/skill.yaml

@@ -0,0 +1,71 @@
+# execute-gate — the EXECUTE-region CONTENT gate (the symmetric third). SCOPE has
+# guess-audit, AUTHOR has spec-audit; CODE/EXECUTE now has this: no `git commit` while
+# the active task's 7-phase workflow is incomplete. Mode-independent port of
+# sangmin-personal-rules/skills/workflow:34-70 — drops the `automation_mode_on`
+# precondition (:31-32) that made it inert interactively, matching the
+# mode-independent SCOPE/AUTHOR gates. Ad-hoc commits (no active task) PASS — the
+# SCOPE gate already forces code work into the flow, so a tracked task is the in-flow
+# case this guards. Spec: docs/tasks/T-fsm-unify.md §2.1; pre-research:
+# docs/research/T-execute-gate-pre-research-2026-06-03.md.
+name: execute-gate
+load: preload
+when_to_load: []
+triggers:
+  - kind: tool_call
+rules:
+  - id: phase-logged-before-commit
+    process:
+      - call: match_command
+        args:
+          # T-FLOW-UNSKIPPABLE FU.1 (the real root cause): this was `^git…commit`, anchored
+          # at START — so a COMPOUND command `cd <dir> && git commit …` (how every commit is
+          # actually made, since the Bash tool resets cwd) starts with `cd` and EVADED the
+          # gate entirely. The gate was dead for real commits. Match `git … commit` ANYWHERE
+          # (`\b`, like the sibling no-verify matcher) so compounds can't slip past. A false
+          # match on a string that merely mentions `git commit` is the safe direction (recall
+          # over precision, same as no-verify-block).
+          pattern: '\bgit\s+(?:-[cC]\s+\S+\s+)*commit\b'
+          target: tool_args.command
+        as: committing
+      # T-FLOW-UNSKIPPABLE FU.1 (D1): the gates must COMPOSE. The "no active task ⇒
+      # ad-hoc ⇒ allow" branch below was a SEAM — a blocked TaskCreate (AUTHOR gate)
+      # leaves NO active task, so its code leaked out as an "ad-hoc" commit. Close it:
+      # a commit while the FSM is MID-FLOW (a track is open but NOT yet authored —
+      # scoping/researching/researched/spec_authored) is NOT ad-hoc; it is
+      # authoring-incomplete work and BLOCKS. A genuine ad-hoc commit is from idle /
+      # phases_complete (no open track) — still allowed. (tasks_loaded / phases_in_flight
+      # are PAST author — code is expected there, guarded by the phase check below.)
+      - call: read_fsm_state
+        if: 'committing'
+        as: st
+      - call: verdict
+        if: 'committing && (st == "scoping" || st == "researching" || st == "researched" || st == "spec_authored")'
+        args:
+          level: block
+          message: >-
+            BLOCKED: a `git commit` while the flow is MID-FLOW (state: {{st}}) is NOT
+            "ad-hoc" — it is authoring-incomplete work. Complete SCOPE→AUTHOR (pass the
+            spec-audit + TaskCreate) before committing code. Do NOT route around a blocked
+            TaskCreate via an ad-hoc commit — that seam is now closed.
+      - call: has_active_task
+        if: 'committing'
+        as: active
+      - call: workflow_phases_complete
+        if: 'committing && active.present == true'
+        as: phases
+      - call: verdict
+        if: 'committing && active.present == true && phases.complete == false'
+        args:
+          level: block
+          message: >-
+            BLOCKED: the 7-phase CODE flow is incomplete for the active task. Log each
+            phase via `mcp__opensquid__log_phase` (pre_research → learn → code → test →
+            audit → post_research → fix) before `git commit`. (Ad-hoc commits from idle /
+            phases_complete pass; this gate guards in-flow work — the EXECUTE stage's
+            content gate, symmetric with SCOPE's guess-audit + AUTHOR's spec-audit.)
+prose: |
+  The EXECUTE content gate — the third, making the three stages symmetric. A stage
+  marker without a content gate is a checkbox (no-implicit-state); EXECUTE had only
+  the FSM advance (phase-advance) and no blocking gate, so the 7-phase CODE flow was
+  unenforced interactively. Blocks `git commit` until `workflow_phases_complete` is
+  true for the active task.

package/packs/builtin/coding-flow/skills/flow-health-check/skill.yaml

@@ -0,0 +1,42 @@
+# flow-health-check — T-FLOW-UNSKIPPABLE FU.3 (D3). SessionStart health assurance.
+#
+# On a genuine session begin (startup/resume — the SessionStart hook bin already
+# filters clear/compact), surface a LOUD inject_context when flow enforcement is
+# NOT active: the opensquid hooks aren't wired in ~/.claude/settings.json, or no
+# gate pack (one with an FSM) is active for this umbrella. This closes the F3
+# silent-un-gated case — a session that started before the hooks were installed
+# runs with zero gates and, until now, zero warning.
+#
+# REPORT-ONLY by necessity: a hook cannot retro-fit a session that never loaded
+# it, and Claude Code reads hook config only at session start — so the only honest
+# remedy is to INFORM + prompt a restart. The primitive returns a
+# RuleResult.inject_context directly (terminal, like session-connection-check); a
+# null return (healthy) is the no-verdict branch. unloads_when session_ends keeps
+# it off the long-running dynamic-skill set (the event only fires once anyway).
+name: flow-health-check
+load: lazy
+when_to_load:
+  - kind: event_type
+    type: session_start
+unloads_when:
+  - kind: session_ends
+triggers:
+  - kind: session_start
+rules:
+  # T-SESSION-STATUS-MANIFEST — the flow-enforcement status (incl. the F3 loud
+  # "enforcement INACTIVE — restart" signal) is now folded into the consolidated
+  # session_status_manifest (default-discipline/session-connection-check), so the
+  # standalone check_flow_health call is removed here to avoid double-reporting.
+  # check_flow_health stays a registered primitive (reused via flowEnforcementProblems).
+  # T-CHAT-REALTIME — make SessionStart actually SET UP chat: direct the agent to
+  # start the inbound watcher so messages arrive in real time (push, no
+  # turn-boundary wait, no --channels flag). Silent for umbrellas with no chat.
+  - id: start-chat-watcher
+    kind: track_check
+    process:
+      - call: chat_watcher_autostart
+prose: |
+  The SessionStart health assurance for the coding-flow gates: if the opensquid
+  hooks aren't wired or no gate pack is active, the SCOPE→AUTHOR→7-phase gates
+  silently don't run. This surfaces that as a loud directive at session begin
+  (the F3 fix), rather than letting work proceed un-gated with no signal.