wogiflow 2.22.0 → 2.22.2

package/.claude/commands/wogi-start.md

@@ -180,18 +180,18 @@ When epic creation adds 2+ stories to ready.json and `config.bulkOrchestrator.en
 
 Non-blocking if transition fails.
 
-### Effort Level Optimization (Claude Code 2.1.72+)
+### Effort Level Optimization (Claude Code 2.1.72+, xhigh added 2.1.111+)
 
 After task level classification (L0-L3), set the reasoning effort level to optimize token usage:
 
 | Task Level | Effort | Rationale |
 |------------|--------|-----------|
-| L0 (Epic) | high | Complex planning, multi-file architecture |
+| L0 (Epic) | high (xhigh on Opus 4.7 for deep architectural reasoning) | Complex planning, multi-file architecture |
 | L1 (Story) | high | Multi-criteria implementation |
 | L2 (Task) | medium | Standard 1-5 file changes |
 | L3 (Subtask) | low | Single file, trivial change |
 
-This is advisory — Claude Code 2.1.72 simplified effort to low/medium/high (removed "max"). The AI should adjust its reasoning depth accordingly during implementation phases.
+This is advisory. Claude Code's effort levels: `low` / `medium` / `high` are universal. Claude Code 2.1.111+ added `xhigh` (between high and max) and `max` as Opus 4.7-only levels — other models fall back to `high`. Use `/effort` interactively (slider as of 2.1.111) to switch mid-session. The AI should adjust reasoning depth during implementation phases accordingly.
 
 ### Task Checkpoints (when `config.proactiveCompaction.enabled`)
 

package/.claude/commands/wogi-story.md

@@ -8,11 +8,38 @@ Run `./scripts/flow story "<title>"` to create a story.
 
 Load `agents/story-writer.md` for the full story format.
 
+## Anti-Deferral Rule (MANDATORY)
+
+**Every item the user provides MUST become a work item** (criterion or sub-task). Never silently filter items. If you believe an item should be deferred, **ASK the user** — do not decide autonomously.
+
+For multi-item inputs, the command output MUST include: **"All {N} items captured as {criteria|sub-tasks}."** If any item cannot be mapped, the "Unmapped" warning must be surfaced, not suppressed.
+
+This rule applies equally to deep-decomposition mode and flat stories.
+
+## Specification-Quality Gates (wf-63c0f4cc)
+
+Five P0 gates run automatically at creation time (all fail-open):
+
+| Gate | Fires When | Effect |
+|------|-----------|--------|
+| 1. Long Input | input ≥40 lines OR ≥5 discrete items | routes to `/wogi-extract-review` |
+| 2. Item Reconciliation | input has ≥3 discrete items | writes manifest, verifies coverage |
+| 3. Consumer Impact | input contains refactor/rename/migrate/etc. | greps consumers, flags phased migration at ≥5 breaking |
+| 4. Scope-Confidence | input mentions "new X" / "existing Y" / "the Z service" | audits assumptions → "Pending Clarifications" block |
+| 5. Intent Bootstrap | IGR artifacts missing + not already scheduled | schedules background bootstrap via session-state.json |
+
+Gates enforce **specification quality at creation time**; runtime-quality gates (wiring, typecheck, tests) remain `/wogi-start`'s job.
+
+Config: `storyFlow.consumerImpactAnalysis`, `storyFlow.scopeConfidenceAudit`, `storyFlow.itemReconciliation`. All default-true.
+
 ## Options
 
 - `--deep` - Enable deep decomposition mode (auto-generate granular sub-tasks)
 - `--priority <P>` - Set priority P0-P4 (default: P2 from config)
 - `--json` - Output JSON for programmatic access
+- `--skip-gates` - Skip all P0 gates (testing/debug only)
+- `--bypass-long-input` - Skip Gate 1 (set by `/wogi-start` when it already routed long input)
+- `--full-input <txt>` - Full user input for gates (when title is a summary)
 
 Examples:
 ```bash

package/.claude/docs/claude-code-compatibility.md

