wogiflow 2.18.0 → 2.19.0

package/bin/flow

@@ -218,6 +218,17 @@ function main() {
     return;
   }
 
+  if (command === 'config') {
+    const { configCommand } = require('../lib/commands/config');
+    try {
+      configCommand(args.slice(1));
+    } catch (err) {
+      console.error(`Config error: ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
   // For all other commands, try to find project context
   const projectRoot = findProjectRoot();
 

package/lib/commands/config.js

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * `flow config` — inspect and compact the project's .workflow/config.json.
+ *
+ * Subcommands:
+ *   flow config show          Show the current (on-disk) config as written
+ *   flow config show --full   Show the fully-merged config (defaults + overrides)
+ *   flow config show --diff   Show only the keys this project overrides
+ *   flow config compact       Rewrite config.json to lean form (overrides only)
+ *   flow config compact --dry Preview the compacted form without writing
+ *
+ * Added in v2.19.0 alongside the lean-config-on-init change. See
+ * `lib/installer.js` `buildLeanInstallConfig()` for the write-time counterpart.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function resolveProjectRoot() {
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (fs.existsSync(path.join(dir, '.workflow', 'config.json'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error('Not in a WogiFlow project (no .workflow/config.json found)');
+}
+
+function readProjectConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.workflow', 'config.json');
+  const raw = fs.readFileSync(configPath, 'utf-8');
+  return { configPath, raw, parsed: JSON.parse(raw) };
+}
+
+function configCommand(args) {
+  const sub = args[0];
+  const flags = args.slice(1);
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    printHelp();
+    return;
+  }
+
+  const projectRoot = resolveProjectRoot();
+
+  if (sub === 'show') {
+    return showConfig(projectRoot, flags);
+  }
+
+  if (sub === 'compact') {
+    return compactConfig(projectRoot, flags);
+  }
+
+  console.error(`Unknown config subcommand: ${sub}`);
+  printHelp();
+  process.exit(1);
+}
+
+function showConfig(projectRoot, flags) {
+  const { configPath, parsed } = readProjectConfig(projectRoot);
+  const { mergeWithDefaults, computeLeanConfig } = require('../../scripts/flow-config-defaults');
+
+  if (flags.includes('--full')) {
+    const merged = mergeWithDefaults(parsed);
+    console.log(JSON.stringify(merged, null, 2));
+    return;
+  }
+
+  if (flags.includes('--diff')) {
+    const merged = mergeWithDefaults(parsed);
+    const lean = computeLeanConfig(merged);
+    console.log(JSON.stringify(lean, null, 2));
+    return;
+  }
+
+  // Default: show what's on disk.
+  const relPath = path.relative(projectRoot, configPath);
+  console.log(`# ${relPath} (on disk — ${Object.keys(parsed).length} top-level keys)`);
+  console.log(JSON.stringify(parsed, null, 2));
+  console.log('');
+  console.log('# Tips:');
+  console.log('#   flow config show --full   see the fully-merged config (defaults + overrides)');
+  console.log('#   flow config show --diff   see only the keys this project overrides');
+  console.log('#   flow config compact       shrink this file to overrides-only');
+}
+
+function compactConfig(projectRoot, flags) {
+  const { configPath, parsed } = readProjectConfig(projectRoot);
+  const { mergeWithDefaults, computeLeanConfig } = require('../../scripts/flow-config-defaults');
+
+  // mergeWithDefaults → computeLeanConfig round-trip produces the canonical
+  // lean form. Doing it via merge-first ensures any keys that used to have
+  // non-default values but now match a new default get correctly removed.
+  const merged = mergeWithDefaults(parsed);
+  const lean = computeLeanConfig(merged);
+
+  const beforeBytes = JSON.stringify(parsed, null, 2).length;
+  const afterBytes = JSON.stringify(lean, null, 2).length;
+  const savedPct = beforeBytes > 0 ? Math.round(((beforeBytes - afterBytes) / beforeBytes) * 100) : 0;
+
+  if (flags.includes('--dry') || flags.includes('--dry-run')) {
+    console.log('# Preview — would write:');
+    console.log(JSON.stringify(lean, null, 2));
+    console.log('');
+    console.log(`# Before: ${beforeBytes} bytes, ${Object.keys(parsed).length} top-level keys`);
+    console.log(`# After:  ${afterBytes} bytes, ${Object.keys(lean).length} top-level keys (-${savedPct}%)`);
+    console.log('# Run without --dry to apply.');
+    return;
+  }
+
+  // Backup first — compaction is reversible, but cheap insurance is free.
+  const backupPath = `${configPath}.bak-${Date.now()}`;
+  fs.copyFileSync(configPath, backupPath);
+
+  fs.writeFileSync(configPath, JSON.stringify(lean, null, 2) + '\n');
+
+  console.log(`✓ Compacted ${path.relative(projectRoot, configPath)}`);
+  console.log(`  Before: ${beforeBytes} bytes, ${Object.keys(parsed).length} top-level keys`);
+  console.log(`  After:  ${afterBytes} bytes, ${Object.keys(lean).length} top-level keys (-${savedPct}%)`);
+  console.log(`  Backup: ${path.relative(projectRoot, backupPath)}`);
+  console.log('');
+  console.log('Runtime behavior is unchanged — defaults merge in at read time.');
+  console.log('Verify with: flow config show --full');
+}
+
+function printHelp() {
+  console.log(`Usage: flow config <subcommand> [flags]
+
+Inspect and compact the project's .workflow/config.json.
+
+Subcommands:
+  show                  Show the current config as written on disk
+  show --full           Show the fully-merged config (defaults + overrides)
+  show --diff           Show only the keys this project overrides
+  compact               Rewrite config.json to overrides-only form
+  compact --dry         Preview the compacted form without writing
+
+Why "lean" configs (v2.19.0+):
+  The runtime config loader merges CONFIG_DEFAULTS on every read, so any key
+  matching the default is redundant noise. New installs write lean configs by
+  default. Existing fat configs still work identically — run 'flow config
+  compact' to shrink them.
+`);
+}
+
+module.exports = { configCommand, showConfig, compactConfig, resolveProjectRoot };

package/lib/installer.js

@@ -520,21 +520,37 @@ function createWorkflowStructure(projectRoot, config) {
     }
   }
 
-  // Create config.json using shared defaults with project-specific overrides
+  // Create config.json — LEAN by default (v2.19.0+).
+  // Only project-specific identity keys + any overrides the installer selected
+  // interactively are written. The runtime loader (flow-config-loader.js)
+  // merges CONFIG_DEFAULTS on every read via mergeWithDefaults(), so a lean
+  // file behaves identically to a fully-specified one.
+  //
+  // This replaces the prior behavior of dumping the full ~300-line default
+  // tree on every `flow init`, which was confusing (users thought they had
+  // to maintain all those keys) and brittle (every new default shipped in a
+  // release became stale in every existing project's config file).
   const configPath = path.join(workflowDir, 'config.json');
-  const configContent = getDefaultConfig({
+  const fullConfig = getDefaultConfig({
     version: config.version,
     projectName: config.projectName,
     projectType: config.projectType || 'unknown',
     strictMode: config.strictMode
   });
-  fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
-
-  // Sync .gitignore entries for enabled features
+  const leanConfig = buildLeanInstallConfig(fullConfig, config);
+  fs.writeFileSync(configPath, JSON.stringify(leanConfig, null, 2) + '\n');
+  // To inspect the fully-merged config (defaults + your overrides), run:
+  //   flow config show --full
+  // To compact an existing fat config back to lean form, run:
+  //   flow config compact
+
+  // Sync .gitignore entries for enabled features. Pass the fully-merged
+  // config (not the lean on-disk form) so gitignore can see all enabled
+  // feature flags, including those inherited from defaults.
   try {
     const { syncGitignore } = require('../scripts/flow-gitignore');
-    syncGitignore(configContent);
-  } catch (err) {
+    syncGitignore(fullConfig);
+  } catch (_err) {
     // Non-blocking — gitignore sync should never fail installation
   }
 
@@ -1118,4 +1134,42 @@ function walkDirForManifest(dir, baseDir, fileSet) {
   }
 }
 
-module.exports = { init, getDefaultConfig, deepMerge, detectProjectType, detectProjectScripts, detectTsConfigMode, getRegistriesForProjectType };
+/**
+ * Build the lean config written by `flow init` (v2.19.0+).
+ *
+ * The runtime loader merges CONFIG_DEFAULTS on every read, so we only need to
+ * persist values that (a) identify this project or (b) differ from the default.
+ * We prefer the `computeLeanConfig()` diff over a hand-picked allowlist so any
+ * interactive-install overrides (e.g. strictMode toggled off) are preserved.
+ *
+ * @param {Object} fullConfig - The fully-merged config object from getDefaultConfig()
+ * @param {Object} config - The install-time config selections (projectName, version, etc.)
+ * @returns {Object} Lean config suitable for writing to .workflow/config.json
+ */
+function buildLeanInstallConfig(fullConfig, config) {
+  const { computeLeanConfig } = require('../scripts/flow-config-defaults');
+  const lean = computeLeanConfig(fullConfig);
+
+  // Ensure identity keys are always present with the expected shape.
+  const out = {
+    $schema: './config.schema.json',
+    version: config.version,
+    projectName: config.projectName || '',
+    cli: { type: 'claude-code' },
+    ...lean
+  };
+
+  // Strip identity keys from the lean block so they aren't duplicated.
+  // (The spread above means lean's values would win; we want OURS to win.)
+  return {
+    $schema: out.$schema,
+    version: out.version,
+    projectName: out.projectName,
+    cli: out.cli,
+    ...Object.fromEntries(
+      Object.entries(lean).filter(([k]) => !['$schema', 'version', 'projectName', 'cli'].includes(k))
+    )
+  };
+}
+
+module.exports = { init, getDefaultConfig, deepMerge, detectProjectType, detectProjectScripts, detectTsConfigMode, getRegistriesForProjectType, buildLeanInstallConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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 && 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 && 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

@@ -867,14 +867,16 @@ const CONFIG_DEFAULTS = {
   // detects the restart flag and relaunches claude. See lib/wogi-claude for
   // the wrapper. See scripts/hooks/core/task-boundary-reset.js for the trigger.
   //
-  // REQUIRES verification against real Claude Code before enabling broadly —
-  // the SIGTERM-to-parent pattern must be confirmed to exit Claude Code
-  // gracefully. Keep disabled until integration test in a throwaway session
-  // confirms clean exit + flag consumption + fresh restart.
+  // Per-task context reset via wogi-claude wrapper. Validated in v2.17.0 for
+  // workspace workers (manager sessions deliberately skip restart to avoid
+  // orchestration storms — see resolveClaudeSpawnCommand in lib/workspace.js).
+  // Enabled by default as of v2.19.0 after the "Sautéed worker" UX complaint:
+  // without it, workers sit idle after task completion instead of restarting
+  // fresh and ready for the next dispatch. Users who want the old behavior
+  // can set `enabled: false` explicitly.
   taskBoundaryReset: {
-    _comment: 'Opt-in per-task context reset via wogi-claude wrapper. See lib/wogi-claude.',
-    enabled: false,
-    _comment_enabled: 'Set true ONLY after verifying SIGTERM behavior with real Claude Code in a throwaway session.',
+    _comment: 'Per-task context reset via wogi-claude wrapper. See lib/wogi-claude.',
+    enabled: true,
     maxRestartsPerSession: 50,
     _comment_maxRestartsPerSession: 'Safety cap. The wrapper also has WOGI_MAX_RESTARTS env override.'
   },
@@ -1166,6 +1168,72 @@ function mergeWithDefaults(userConfig) {
   return deepMerge(CONFIG_DEFAULTS, userConfig);
 }
 
+/**
+ * Compute the "lean" form of a config — the minimal object that, when passed
+ * through mergeWithDefaults(), reproduces the input. Removes every key whose
+ * value equals the default. Nested objects are diffed recursively; arrays and
+ * primitives are compared by JSON equality.
+ *
+ * Always preserves these identity keys even if they match defaults:
+ *   - `$schema`, `version`, `projectName`, `cli`, `_configVersion`
+ * These anchor the file's purpose and let tooling (VS Code JSON schema, config
+ * migrations) work correctly on the lean file.
+ *
+ * Round-trip guarantee:
+ *   mergeWithDefaults(computeLeanConfig(full)) deep-equals mergeWithDefaults(full)
+ * for any input — verified in tests.
+ *
+ * @param {Object} fullConfig - A fully-merged config (or any config object)
+ * @returns {Object} Lean config containing only overrides + identity keys
+ */
+function computeLeanConfig(fullConfig) {
+  if (!fullConfig || typeof fullConfig !== 'object') {
+    return {};
+  }
+  const IDENTITY_KEYS = new Set(['$schema', 'version', 'projectName', 'cli', '_configVersion', 'projectType']);
+  return diffAgainstDefaults(fullConfig, CONFIG_DEFAULTS, IDENTITY_KEYS, true);
+}
+
+function diffAgainstDefaults(user, defaults, identityKeys, isRoot) {
+  const out = {};
+  for (const key of Object.keys(user)) {
+    const uVal = user[key];
+    const dVal = defaults ? defaults[key] : undefined;
+
+    // Preserve identity keys at the root regardless of equality.
+    if (isRoot && identityKeys.has(key)) {
+      out[key] = uVal;
+      continue;
+    }
+
+    // Comment fields (prefix _comment) are metadata from the defaults file —
+    // don't propagate into user configs, they bloat without adding meaning.
+    if (typeof key === 'string' && key.startsWith('_comment')) {
+      continue;
+    }
+
+    if (dVal === undefined) {
+      // Key doesn't exist in defaults — it's fully user-defined, keep it.
+      out[key] = uVal;
+      continue;
+    }
+
+    if (isPlainObject(uVal) && isPlainObject(dVal)) {
+      const nested = diffAgainstDefaults(uVal, dVal, identityKeys, false);
+      if (Object.keys(nested).length > 0) {
+        out[key] = nested;
+      }
+      continue;
+    }
+
+    // Primitive / array / null comparison via JSON stringify.
+    if (JSON.stringify(uVal) !== JSON.stringify(dVal)) {
+      out[key] = uVal;
+    }
+  }
+  return out;
+}
+
 /**
  * Apply project-type-aware defaults to a config.
  * Strips/disables irrelevant sections based on detected project type.
@@ -1249,5 +1317,6 @@ module.exports = {
   isPlainObject,
   getDefaultsForKey,
   mergeWithDefaults,
+  computeLeanConfig,
   applyProjectTypeDefaults
 };

package/scripts/hooks/core/task-gate.js

@@ -418,19 +418,104 @@ function generateWarningMessage(operation, filePath) {
   return `Warning: ${operation === 'write' ? 'Creating' : 'Editing'} ${fileName} without an active task. Consider starting a task first.`;
 }
 
+// Rule / memory files where /wogi-decide is the idiomatic capture command.
+// Intent artifacts (domain-model.md, user-journeys.md, glossary.md, product.md)
+// are deliberately excluded — modifying those is product-design work and should
+// flow through /wogi-story per the normal task lifecycle.
+const RULE_FILE_BASENAMES = new Set([
+  'decisions.md',
+  'feedback-patterns.md',
+  'MEMORY.md'
+]);
+
+/**
+ * Detect whether the given file path (or its basename) is a rule/memory file
+ * that should route to /wogi-decide for capture instead of /wogi-story.
+ *
+ * Also matches Claude Code auto-memory paths under `.claude/projects/*\/memory/`.
+ */
+function isRuleOrMemoryFile(filePath) {
+  if (!filePath || typeof filePath !== 'string') return false;
+  const base = path.basename(filePath);
+  if (RULE_FILE_BASENAMES.has(base)) return true;
+  if (filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`) &&
+      filePath.includes(`${path.sep}memory${path.sep}`)) return true;
+  return false;
+}
+
+/**
+ * Detect whether the current working directory (or its parents) contains a
+ * `.workspace/` directory — the marker for WogiFlow workspace mode where a
+ * manager repo coordinates worker repos. When present, the block message
+ * additionally suggests the workspace-coordination task pattern.
+ *
+ * Walks up at most 6 parents to avoid unbounded traversal.
+ */
+function isInWorkspaceMode(startDir) {
+  const start = startDir || process.cwd();
+  try {
+    let dir = start;
+    for (let i = 0; i < 6; i++) {
+      const candidate = path.join(dir, '.workspace');
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+        return true;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch (_err) {
+    // Filesystem errors (permissions, etc.) → conservatively say no. The
+    // standard suggestions are still shown, so the user is never stranded.
+  }
+  return false;
+}
+
 /**
- * Generate block message
+ * Generate block message (context-aware).
+ *
+ * The message adapts to two signals:
+ *  1. If the blocked path is a rule/memory file (e.g. decisions.md), the
+ *     message leads with `/wogi-decide` — the idiomatic "from now on" rule
+ *     capture command that doesn't require a code task.
+ *  2. If a `.workspace/` directory exists at cwd or a parent, the message
+ *     adds a workspace-coordination task pattern.
+ *
+ * Enforcement behavior is unchanged — this only affects the text shown to
+ * the AI / user when the gate blocks. Intent artifacts (domain-model.md,
+ * user-journeys.md, glossary.md, product.md) deliberately do NOT trigger
+ * the rule-file branch — those still route to /wogi-story.
  */
 function generateBlockMessage(operation, filePath) {
   const fileName = filePath ? path.basename(filePath) : 'file';
-  return `Cannot ${operation} ${fileName} without an active task.
+  const isRuleFile = isRuleOrMemoryFile(filePath);
+  const inWorkspace = isInWorkspaceMode();
+
+  const lines = [`Cannot ${operation} ${fileName} without an active task.`, ''];
 
-To proceed:
-1. Check available tasks: /wogi-ready
-2. Start an existing task: /wogi-start wf-XXXXXXXX
-3. Or create a new task: /wogi-story "description"
+  if (isRuleFile) {
+    lines.push('For rule / memory capture without a code task:');
+    lines.push('  /wogi-decide "from now on, <your rule>"');
+    lines.push('');
+  }
+
+  if (inWorkspace) {
+    lines.push('For workspace coordination (manager repo in workspace mode):');
+    lines.push('  /wogi-start "coordinate wf-XXXXXXXX in workspace"');
+    lines.push('');
+  }
 
-Task gating is enforced when strictMode is enabled.`;
+  lines.push('For a side thought or idea to save for later:');
+  lines.push('  /wogi-capture "your idea"');
+  lines.push('');
+  lines.push('Other options:');
+  lines.push('  /wogi-ready                 → see available tasks');
+  lines.push('  /wogi-start wf-XXXXXXXX     → start an existing task');
+  lines.push('  /wogi-story "description"   → create a new task');
+  lines.push('');
+  lines.push('Task gating is enforced when strictMode is enabled.');
+
+  return lines.join('\n');
 }
 
 module.exports = {