wogiflow 2.26.2 → 2.29.1

package/scripts/flow-skill-manage.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * Wogi Flow — Skill Proposal CLI
+ *
+ * Subcommands:
+ *   flow skill propose --name <n> --content <file> [--rationale <text>]
+ *   flow skill patch   --name <n> --content <file> [--rationale <text>]
+ *   flow skill remove  --name <n> [--rationale <text>]
+ *   flow skill promote <name> [--id <proposalId>]
+ *   flow skill reject  <name> [--id <proposalId>]
+ *   flow skill archive <name>
+ *   flow skill pending [--json]
+ *
+ * Writes are staged to .claude/skills/pending/ and .workflow/state/skill-proposals.json.
+ * Session-end hook surfaces pending proposals for user review.
+ */
+
+const store = require('../lib/skill-proposal-store');
+const { success, error: errorMsg, info, colors } = require('./flow-output');
+
+// ============================================================
+// Arg parsing
+// ============================================================
+
+function parseArgs(argv) {
+  // argv = [subcommand, ...rest]
+  const [subcommand, ...rest] = argv;
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === '--name') {
+      flags.name = rest[++i];
+    } else if (a === '--content') {
+      flags.content = rest[++i];
+    } else if (a === '--find') {
+      flags.find = rest[++i];
+    } else if (a === '--replace') {
+      flags.replace = rest[++i];
+    } else if (a === '--rationale') {
+      flags.rationale = rest[++i];
+    } else if (a === '--id') {
+      flags.id = rest[++i];
+    } else if (a === '--json') {
+      flags.json = true;
+    } else if (a === '--proposed-by') {
+      flags.proposedBy = rest[++i];
+    } else if (a === '--help' || a === '-h') {
+      flags.help = true;
+    } else if (a && !a.startsWith('--')) {
+      positional.push(a);
+    }
+  }
+  return { subcommand, flags, positional };
+}
+
+function showHelp() {
+  console.log(`
+${colors.cyan}Wogi Flow — Skill Proposal CLI${colors.reset}
+
+Agent-staged skill changes. Proposals are reviewed at session-end and approved
+or rejected by the user. No auto-apply.
+
+Usage:
+  flow skill propose --name <n> --content <file> [--rationale <text>]
+  flow skill patch   --name <n> --content <file> [--rationale <text>]
+  flow skill patch   --name <n> --find <file> --replace <file> [--rationale <text>]
+  flow skill remove  --name <n> [--rationale <text>]
+  flow skill promote <name> [--id <proposalId>]
+  flow skill reject  <name> [--id <proposalId>]
+  flow skill archive <name>
+  flow skill pending [--json]
+
+Actions:
+  propose     Stage a new skill. Writes content to .claude/skills/pending/<n>.md
+  patch       Stage an edit to an existing skill. Use --content for full
+              replacement, or --find + --replace for fuzzy find-replace
+              (tolerates whitespace/line-ending drift; rejects low-confidence
+              matches below skills.fuzzyPatchThreshold, default 0.85).
+  remove      Stage a removal of an existing skill.
+  promote     Apply a pending proposal (user-only). Moves pending → active,
+              applies patch, or archives as appropriate.
+  reject      Discard a pending proposal; cleans up staged content.
+  archive     Direct archival of an active skill (no staging).
+  pending     List pending proposals. --json for machine-readable output.
+
+Examples:
+  flow skill propose --name react-hooks --content scratch/draft.md \\
+                     --rationale "capture hook patterns from recent session"
+  flow skill patch   --name react-hooks --content scratch/updated.md
+  flow skill remove  --name outdated-skill --rationale "superseded by newer skill"
+  flow skill promote react-hooks
+  flow skill reject  react-hooks
+`);
+}
+
+function printPending(list, asJson) {
+  if (asJson) {
+    process.stdout.write(JSON.stringify(list, null, 2) + '\n');
+    return;
+  }
+  if (list.length === 0) {
+    info('No pending skill proposals.');
+    return;
+  }
+  console.log(`${colors.cyan}Pending skill proposals (${list.length}):${colors.reset}\n`);
+  for (const p of list) {
+    const icon = p.action === 'propose' ? '+' : p.action === 'patch' ? '~' : '-';
+    console.log(`  ${colors.bold}${icon} ${p.skillName}${colors.reset} ${colors.dim}(${p.action}, ${p.id})${colors.reset}`);
+    console.log(`    proposedAt: ${p.proposedAt}  by: ${p.proposedBy}`);
+    if (p.contentPath) console.log(`    content:    ${p.contentPath}`);
+    if (p.rationale) console.log(`    rationale:  ${p.rationale}`);
+    console.log('');
+  }
+}
+
+// ============================================================
+// Subcommand handlers
+// ============================================================
+
+function runPropose(flags) {
+  const record = store.createProposal({
+    action: 'propose',
+    skillName: flags.name,
+    contentFile: flags.content,
+    rationale: flags.rationale,
+    proposedBy: flags.proposedBy,
+  });
+  success(`Staged propose '${record.skillName}' (${record.id})`);
+  console.log(`  content: ${record.contentPath}`);
+  console.log(`  review with: flow skill pending`);
+  return 0;
+}
+
+function runPatch(flags) {
+  const record = store.createProposal({
+    action: 'patch',
+    skillName: flags.name,
+    contentFile: flags.content,
+    findFile: flags.find,
+    replaceFile: flags.replace,
+    rationale: flags.rationale,
+    proposedBy: flags.proposedBy,
+  });
+  success(`Staged patch '${record.skillName}' (${record.id})`);
+  if (record.patchMode === 'fuzzy') {
+    console.log(`  mode:    fuzzy find/replace`);
+    console.log(`  find:    ${record.findPath}`);
+    console.log(`  replace: ${record.replacePath}`);
+  } else {
+    console.log(`  mode:    full replacement`);
+    console.log(`  content: ${record.contentPath}`);
+  }
+  return 0;
+}
+
+function runRemove(flags) {
+  const record = store.createProposal({
+    action: 'remove',
+    skillName: flags.name,
+    rationale: flags.rationale,
+    proposedBy: flags.proposedBy,
+  });
+  success(`Staged remove '${record.skillName}' (${record.id})`);
+  console.log(`  review with: flow skill pending`);
+  return 0;
+}
+
+function runPromote(flags, positional) {
+  const name = positional[0] || flags.name;
+  const id = flags.id;
+  if (!name && !id) throw new Error('promote requires a skill name or --id <proposalId>');
+  const applied = store.promoteProposal({ skillName: name, id });
+  success(`Promoted ${applied.action} '${applied.skillName}' (${applied.id})`);
+  return 0;
+}
+
+function runReject(flags, positional) {
+  const name = positional[0] || flags.name;
+  const id = flags.id;
+  if (!name && !id) throw new Error('reject requires a skill name or --id <proposalId>');
+  const rejected = store.rejectProposal({ skillName: name, id });
+  success(`Rejected ${rejected.action} '${rejected.skillName}' (${rejected.id})`);
+  return 0;
+}
+
+function runArchive(_flags, positional) {
+  const name = positional[0];
+  if (!name) throw new Error('archive requires a skill name');
+  const r = store.archiveSkill(name);
+  success(`Archived '${r.skillName}' → ${r.archivedPath}`);
+  return 0;
+}
+
+function runPending(flags) {
+  const list = store.listProposals({ status: 'pending' });
+  printPending(list, !!flags.json);
+  return 0;
+}
+
+// ============================================================
+// Main
+// ============================================================
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const { subcommand, flags, positional } = parseArgs(argv);
+
+  if (flags.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  try {
+    let code;
+    switch (subcommand) {
+      case 'propose':  code = runPropose(flags); break;
+      case 'patch':    code = runPatch(flags); break;
+      case 'remove':   code = runRemove(flags); break;
+      case 'promote':  code = runPromote(flags, positional); break;
+      case 'reject':   code = runReject(flags, positional); break;
+      case 'archive':  code = runArchive(flags, positional); break;
+      case 'pending':  code = runPending(flags); break;
+      default:
+        errorMsg(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+        process.exit(1);
+    }
+    process.exit(code);
+  } catch (err) {
+    errorMsg(err.message);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { parseArgs, runPropose, runPatch, runRemove, runPromote, runReject, runArchive, runPending };

package/scripts/flow-spec-verifier.js

@@ -410,7 +410,7 @@ function isLikelyNewFile(content, filePath) {
  * @param {string} filePath - File path
  * @returns {string|null} Section name
  */
-function findFileSection(content, filePath) {
+function _findFileSection(content, filePath) {
   const lines = content.split('\n');
   let currentSection = null;
 

package/scripts/flow-standards-checker.js

@@ -1214,6 +1214,75 @@ Examples:
   process.exit(results.blocked ? 1 : 0);
 }
 
+// ============================================================================
+// Non-Negotiable Rules Validation (wf-d0adca72 / A5)
+// ============================================================================
+
+const NON_NEGOTIABLE_FRAGMENT_ID = 'non-negotiable-rules';
+const NON_NEGOTIABLE_FRAGMENT_PATH = '.workflow/prompts/fragments/non-negotiable-rules.md';
+const CITATION_FORMAT_REGEX = /\b[\w./-]+\.(?:js|ts|tsx|jsx|md|json|yaml|yml|py|go|rs|sh):\d+(?:-\d+)?\b/;
+
+/**
+ * Validate that the non-negotiable-rules fragment exists and is loadable.
+ * @returns {{ ok: boolean, reason?: string, path?: string }}
+ */
+function checkNonNegotiableFragment() {
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const full = path.join(process.cwd(), NON_NEGOTIABLE_FRAGMENT_PATH);
+  if (!fs.existsSync(full)) {
+    return { ok: false, reason: `missing fragment: ${NON_NEGOTIABLE_FRAGMENT_PATH}`, path: full };
+  }
+  const content = fs.readFileSync(full, 'utf8');
+  const required = ['Evidence before claim', 'No silent scope changes', 'Route every request', 'filepath:line', 'Destructive operations', 'Do not invent artifacts'];
+  const missing = required.filter((r) => !content.includes(r));
+  if (missing.length > 0) {
+    return { ok: false, reason: `fragment missing required sections: ${missing.join(', ')}`, path: full };
+  }
+  return { ok: true, path: full };
+}
+
+/**
+ * Validate that a composed prompt includes the non-negotiable-rules block.
+ * @param {string} composedPrompt
+ * @returns {{ ok: boolean, reason?: string }}
+ */
+function checkComposedPromptHasNonNegotiables(composedPrompt) {
+  if (!composedPrompt || typeof composedPrompt !== 'string') {
+    return { ok: false, reason: 'composedPrompt must be a non-empty string' };
+  }
+  if (!composedPrompt.includes('Non-Negotiable Rules')) {
+    return { ok: false, reason: 'composed prompt missing "Non-Negotiable Rules" header — fragment not loaded' };
+  }
+  if (!composedPrompt.includes('filepath:line')) {
+    return { ok: false, reason: 'composed prompt missing citation-format rule' };
+  }
+  return { ok: true };
+}
+
+/**
+ * Validate that a text body contains at least one filepath:line citation when it makes claims about code.
+ * Heuristic: if the text references code (function names with parens, paths with slashes, or quoted identifiers),
+ * it should cite at least one location in `path:line` format.
+ * @param {string} text
+ * @param {object} [opts]
+ * @param {boolean} [opts.requireCitation=true]
+ * @returns {{ ok: boolean, reason?: string, hasCitation: boolean }}
+ */
+function checkCitationFormat(text, { requireCitation = true } = {}) {
+  if (!text || typeof text !== 'string') {
+    return { ok: false, reason: 'text must be a non-empty string', hasCitation: false };
+  }
+  const hasCitation = CITATION_FORMAT_REGEX.test(text);
+  if (!requireCitation) return { ok: true, hasCitation };
+  // Make claim-about-code detection lightweight
+  const looksLikeCodeClaim = /\b(function|class|module|import|require|file|path)\b|`[^`]+`/.test(text);
+  if (looksLikeCodeClaim && !hasCitation) {
+    return { ok: false, reason: 'text references code but has no filepath:line citation', hasCitation: false };
+  }
+  return { ok: true, hasCitation };
+}
+
 // ============================================================================
 // Exports
 // ============================================================================
@@ -1221,6 +1290,12 @@ Examples:
 module.exports = {
   runStandardsCheck,
   formatStandardsResults,
+  checkNonNegotiableFragment,
+  checkComposedPromptHasNonNegotiables,
+  checkCitationFormat,
+  NON_NEGOTIABLE_FRAGMENT_ID,
+  NON_NEGOTIABLE_FRAGMENT_PATH,
+  CITATION_FORMAT_REGEX,
   parseDecisions,
   parseAppMap,
   parseFunctionMap,

package/scripts/flow-standards-gate.js

@@ -23,7 +23,7 @@ const {
   runStandardsCheck,
   formatStandardsResults,
   collectReuseCandidates,
-  TASK_CHECK_MAP
+  _TASK_CHECK_MAP
 } = require('./flow-standards-checker');
 
 // Gate telemetry — records every invocation for self-assessment.

package/scripts/flow-statusline-setup.js

@@ -42,6 +42,11 @@ const FORMATS = {
     name: 'Detailed',
     description: 'Full info including skill and worktree',
     format: '{{#if workspace.git_worktree}}[WT] {{/if}}{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}% used{{#if skill}} | {{skill}}{{/if}}'
+  },
+  advanced: {
+    name: 'Advanced',
+    description: 'Detailed + effort level and thinking state (Claude Code 2.1.119+)',
+    format: '{{#if workspace.git_worktree}}[WT] {{/if}}{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}%{{#if effort.level}} | {{effort.level}}{{/if}}{{#if thinking.enabled}} | thinking{{/if}}{{#if skill}} | {{skill}}{{/if}}'
   }
 };
 
@@ -157,7 +162,7 @@ async function interactiveSetup() {
   showCurrentConfig();
   showFormats();
 
-  const format = await question(`\nChoose format (minimal/compact/standard/detailed) [standard]: `);
+  const format = await question(`\nChoose format (minimal/compact/standard/detailed/advanced) [standard]: `);
   const selectedFormat = format.trim() || 'standard';
 
   if (!FORMATS[selectedFormat]) {
@@ -226,6 +231,7 @@ Formats:
   compact   - Task ID + model + context %
   standard  - Task ID + model + labeled context (recommended)
   detailed  - Worktree + task + model + context % + skill
+  advanced  - Detailed + effort level + thinking state (Claude Code 2.1.119+)
 
 Refresh interval (Claude Code 2.1.97+):
   Re-runs the status line every N seconds so live values like task ID,
@@ -281,7 +287,7 @@ Examples:
   if (formatIndex >= 0) {
     const format = args[formatIndex + 1];
     if (!format || !FORMATS[format]) {
-      errorMsg('Invalid format. Use: minimal, compact, standard, or detailed');
+      errorMsg('Invalid format. Use: minimal, compact, standard, detailed, or advanced');
       process.exit(1);
     }
 

package/scripts/flow-step-changelog.js

@@ -26,7 +26,7 @@ const CHANGELOG_PATH = path.join(PATHS.root, 'CHANGELOG.md');
  * @returns {object} - { passed: boolean, message: string, entry?: string }
  */
 async function run(options = {}) {
-  const { taskId, taskTitle, taskType, files = [], mode, stepConfig = {} } = options;
+  const { taskId, taskTitle, taskType, files = [], mode, _stepConfig = {} } = options;
 
   // Determine changelog category
   const category = getChangelogCategory(taskType, taskTitle, files);
@@ -133,7 +133,7 @@ function getChangelogCategory(taskType, taskTitle, _files) {
 /**
  * Generate a changelog entry
  */
-function generateEntry(taskId, taskTitle, _category, files) {
+function generateEntry(taskId, taskTitle, _category, _files) {
   // Clean up title
   let entry = taskTitle || 'Update';
 

package/scripts/flow-step-coverage.js

@@ -31,7 +31,7 @@ const COVERAGE_PATHS = [
  * @returns {object} - { passed: boolean, message: string, coverage?: object }
  */
 async function run(options = {}) {
-  const { files = [], stepConfig = {}, mode } = options;
+  const { files = [], stepConfig = {}, _mode } = options;
   const minCoverage = stepConfig.minCoverage || 80;
   const checkFiles = stepConfig.checkModifiedOnly ?? true;
 

package/scripts/flow-step-knowledge.js

@@ -26,7 +26,7 @@ const KNOWLEDGE_DIR = path.join(PATHS.root, '.claude', 'docs', 'knowledge-base')
  * @returns {object} - { passed: boolean, message: string, suggestion?: string }
  */
 async function run(options = {}) {
-  const { taskId, taskTitle, files = [], mode, stepConfig = {}, learnings } = options;
+  const { _taskId, taskTitle, files = [], mode, _stepConfig = {}, learnings } = options;
 
   // Ensure knowledge base directory exists
   if (!fs.existsSync(KNOWLEDGE_DIR)) {

package/scripts/flow-step-regression.js

@@ -21,7 +21,7 @@ const { PATHS } = require('./flow-utils');
  * @returns {object} - { passed: boolean, message: string, details?: object }
  */
 async function run(options = {}) {
-  const { stepConfig = {}, mode } = options;
+  const { stepConfig = {}, _mode } = options;
   const sampleSize = stepConfig.sampleSize || 3;
 
   try {

package/scripts/flow-step-simplifier.js

@@ -308,7 +308,7 @@ function findDuplicationPatterns(content, fileName) {
   }
 
   // Report lines that appear 3+ times
-  for (const [pattern, lineNumbers] of Object.entries(patterns)) {
+  for (const [_pattern, lineNumbers] of Object.entries(patterns)) {
     if (lineNumbers.length >= 3) {
       suggestions.push({
         file: fileName,

package/scripts/flow-task-analyzer.js

@@ -355,7 +355,7 @@ function determineCapabilities(text, complexity) {
  * @returns {Object} Token estimates
  */
 function estimateTaskTokens(analysis) {
-  const { complexity, domains, languages } = analysis;
+  const { complexity, domains, _languages } = analysis;
 
   const multiplier = TOKEN_FACTORS.COMPLEXITY_MULTIPLIER[complexity.level];
   const baseInput = TOKEN_FACTORS.BASE_INPUT;

package/scripts/flow-task-classifier.js

@@ -176,7 +176,7 @@ function classifyTask(taskDescription, affectedFiles = [], _options = {}) {
     .sort((a, b) => b[1] - a[1]);
 
   const [topType, topScore] = sortedTypes[0];
-  const [secondType, secondScore] = sortedTypes[1] || ['none', 0];
+  const [_secondType, secondScore] = sortedTypes[1] || ['none', 0];
 
   // Calculate confidence
   let confidence = 'high';

package/scripts/flow-task-enforcer.js

@@ -752,7 +752,7 @@ function getLoopStats() {
  */
 function verifyCriterion(criterion, context = {}) {
   const { execSync, execFileSync } = require('node:child_process');
-  const { changedFiles = [], testResults = null, lintResults = null } = context;
+  const { _changedFiles = [], testResults = null, lintResults = null } = context;
   const _config = getConfig();
   const taskConfig = getTaskConfig();
   const desc = criterion.description;

package/scripts/flow-template-extractor.js

@@ -461,7 +461,7 @@ function getIndent(line) {
 async function extractTemplates(projectRoot, options = {}) {
   const {
     types = Object.keys(FILE_TYPES),
-    outputDir = path.join(projectRoot, '.workflow', 'templates', 'extracted')
+    _outputDir = path.join(projectRoot, '.workflow', 'templates', 'extracted')
   } = options;
 
   const startTime = Date.now();

package/scripts/flow-trap-zone.js

@@ -264,7 +264,7 @@ function parseTypeScript(file) {
     /(?:^|\n)\s*(?:export\s+)?(interface|class|type)\s+([A-Z]\w*)\b\s*(?:extends[^{]*|implements[^{]*|<[^>]*>\s*)?(?:=\s*)?(\{)/g;
   let m;
   while ((m = headerRegex.exec(content)) !== null) {
-    const [, kind, name, openBrace] = m;
+    const [, kind, name, _openBrace] = m;
     const bodyStart = m.index + m[0].length;
     const body = extractBalancedBlock(content, bodyStart - 1); // include the opening brace
     if (!body) continue;

package/scripts/flow-utils.js

@@ -262,6 +262,10 @@ function isValidWogiId(id) {
   if (/^wf-rv-[a-f0-9]{8}$/i.test(id)) return true;
   // Epic, feature, plan IDs
   if (/^(ep|ft|pl)-[a-f0-9]{8}$/i.test(id)) return true;
+  // Slug format: wf-<alphanum>[<alphanum or hyphen>]*<alphanum>, 5-64 chars.
+  // For manager-dispatched descriptive IDs. Path-safe (no dots/separators).
+  // Keep this in sync with validateTaskId() 'slug' branch in flow-id.js.
+  if (/^wf-[a-z0-9][a-z0-9-]{0,60}[a-z0-9]$/i.test(id)) return true;
   // Legacy format
   if (/^(TASK|BUG)-\d{3,}$/i.test(id)) return true;
   return false;

package/scripts/flow-worker-mcp-strip.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Worker MCP Strip Helper
+ *
+ * Generates a channel-only MCP config for worker boot. This is the proper
+ * fix for the audit-channel-transport-001 regression: Story A originally
+ * wrote `{"mcpServers":{}}` (fully empty) for boot speed, which silently
+ * stripped the `wogi-workspace-channel` MCP server — leaving manager-side
+ * `workspace_send_message` HTTP-POSTs unable to reach the worker.
+ *
+ * This script reads the worker member-repo's real `.mcp.json`, extracts
+ * ONLY the `wogi-workspace-channel` entry, and writes a channel-only
+ * config to a destination path. Result:
+ *   - claude.ai MCP integrations remain stripped (Story A's boot-speed win)
+ *   - The workspace transport remains active (manager dispatch works)
+ *
+ * Fallback: if the source `.mcp.json` doesn't define
+ * `wogi-workspace-channel` (e.g. the worker isn't a workspace member),
+ * the destination is written with `{"mcpServers":{}}` — harmless in
+ * non-workspace contexts.
+ *
+ * Usage:
+ *   node flow-worker-mcp-strip.js <source-mcp.json> <dest-mcp.json>
+ *
+ * Programmatic:
+ *   const { extractChannelOnlyConfig, writeChannelOnlyConfig } =
+ *     require('./flow-worker-mcp-strip');
+ *   const cfg = extractChannelOnlyConfig(srcPath);
+ *   writeChannelOnlyConfig(destPath, cfg);
+ *
+ * Exit codes:
+ *   0 — success (channel-only or empty config written)
+ *   1 — write failure (caller should fall back to no-strip)
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CHANNEL_SERVER_NAME = 'wogi-workspace-channel';
+
+/**
+ * Read the source `.mcp.json` and return the channel-only config object.
+ * Never throws; returns the empty-config fallback on any failure.
+ */
+function extractChannelOnlyConfig(sourcePath) {
+  const empty = { mcpServers: {} };
+  if (!sourcePath || typeof sourcePath !== 'string') return empty;
+  try {
+    if (!fs.existsSync(sourcePath)) return empty;
+    const raw = fs.readFileSync(sourcePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || !parsed.mcpServers) return empty;
+    const entry = parsed.mcpServers[CHANNEL_SERVER_NAME];
+    if (!entry || typeof entry !== 'object') return empty;
+    return { mcpServers: { [CHANNEL_SERVER_NAME]: entry } };
+  } catch (_err) {
+    return empty;
+  }
+}
+
+/**
+ * Atomically write the channel-only config to destPath. Returns true on
+ * success, false on failure (caller should fall back).
+ */
+function writeChannelOnlyConfig(destPath, config) {
+  if (!destPath || typeof destPath !== 'string') return false;
+  try {
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    const tmp = `${destPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+    fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n');
+    fs.renameSync(tmp, destPath);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * Whether the resulting config preserves the channel transport (i.e. the
+ * worker will be reachable from the manager). Useful for callers that want
+ * to log a warning if dispatch will silently fail.
+ */
+function preservesChannelTransport(config) {
+  return Boolean(
+    config &&
+    config.mcpServers &&
+    config.mcpServers[CHANNEL_SERVER_NAME] &&
+    typeof config.mcpServers[CHANNEL_SERVER_NAME] === 'object'
+  );
+}
+
+module.exports = {
+  CHANNEL_SERVER_NAME,
+  extractChannelOnlyConfig,
+  writeChannelOnlyConfig,
+  preservesChannelTransport
+};
+
+if (require.main === module) {
+  const [src, dest] = process.argv.slice(2);
+  if (!src || !dest) {
+    process.stderr.write('Usage: flow-worker-mcp-strip <source-mcp.json> <dest-mcp.json>\n');
+    process.exit(1);
+  }
+  const cfg = extractChannelOnlyConfig(src);
+  const ok = writeChannelOnlyConfig(dest, cfg);
+  if (!ok) {
+    process.stderr.write(`[flow-worker-mcp-strip] failed to write ${dest}\n`);
+    process.exit(1);
+  }
+  if (!preservesChannelTransport(cfg)) {
+    process.stderr.write(
+      `[flow-worker-mcp-strip] WARNING: ${src} did not define ${CHANNEL_SERVER_NAME} — ` +
+      `worker will boot but manager dispatch will fail. ` +
+      `Run "flow workspace init" in the workspace root to regenerate .mcp.json.\n`
+    );
+  }
+  process.exit(0);
+}