@@ -408,6 +408,37 @@ await cancelTask('wf-123', 'superseded', false);
 
 - **Hardened "Open in editor" against command injection**: Security hardening for untrusted filenames. **Impact on WogiFlow**: Validates the same pattern in `.claude/rules/security/security-patterns.md` — external inputs going into shell commands must be validated. No WogiFlow code change needed.
 
+### Features in 2.1.111+
+
+- **`xhigh` effort level for Opus 4.7**: New effort level sitting between `high` and `max`, available via `/effort`, `--effort`, and the model picker. Other models fall back to `high`. `/effort` now opens an interactive slider when called without arguments. **Impact on WogiFlow**: The effort-level mapping in `wogi-start.md` now acknowledges `xhigh`/`max` as Opus 4.7-only. For L0 epics running on Opus 4.7, users may prefer `xhigh` over `high` for deeper architectural reasoning — the mapping table documents this as an option. No code change needed; the mapping is advisory.
+
+- **`/ultrareview` built-in command**: Claude Code now ships a native `/ultrareview` that runs parallel multi-agent analysis and critique in the cloud — invoke with no arguments to review the current branch, or `/ultrareview <PR#>` to fetch and review a specific GitHub PR. **Relationship to WogiFlow's review commands**: No collision (`wogi-*` prefix). How to choose:
+  - `/ultrareview` — cloud-side parallel multi-agent critique. Zero local setup. Best for standalone branch/PR reviews when you don't have peer models configured.
+  - `/wogi-peer-review` — uses the peer models you configured via `/wogi-models-setup` (local/BYO models). Best when you want specific perspectives (e.g., a different vendor's model) or offline/cost-controlled review.
+  - `/wogi-review` — single-reviewer code review wired into WogiFlow task state (findings logged to `last-review.json`, triaged via `/wogi-triage`). Best for in-flow review during task execution.
+  - `/wogi-review-fix` — auto-applies fixes from `/wogi-review` findings.
+  Users can combine them: run `/ultrareview` for a wide-angle cloud critique, then `/wogi-review` for task-linked findings.
+
+- **`/less-permission-prompts` built-in skill**: Scans recent transcripts for common read-only Bash and MCP tool calls and proposes a prioritized allowlist for `.claude/settings.json`. **Relationship to WogiFlow**: Complementary to `computeLeanConfig()` in `lib/installer.js` — the installer produces a minimal allowlist at install time, while `/less-permission-prompts` tunes the allowlist based on actual session usage. Suggested workflow: after a few WogiFlow sessions, run `/less-permission-prompts` to prune redundant prompts. Future opportunity: surface this suggestion in `/wogi-health` output.
+
+- **Auto-allow for read-only bash with globs and `cd <project-dir> &&` prefix**: Read-only commands like `ls *.ts` and commands starting with `cd <project-dir> &&` no longer trigger a permission prompt. **Impact on WogiFlow**: Reduces prompts during WogiFlow hook-driven validation (lint/typecheck) and user-driven exploration. Allowlist rules in `lib/installer.js` that duplicated these patterns are now redundant — minor cleanup opportunity (tracked, low priority). No action required; the installer's lean-config approach already avoids over-emitting.
+
+- **Auto mode for Max subscribers on Opus 4.7**: Auto mode is now available for Max subscribers when using Opus 4.7, and no longer requires `--enable-auto-mode`. 2.1.112 fixed a "claude-opus-4-7 is temporarily unavailable" error in auto mode. **Impact on WogiFlow**: WogiFlow's model registry already lists Opus 4.7 (v2.22.0); auto-mode routing is orthogonal to WogiFlow's hybrid mode. Users on Max with Opus 4.7 benefit automatically.
+
+- **`OTEL_LOG_RAW_API_BODIES` env var**: Emits full API request and response bodies as OpenTelemetry log events for debugging. **Impact on WogiFlow**: Useful when debugging hybrid mode (`/wogi-hybrid`) routing and peer-review (`/wogi-peer-review`) model calls — set this env var to see the exact payloads reaching each model. Complements WogiFlow's gate telemetry (`/wogi-gate-stats`) which tracks pass/catch/miss rates at a higher level. Set with: `export OTEL_LOG_RAW_API_BODIES=1`. Note: payloads may contain sensitive data — only enable in development.
+
+- **Headless `--output-format stream-json` includes `plugin_errors` on init**: Plugin demotion errors (unsatisfied dependencies, conflicting versions) are now surfaced on the init event in headless mode. **WogiFlow opportunity**: `/wogi-health` could read this stream when running in CI/headless mode to flag plugin-registry issues before they cause silent failures. Tracked as an enhancement.
+
+- **Opus 4.7 availability fix (2.1.112)**: Fixed a "claude-opus-4-7 is temporarily unavailable" error in auto mode. Aligned with WogiFlow v2.22.0 registry update. No WogiFlow code change needed.
+
+- **Windows improvements**: `CLAUDE_ENV_FILE` and SessionStart hook environment files now apply on Windows (previously a no-op). Permission rules with drive-letter paths are now correctly root-anchored, and paths differing only by drive-letter case are recognized as the same path. **Impact on WogiFlow**: Windows users of WogiFlow's SessionStart hook can now configure environment variables via `CLAUDE_ENV_FILE`. Drive-letter-path permission rules generated by the installer now behave correctly. Automatic improvement after upgrade.
+
+- **Miscellaneous UX**: Plan files named after the originating prompt (e.g. `fix-auth-race-snug-otter.md`), `/skills` menu supports sorting by estimated token count (press `t`), Ctrl+U clears the entire input buffer (Ctrl+Y restores), Ctrl+L forces a full redraw, and typo suggestions on near-miss subcommands. Documentation-only for WogiFlow.
+
+- **Fixed "Unknown skill: commit" error**: Users without a custom `/commit` skill were seeing this error when Claude Code tried to invoke a non-existent built-in. **Impact on WogiFlow**: No WogiFlow-shipped `/commit` skill (commits go through `/wogi-finalize` and git commit instructions). Users benefit passively from the fix.
+
+- **Reliability fixes (all automatic after upgrade)**: Terminal display tearing in iTerm2+tmux, `@`-file suggestions re-scanning entire project in non-git directories, LSP diagnostics from before an edit appearing after it, tab-completing `/resume` behavior, `/context` grid rendering, `/clear` dropping session name, spurious decompression/network/transient errors in the TUI. Reverted v2.1.110 cap on non-streaming fallback retries (now uncapped again). Fixed Bedrock/Vertex/Foundry 429 retries pointing users at the wrong status page, bare URLs unclickable when wrapped in tool output, feedback surveys appearing back-to-back. WogiFlow sessions benefit from all of these automatically.
+
 ### Simple Mode Naming Distinction
 
 Claude Code's `CLAUDE_CODE_SIMPLE` environment variable (which enables a simplified tool set) is **unrelated** to WogiFlow's `loops.simpleMode` (a lightweight task completion loop using string detection). They are separate features that happen to share the word "simple":
@@ -542,4 +573,4 @@ Run `/keybindings` in Claude Code to customize your shortcuts.
 
 ---
 
-*Last updated: 2026-04-16*
+*Last updated: 2026-04-17*

package/lib/workspace-dispatch-tracking.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — Dispatch Tracking (wf-d3e67abe)
+ *
+ * Silent-worker-halt detection via file-based dispatch records.
+ *
+ * Manager records every dispatch; any pending dispatch past its
+ * expectedDeadline without a matching completion/stop message =
+ * silent death. Surfaced on the next manager turn via the
+ * UserPromptSubmit hook (no background processes).
+ *
+ * State file: .workspace/state/dispatched-tasks.json
+ * Ring buffer of last MAX_ACTIVE records; older overflow to
+ * .workspace/state/dispatched-tasks.archive.jsonl (append-only).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { safeReadJson } = require('./utils');
+
+const DEFAULT_DURATION_MS = 30 * 60 * 1000; // 30 min — matches waitForCompletion default
+const MAX_ACTIVE = 100;
+const SCHEMA_VERSION = 1;
+
+const VALID_STATUSES = new Set(['pending', 'completed', 'graceful-stop', 'silent-halt']);
+
+function stateFilePath(workspaceRoot) {
+  return path.join(workspaceRoot, '.workspace', 'state', 'dispatched-tasks.json');
+}
+
+function archiveFilePath(workspaceRoot) {
+  return path.join(workspaceRoot, '.workspace', 'state', 'dispatched-tasks.archive.jsonl');
+}
+
+function loadState(workspaceRoot) {
+  const data = safeReadJson(stateFilePath(workspaceRoot), null);
+  if (data && typeof data === 'object' && Array.isArray(data.dispatches)) {
+    return { version: data.version || SCHEMA_VERSION, dispatches: data.dispatches };
+  }
+  return { version: SCHEMA_VERSION, dispatches: [] };
+}
+
+function saveState(workspaceRoot, state) {
+  const filePath = stateFilePath(workspaceRoot);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+
+function archiveRecord(workspaceRoot, record) {
+  const filePath = archiveFilePath(workspaceRoot);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, JSON.stringify(record) + '\n');
+}
+
+/**
+ * Record a dispatch. Appends to state and trims ring buffer.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} params
+ * @param {string} params.taskId - wf-XXXXXXXX
+ * @param {string} params.repoName
+ * @param {number} [params.expectedDurationMs=DEFAULT_DURATION_MS]
+ * @param {string} [params.dispatchedBy='manager']
+ * @returns {Object} the created record
+ */
+function recordDispatch(workspaceRoot, { taskId, repoName, expectedDurationMs, dispatchedBy }) {
+  if (!workspaceRoot || typeof workspaceRoot !== 'string') {
+    throw new Error('workspaceRoot required');
+  }
+  if (!/^wf-[0-9a-f]{8}$/i.test(taskId || '')) {
+    throw new Error(`Invalid taskId: ${taskId}`);
+  }
+  if (!repoName || typeof repoName !== 'string') {
+    throw new Error('repoName required');
+  }
+
+  const durationMs = Number.isFinite(expectedDurationMs) && expectedDurationMs > 0
+    ? expectedDurationMs
+    : DEFAULT_DURATION_MS;
+  const now = Date.now();
+  const dispatchedAt = new Date(now).toISOString();
+  const expectedDeadline = new Date(now + durationMs).toISOString();
+
+  const record = {
+    taskId,
+    repoName,
+    dispatchedAt,
+    expectedDeadline,
+    expectedDurationMs: durationMs,
+    status: 'pending',
+    dispatchedBy: dispatchedBy || 'manager',
+    reconciledAt: null,
+    reconciledReason: null
+  };
+
+  const state = loadState(workspaceRoot);
+  state.dispatches.push(record);
+
+  // Ring buffer: overflow oldest records to archive
+  while (state.dispatches.length > MAX_ACTIVE) {
+    const overflow = state.dispatches.shift();
+    try { archiveRecord(workspaceRoot, overflow); }
+    catch (_err) { /* non-fatal — archive is best-effort */ }
+  }
+
+  saveState(workspaceRoot, state);
+  return record;
+}
+
+/**
+ * Reconcile the most recent pending record for a task.
+ *
+ * @param {string} workspaceRoot
+ * @param {string} taskId
+ * @param {string} status - 'completed' | 'graceful-stop' | 'silent-halt'
+ * @param {string} [reason]
+ * @returns {Object|null} updated record, or null if not found
+ */
+function reconcileDispatch(workspaceRoot, taskId, status, reason) {
+  if (!VALID_STATUSES.has(status) || status === 'pending') {
+    throw new Error(`Invalid reconcile status: ${status}`);
+  }
+  const state = loadState(workspaceRoot);
+  // Find most recent pending record for this taskId (last wins — most recent dispatch)
+  for (let i = state.dispatches.length - 1; i >= 0; i--) {
+    const r = state.dispatches[i];
+    if (r && r.taskId === taskId && r.status === 'pending') {
+      r.status = status;
+      r.reconciledAt = new Date().toISOString();
+      r.reconciledReason = reason || null;
+      saveState(workspaceRoot, state);
+      return r;
+    }
+  }
+  return null;
+}
+
+/**
+ * Read all currently-active dispatch records (not archived).
+ *
+ * @param {string} workspaceRoot
+ * @returns {Array<Object>}
+ */
+function readDispatches(workspaceRoot) {
+  return loadState(workspaceRoot).dispatches;
+}
+
+/**
+ * Get dispatches whose expectedDeadline has passed and are still pending.
+ *
+ * @param {string} workspaceRoot
+ * @param {number} [now=Date.now()]
+ * @returns {Array<Object>} overdue records
+ */
+function getOverdueDispatches(workspaceRoot, now) {
+  const ts = Number.isFinite(now) ? now : Date.now();
+  const dispatches = readDispatches(workspaceRoot);
+  return dispatches.filter(r => {
+    if (!r || r.status !== 'pending') return false;
+    const deadline = Date.parse(r.expectedDeadline || '');
+    return Number.isFinite(deadline) && deadline < ts;
+  });
+}
+
+module.exports = {
+  DEFAULT_DURATION_MS,
+  MAX_ACTIVE,
+  recordDispatch,
+  reconcileDispatch,
+  readDispatches,
+  getOverdueDispatches,
+  stateFilePath,
+  archiveFilePath
+};

package/lib/workspace-messages.js

@@ -22,6 +22,8 @@ const MESSAGE_TYPES = [
   'question',         // "Does your side handle X?"
   'bug-report',       // "Your endpoint returns 500 when I send Y"
   'task-complete',    // "I finished my side of feature Z"
+  'worker-stopped',   // Graceful Stop hook — worker session ending, not necessarily at task completion
+  'worker-ready',     // Fresh worker session with empty queue — "got anything for me?" (wf-restart-handoff)
   'needs-help',       // "I'm stuck, can you check X on your side?"
   'heads-up',         // "I'm about to change Y, just FYI"
   'impact-query',     // Pre-dev: "I'm about to change X, will this break you?"

package/lib/workspace-routing.js

@@ -700,6 +700,8 @@ function checkWorkerHealth(port) {
  * @param {string} taskId — task ID to start
  * @param {Object} [opts] — dispatch options
  * @param {string} [opts.effortLevel] — reasoning effort to propagate ('low'|'medium'|'high')
+ * @param {number} [opts.expectedDurationMs] — override deadline for silent-halt detection
+ *   (wf-d3e67abe). Defaults to DEFAULT_DURATION_MS from workspace-dispatch-tracking.
  * @returns {Promise<{ ok: boolean, message: string }>}
  */
 async function dispatchToChannel(workspaceRoot, repoName, taskId, opts = {}) {
@@ -739,6 +741,21 @@ async function dispatchToChannel(workspaceRoot, repoName, taskId, opts = {}) {
   const dispatchBody = `${effortPrefix}/wogi-start ${taskId}`;
   const result = await httpPost('127.0.0.1', port, dispatchBody);
   if (result.ok) {
+    // wf-d3e67abe — record dispatch for silent-halt detection.
+    // Fail-open: if tracking write fails, dispatch itself still succeeds.
+    try {
+      const { recordDispatch } = require('./workspace-dispatch-tracking');
+      recordDispatch(workspaceRoot, {
+        taskId,
+        repoName,
+        expectedDurationMs: opts.expectedDurationMs,
+        dispatchedBy: process.env.WOGI_REPO_NAME || 'manager'
+      });
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error(`[dispatchToChannel] Dispatch tracking failed (non-fatal): ${err.message}`);
+      }
+    }
     return { ok: true, message: `Dispatched /wogi-start ${taskId} to ${repoName} (port ${port})${effortLevel ? ` [effort: ${effortLevel}]` : ''}` };
   }
 

package/lib/workspace-worker-ready.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — Worker Readiness Announce (restart-handoff protocol)
+ *
+ * Problem this solves:
+ *   When a worker session restarts (wogi-claude wrapper relaunches claude
+ *   after a task-boundary), channel dispatches sent by the manager during
+ *   the restart window can be lost — they arrive either while the old
+ *   claude is shutting down or before the new claude has wired up its
+ *   MCP channel, and the notification never reaches a live session.
+ *
+ *   Previous sessions observed: manager dispatches session N, worker
+ *   completes N and restarts, manager tries to dispatch N+1 during the
+ *   restart gap, N+1 is lost, worker comes up fresh with empty queue
+ *   and sits idle until the user notices and the manager re-dispatches.
+ *
+ * Design:
+ *   File-based announce via the workspace-messages bus. When a worker
+ *   SessionStart fires and the worker has zero in-progress tasks and
+ *   zero queued channel dispatches, write a structured `worker-ready`
+ *   message to `.workspace/messages/`. The manager's next turn sweeps
+ *   the bus, cross-references the dispatched-tasks.json (wf-d3e67abe)
+ *   to see if anything is owed to this worker, and surfaces lost
+ *   dispatches for re-dispatch.
+ *
+ *   File-based delivery is durable: no timing games, no buffer TTL,
+ *   no dependency on the MCP channel server being up during the
+ *   restart gap. Worker writes → manager reads → reconciles.
+ *
+ * Dedup:
+ *   If a pending `worker-ready` message already exists for this repo,
+ *   we skip — no need to stack announcements while the manager hasn't
+ *   picked up the first one yet.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { safeReadJson } = require('./utils');
+
+/**
+ * Detect if the current process is a workspace worker (not a manager and not a
+ * single-repo session). Mirrors the isWorkspaceWorker detection used in
+ * scripts/hooks/core/task-completed.js.
+ *
+ * @returns {boolean}
+ */
+function isWorker() {
+  if (!process.env.WOGI_WORKSPACE_ROOT) return false;
+  const repo = process.env.WOGI_REPO_NAME;
+  if (!repo || repo === 'manager') return false;
+  return true;
+}
+
+/**
+ * Resolve the workspace root from env (worker mode).
+ *
+ * @returns {string|null}
+ */
+function getWorkspaceRoot() {
+  const root = process.env.WOGI_WORKSPACE_ROOT;
+  if (!root || !path.isAbsolute(root)) return null;
+  return root;
+}
+
+/**
+ * Check whether a pending worker-ready message already exists for this repo.
+ * Used to dedup — we don't need to stack announcements.
+ *
+ * @param {string} workspaceRoot
+ * @param {string} repoName
+ * @returns {boolean}
+ */
+function hasPendingAnnounce(workspaceRoot, repoName) {
+  try {
+    const messagesDir = path.join(workspaceRoot, '.workspace', 'messages');
+    if (!fs.existsSync(messagesDir)) return false;
+    const files = fs.readdirSync(messagesDir).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      try {
+        const msg = safeReadJson(path.join(messagesDir, file));
+        if (!msg) continue;
+        if (msg.type === 'worker-ready' &&
+            msg.from === repoName &&
+            msg.status === 'pending') {
+          return true;
+        }
+      } catch (_err) { /* skip malformed */ }
+    }
+    return false;
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * Decide whether this worker should announce ready.
+ * Preconditions:
+ *   - Worker mode (WOGI_WORKSPACE_ROOT + WOGI_REPO_NAME !== 'manager')
+ *   - ready.json has zero in-progress tasks
+ *   - ready.json has zero queued channel-dispatched tasks
+ *     (if it has queued work, the SessionStart hook auto-invokes
+ *     /wogi-start instead of announcing — different branch)
+ *   - No pending worker-ready message already exists for this repo
+ *
+ * @param {Object} [opts] - override knobs for testing
+ * @param {string} [opts.workspaceRoot]
+ * @param {string} [opts.repoName]
+ * @param {Object} [opts.readyData]
+ * @returns {{announce: boolean, reason: string, repoName?: string, workspaceRoot?: string}}
+ */
+function shouldAnnounceReady(opts = {}) {
+  const workspaceRoot = opts.workspaceRoot || getWorkspaceRoot();
+  const repoName = opts.repoName || process.env.WOGI_REPO_NAME;
+
+  if (!workspaceRoot) return { announce: false, reason: 'no-workspace-root' };
+  if (!opts.repoName && !isWorker()) return { announce: false, reason: 'not-worker' };
+  if (!repoName || repoName === 'manager') return { announce: false, reason: 'not-worker' };
+
+  let readyData = opts.readyData;
+  if (!readyData) {
+    try {
+      const { PATHS } = require('../scripts/flow-utils');
+      const readyPath = path.join(PATHS.state, 'ready.json');
+      readyData = safeReadJson(readyPath, { ready: [], inProgress: [] });
+    } catch (_err) {
+      readyData = { ready: [], inProgress: [] };
+    }
+  }
+
+  const inProgress = Array.isArray(readyData.inProgress) ? readyData.inProgress : [];
+  if (inProgress.length > 0) {
+    return { announce: false, reason: 'in-progress-not-empty' };
+  }
+
+  const queuedChannel = (Array.isArray(readyData.ready) ? readyData.ready : [])
+    .filter(t => t && (
+      t.channelSource === 'wogi-workspace-channel' ||
+      t.dispatchedBy === 'workspace-manager' ||
+      (typeof t.source === 'string' && t.source.startsWith('workspace:'))
+    ));
+  if (queuedChannel.length > 0) {
+    return { announce: false, reason: 'queued-channel-work-present' };
+  }
+
+  if (hasPendingAnnounce(workspaceRoot, repoName)) {
+    return { announce: false, reason: 'already-announced' };
+  }
+
+  return { announce: true, reason: 'ok', workspaceRoot, repoName };
+}
+
+/**
+ * Write a worker-ready message to the workspace-messages bus.
+ *
+ * @param {string} workspaceRoot
+ * @param {string} repoName
+ * @returns {{written: boolean, messageId?: string, path?: string, reason?: string}}
+ */
+function announceWorkerReady(workspaceRoot, repoName) {
+  try {
+    const { createMessage, saveMessage } = require('./workspace-messages');
+    const msg = createMessage({
+      from: repoName,
+      to: 'manager',
+      type: 'worker-ready',
+      subject: `Worker ${repoName} ready — queue empty, awaiting dispatch`,
+      body: [
+        `Worker "${repoName}" has started a fresh session with an empty task queue.`,
+        `If you dispatched any tasks to this worker that were lost during the`,
+        `restart window, they can be re-dispatched now. No pending work detected`,
+        `in ready.json (zero inProgress, zero queued channel dispatches).`
+      ].join('\n'),
+      priority: 'medium',
+      actionRequired: false
+    });
+    const filePath = saveMessage(workspaceRoot, msg);
+    return { written: true, messageId: msg.id, path: filePath };
+  } catch (err) {
+    return { written: false, reason: `write-failed: ${err.message}` };
+  }
+}
+
+module.exports = {
+  isWorker,
+  getWorkspaceRoot,
+  hasPendingAnnounce,
+  shouldAnnounceReady,
+  announceWorkerReady
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.22.0",
+  "version": "2.22.2",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "flow": "./scripts/flow",
-    "test": "NODE_ENV=test node --test tests/auto-compact-prompt.test.js tests/flow-paths.test.js tests/flow-io.test.js tests/flow-config-loader.test.js tests/flow-damage-control.test.js tests/flow-output.test.js tests/flow-constants.test.js tests/flow-session-state.test.js tests/flow-hooks-integration.test.js tests/flow-utils.test.js tests/flow-security.test.js tests/flow-memory-db.test.js tests/flow-durable-session.test.js tests/flow-skill-matcher.test.js tests/flow-bridge.test.js tests/flow-proactive-compact.test.js tests/flow-cascade-completion.test.js tests/flow-capture-gate.test.js tests/flow-correction-detector-hybrid.test.js tests/flow-promote.test.js tests/flow-archive-runs.test.js tests/flow-memory.test.js tests/flow-hooks-pre-tool-helpers.test.js tests/flow-hooks-bugfix-scope-gate.test.js tests/flow-hooks-routing-gate.test.js tests/flow-hooks-phase-read-gate.test.js tests/flow-hooks-commit-log-gate.test.js tests/flow-hooks-deploy-gate.test.js tests/flow-hooks-todowrite-gate.test.js tests/flow-hooks-git-safety-gate.test.js tests/flow-hooks-scope-mutation-gate.test.js tests/flow-hooks-strike-gate.test.js tests/flow-hooks-component-check.test.js tests/flow-hooks-scope-gate.test.js tests/flow-hooks-implementation-gate.test.js tests/flow-hooks-research-gate.test.js tests/flow-hooks-loop-check.test.js tests/flow-hooks-manager-boundary-gate.test.js tests/flow-hooks-phase-gate.test.js tests/flow-hooks-pre-tool-orchestrator.test.js tests/flow-hooks-observation-capture.test.js tests/flow-hooks-task-gate.test.js tests/flow-durable-session-suspension.test.js tests/flow-health-mcp-scopes.test.js tests/flow-lean-config.test.js tests/flow-workspace-autopickup.test.js tests/flow-worker-boundary-gate.test.js tests/flow-worker-question-classifier.test.js tests/flow-completion-truth-gate-contradictions.test.js tests/flow-structure-sensor.test.js && NODE_ENV=test node tests/run-quality-gates.test.js",
+    "test": "NODE_ENV=test node --test tests/auto-compact-prompt.test.js tests/flow-paths.test.js tests/flow-io.test.js tests/flow-config-loader.test.js tests/flow-damage-control.test.js tests/flow-output.test.js tests/flow-constants.test.js tests/flow-session-state.test.js tests/flow-hooks-integration.test.js tests/flow-utils.test.js tests/flow-security.test.js tests/flow-memory-db.test.js tests/flow-durable-session.test.js tests/flow-skill-matcher.test.js tests/flow-bridge.test.js tests/flow-proactive-compact.test.js tests/flow-cascade-completion.test.js tests/flow-capture-gate.test.js tests/flow-correction-detector-hybrid.test.js tests/flow-promote.test.js tests/flow-archive-runs.test.js tests/flow-memory.test.js tests/flow-hooks-pre-tool-helpers.test.js tests/flow-hooks-bugfix-scope-gate.test.js tests/flow-hooks-routing-gate.test.js tests/flow-hooks-phase-read-gate.test.js tests/flow-hooks-commit-log-gate.test.js tests/flow-hooks-deploy-gate.test.js tests/flow-hooks-todowrite-gate.test.js tests/flow-hooks-git-safety-gate.test.js tests/flow-hooks-scope-mutation-gate.test.js tests/flow-hooks-strike-gate.test.js tests/flow-hooks-component-check.test.js tests/flow-hooks-scope-gate.test.js tests/flow-hooks-implementation-gate.test.js tests/flow-hooks-research-gate.test.js tests/flow-hooks-loop-check.test.js tests/flow-hooks-manager-boundary-gate.test.js tests/flow-hooks-phase-gate.test.js tests/flow-hooks-pre-tool-orchestrator.test.js tests/flow-hooks-observation-capture.test.js tests/flow-hooks-task-gate.test.js tests/flow-durable-session-suspension.test.js tests/flow-health-mcp-scopes.test.js tests/flow-lean-config.test.js tests/flow-workspace-autopickup.test.js tests/flow-worker-boundary-gate.test.js tests/flow-worker-question-classifier.test.js tests/flow-completion-truth-gate-contradictions.test.js tests/flow-structure-sensor.test.js tests/flow-workspace-dispatch-tracking.test.js tests/flow-story-gates.test.js tests/flow-workspace-restart-handoff.test.js && NODE_ENV=test node tests/run-quality-gates.test.js",
     "test:syntax": "find scripts/ lib/ -name '*.js' -not -path '*/node_modules/*' -exec node --check {} +",
     "lint": "eslint scripts/ lib/ tests/",
     "lint:ci": "eslint scripts/ lib/ tests/ --max-warnings 0",

package/scripts/flow-config-defaults.js

@@ -328,6 +328,15 @@ const CONFIG_DEFAULTS = {
     supportEpics: true,
     propagateProgress: true
   },
+
+  // --- Story Creation Quality Gates (wf-63c0f4cc) ---
+  // Specification-quality gates enforced at story CREATION time. Execution-
+  // quality gates (runtime wiring, typecheck, tests) remain /wogi-start's job.
+  storyFlow: {
+    consumerImpactAnalysis: { enabled: true, breakingThreshold: 5 },
+    scopeConfidenceAudit: { enabled: true },
+    itemReconciliation: { enabled: true, minItems: 3 }
+  },
   epics: { enabled: false },
 
   // --- Specification & Questions ---