create-harness-vibe-coding 0.8.17 → 0.8.19

package/templates/common/Harness/scripts/wf-remove.mjs

@@ -83,6 +83,7 @@ const PURGEABLE_HARNESS_DATA_PATTERNS = [
 const FRAMEWORK_TASK_PATTERNS = [
   /^Harness\/tasks\/_template\//,
   /^Harness\/tasks\/auto\//,
+  /^Harness\/tasks\/continuous\//,
 ];
 
 function isUserData(file) {
@@ -141,12 +142,36 @@ const BUILT_IN_SKILL_NAMES = [
   'wf-auto',
   'wf-auto-spark',
   'wf-browser',
+  'wf-command-create',
   'wf-help',
   'wf-learn',
   'wf-max',
   'wf-readme',
   'wf-remove',
   'wf-review',
+  'wf-task-archive',
+  'wf-task-list',
+  'wf-task-record',
+  'wf-ui',
+  'wf-update',
+];
+
+const BUILT_IN_COMMAND_NAMES = [
+  'wf',
+  'wf-auto',
+  'wf-auto-spark',
+  'wf-browser',
+  'wf-command-create',
+  'wf-help',
+  'wf-learn',
+  'wf-max',
+  'wf-readme',
+  'wf-remove',
+  'wf-review',
+  'wf-task-archive',
+  'wf-task-list',
+  'wf-task-record',
+  'wf-ui',
   'wf-update',
 ];
 
@@ -159,8 +184,10 @@ const KNOWN_FRAMEWORK_FILES = new Set([
     `.claude/skills/${name}/SKILL.md`,
     `.agents/skills/${name}/SKILL.md`,
   ]),
-  '.claude/commands/wf-help.md',
-  '.opencode/commands/wf-help.md',
+  ...BUILT_IN_COMMAND_NAMES.flatMap(name => [
+    `.claude/commands/${name}.md`,
+    `.opencode/commands/${name}.md`,
+  ]),
   '.claude/rules/ecc/common.md',
   'opencode.json',
 ]);
@@ -177,6 +204,7 @@ const CLEANUP_DIRS = [
   '.claude/skills/wf-auto',
   '.claude/skills/wf-auto-spark',
   '.claude/skills/wf-browser',
+  '.claude/skills/wf-command-create',
   '.claude/skills/wf-help',
   '.claude/skills/tdd',
   '.claude/skills/ts-react-frontend',
@@ -187,7 +215,11 @@ const CLEANUP_DIRS = [
   '.claude/skills/wf-max',
   '.claude/skills/wf-readme',
   '.claude/skills/wf-review',
+  '.claude/skills/wf-task-archive',
+  '.claude/skills/wf-task-list',
+  '.claude/skills/wf-task-record',
   '.claude/skills/wf-update',
+  '.claude/skills/wf-ui',
   '.claude/skills/wf-remove',
   '.claude/skills/subagent-orchestrator',
   '.claude/skills',
@@ -196,6 +228,7 @@ const CLEANUP_DIRS = [
   '.agents/skills/wf-auto',
   '.agents/skills/wf-auto-spark',
   '.agents/skills/wf-browser',
+  '.agents/skills/wf-command-create',
   '.agents/skills/wf-help',
   '.agents/skills/tdd',
   '.agents/skills/ts-react-frontend',
@@ -206,7 +239,11 @@ const CLEANUP_DIRS = [
   '.agents/skills/wf-max',
   '.agents/skills/wf-readme',
   '.agents/skills/wf-review',
+  '.agents/skills/wf-task-archive',
+  '.agents/skills/wf-task-list',
+  '.agents/skills/wf-task-record',
   '.agents/skills/wf-update',
+  '.agents/skills/wf-ui',
   '.agents/skills/wf-remove',
   '.agents/skills/subagent-orchestrator',
   '.agents/skills',
@@ -231,7 +268,7 @@ const CLEANUP_DIRS = [
   'Harness/features',
   'Harness/memory',
   'Harness/tasks/_template',
-  'Harness/tasks/auto',
+  'Harness/tasks/continuous',
   'Harness/tasks',
   'Harness',
 ];
@@ -402,8 +439,8 @@ async function main() {
     '.claude/skills/wf-auto/SKILL.md',
     '.agents/skills/wf-auto/SKILL.md',
     'Harness/specs/workflows/WF-AUTO.md',
-    'Harness/tasks/auto/PROGRESS.md',
-    'Harness/tasks/auto/PLAN.md',
+    'Harness/tasks/continuous/PROGRESS.md',
+    'Harness/tasks/continuous/PLAN.md',
     'Harness/tasks/_template/ARTIFACTS.md',
     'Harness/tasks/_template/NOTES.md',
     'Harness/tasks/_template/PLAN.md',

package/templates/common/Harness/scripts/wf-update-check.mjs

@@ -541,6 +541,10 @@ async function main() {
   const acceptMerged = readRepeatedFlagValues(args, '--accept-merged');
   const acceptTemplate = readRepeatedFlagValues(args, '--accept-template');
   const ignoreVersion = args.includes('--ignore-version') || args.includes('--force-check');
+  const repairMode = args.includes('--repair');
+  const effectiveIgnoreVersion = ignoreVersion || repairMode;
+  const allowDowngrade = args.includes('--allow-downgrade');
+  const allowPrerelease = args.includes('--include-prerelease');
   const explicitSource = readFlagValue(args, '--source-base') || process.env.WF_SOURCE_BASE;
   let source;
   let sourceBase;
@@ -632,7 +636,7 @@ async function main() {
   const localGen = localVersion.generator || '0.0.0';
   const remoteGen = remoteVersion.generator || '0.0.0';
 
-  if (!ignoreVersion && isPrerelease(remoteGen)) {
+  if (!allowPrerelease && isPrerelease(remoteGen)) {
     if (jsonOut) {
       console.log(JSON.stringify({ status: 'up-to-date', version: localGen, remote: remoteGen, sourceBase }));
     } else {
@@ -642,27 +646,41 @@ async function main() {
   }
 
   const versionCmp = cmpSemver(remoteGen, localGen);
+  const reportDowngrade = !sourceStable;
 
-  if (!ignoreVersion && versionCmp <= 0) {
-    const reportDowngrade = !sourceStable;
+  if (versionCmp < 0 && !allowDowngrade) {
     if (jsonOut) {
       console.log(JSON.stringify({
-        status: (versionCmp < 0 && reportDowngrade) ? 'downgrade-refused' : 'up-to-date',
+        status: reportDowngrade ? 'downgrade-refused' : 'up-to-date',
         version: localGen,
         remote: remoteGen,
         sourceBase,
       }));
-    } else if (versionCmp < 0 && reportDowngrade) {
+    } else if (reportDowngrade) {
       console.log(`WARN: Remote (v${remoteGen}) is OLDER than local (v${localGen}). Downgrade refused.`);
+    } else {
+      console.log(`Already up to date (v${localGen}). Remote ${remoteGen} is older and ignored.`);
+    }
+    if (reportDowngrade) process.exitCode = 1;
+    return;
+  }
+
+  if (!effectiveIgnoreVersion && versionCmp <= 0) {
+    if (jsonOut) {
+      console.log(JSON.stringify({
+        status: 'up-to-date',
+        version: localGen,
+        remote: remoteGen,
+        sourceBase,
+      }));
     } else {
       console.log(`Already up to date (v${localGen})`);
     }
-    if (versionCmp < 0 && reportDowngrade) process.exitCode = 1;
     return;
   }
 
-  if (ignoreVersion) {
-    if (!jsonOut) console.log('Version check bypassed (--ignore-version). Comparing files anyway.');
+  if (effectiveIgnoreVersion) {
+    if (!jsonOut) console.log(`Version check bypassed (${repairMode ? '--repair' : '--ignore-version'}). Comparing files anyway.`);
   }
 
   const remoteChecksums = remoteVersion.checksums || {};
@@ -760,6 +778,9 @@ async function main() {
       : 0;
     return {
       mode: 'script-first-ai-conflicts',
+      multiScopeDryRunCommand: 'node Harness/scripts/wf-update-runner.mjs --json',
+      multiScopeSafeApplyCommand: 'node Harness/scripts/wf-update-runner.mjs --apply-safe --json',
+      multiScopeFinalizeCommand: 'node Harness/scripts/wf-update-runner.mjs --finalize --json',
       dryRunJsonCommand: 'node Harness/scripts/wf-update-check.mjs --json',
       safeApplyCommand: 'node Harness/scripts/wf-update-check.mjs --apply-safe',
       strictApplyCommand: 'node Harness/scripts/wf-update-check.mjs --apply',
@@ -776,7 +797,10 @@ async function main() {
       aiMergeRequiredTruncated: truncated > 0 ? truncated : undefined,
       conflictPolicy: 'Use the script for SAFE/NEW/adopted files. For each CONFLICT file, compare local content with templateHint/remoteUrl, then record the decision with --accept-local, --accept-merged, or --accept-template. Do not hand-edit Harness/.harness-version.',
       postUpdateCommands: [
+        'node Harness/scripts/sync-host-global.mjs --json',
+        'node Harness/scripts/sync-host-global.mjs --apply --json',
         'node Harness/scripts/validate-harness.mjs',
+        'node Harness/scripts/validate-harness.mjs --manifest-audit',
         'node Harness/scripts/scan-clean.mjs --json',
       ],
       bootstrapDebtCommand: 'node Harness/scripts/validate-harness.mjs --strict',
@@ -1010,8 +1034,11 @@ async function main() {
   if (jsonOut) {
     const verbose = args.includes('--verbose') || args.includes('--full-plan');
     const jsonPlan = buildJsonPlan();
+    const effectiveStatus = repairMode && versionCmp <= 0 && !localVersion.partialUpdate
+      ? 'repair-check'
+      : (localVersion.partialUpdate ? 'partial-update' : 'update-available');
     console.log(JSON.stringify({
-      status: localVersion.partialUpdate ? 'partial-update' : 'update-available',
+      status: effectiveStatus,
       from: localGen,
       to: remoteGen,
       sourceBase,
@@ -1026,6 +1053,7 @@ async function main() {
       skipped: plan.skipped.length,
       // Token-safe by default: attach the full plan only when --verbose / --full-plan is passed.
       ...(verbose ? { plan: jsonPlan } : {}),
+      repair: repairMode || undefined,
       agent: buildAgentHints(jsonPlan),
     }, null, 2));
     return;

package/templates/common/Harness/scripts/wf-update-runner.mjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT_ROOT = path.resolve(__dirname, '..', '..');
+const rawArgs = process.argv.slice(2);
+const JSON_OUT = rawArgs.includes('--json');
+
+function readFlagValue(args, flagName) {
+  const idx = args.indexOf(flagName);
+  if (idx === -1) return null;
+  const value = args[idx + 1];
+  return value && !value.startsWith('--') ? value : null;
+}
+
+function stripFlagWithValue(args, flagName) {
+  const next = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === flagName) {
+      i += 1;
+      continue;
+    }
+    if (args[i].startsWith(`${flagName}=`)) continue;
+    next.push(args[i]);
+  }
+  return next;
+}
+
+function normalizePath(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function comparablePath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function samePath(a, b) {
+  if (!a || !b) return false;
+  return comparablePath(a) === comparablePath(b);
+}
+
+function parseSemver(value) {
+  if (!value || typeof value !== 'string') return [0, 0, 0];
+  return value.replace(/^[^0-9]*/, '').split('.').slice(0, 3).map(part => Number(part) || 0);
+}
+
+function cmpSemver(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  for (let i = 0; i < 3; i += 1) {
+    if ((left[i] || 0) > (right[i] || 0)) return 1;
+    if ((left[i] || 0) < (right[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function shouldAutoRepair(firstJson, targetVersion) {
+  if (firstJson?.status !== 'up-to-date') return false;
+  const remote = firstJson.remote || firstJson.to || null;
+  if (remote && targetVersion && cmpSemver(remote, targetVersion) < 0) return false;
+  return true;
+}
+
+function defaultGlobalDir() {
+  return process.env.HARNESS_GLOBAL_HOME
+    || path.join(os.homedir(), '.harness', 'create-harness-vibe-coding');
+}
+
+function versionPath(root) {
+  return path.join(root, 'Harness', '.harness-version');
+}
+
+function updateScriptPath(root) {
+  return path.join(root, 'Harness', 'scripts', 'wf-update-check.mjs');
+}
+
+function syncScriptPath(root) {
+  return path.join(root, 'Harness', 'scripts', 'sync-host-global.mjs');
+}
+
+function validateScriptPath(root) {
+  return path.join(root, 'Harness', 'scripts', 'validate-harness.mjs');
+}
+
+function scanCleanScriptPath(root) {
+  return path.join(root, 'Harness', 'scripts', 'scan-clean.mjs');
+}
+
+function readVersion(root) {
+  try {
+    const file = versionPath(root);
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function hasRunnableUpdater(root) {
+  return fs.existsSync(versionPath(root)) && fs.existsSync(updateScriptPath(root));
+}
+
+function discoverGlobalRuntime(projectVersion) {
+  const candidates = [];
+  if (projectVersion?.globalDir) candidates.push(projectVersion.globalDir);
+  if (process.env.HARNESS_GLOBAL_HOME) candidates.push(process.env.HARNESS_GLOBAL_HOME);
+  candidates.push(defaultGlobalDir());
+  const scriptVersion = readVersion(SCRIPT_ROOT);
+  if (scriptVersion?.installScope === 'global') candidates.push(SCRIPT_ROOT);
+
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const resolved = path.resolve(candidate);
+    if (hasRunnableUpdater(resolved)) return resolved;
+  }
+  return null;
+}
+
+function dedupeTargets(targets) {
+  const seen = new Set();
+  const result = [];
+  for (const target of targets) {
+    const key = comparablePath(target.root);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(target);
+  }
+  return result;
+}
+
+function discoverTargets(projectRoot) {
+  const targets = [];
+  const projectVersion = readVersion(projectRoot);
+  const projectHasUpdater = hasRunnableUpdater(projectRoot);
+  const globalRoot = discoverGlobalRuntime(projectVersion);
+
+  if (projectHasUpdater && !samePath(projectRoot, globalRoot)) {
+    targets.push({
+      scope: projectVersion?.installScope === 'global' && projectVersion?.globalDir ? 'project-bridge' : 'project',
+      root: projectRoot,
+      version: projectVersion?.generator || null,
+    });
+  }
+
+  if (globalRoot) {
+    const globalVersion = readVersion(globalRoot);
+    targets.push({
+      scope: 'global',
+      root: globalRoot,
+      version: globalVersion?.generator || null,
+    });
+  }
+
+  return dedupeTargets(targets);
+}
+
+function runNode(root, scriptPath, args, { parseJson = false } = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    env: process.env,
+  });
+  const stdout = result.stdout || '';
+  const stderr = result.stderr || '';
+  let json = null;
+  if (parseJson && stdout.trim()) {
+    try {
+      json = JSON.parse(stdout.trim());
+    } catch {
+      json = { rawOutput: stdout };
+    }
+  }
+  return {
+    status: result.status ?? 1,
+    stdout,
+    stderr,
+    ...(parseJson ? { json } : {}),
+  };
+}
+
+function wantsApply(args) {
+  return args.includes('--apply') || args.includes('--apply-safe') || args.includes('--safe-only') || args.includes('--finalize');
+}
+
+function wantsRepair(args) {
+  return args.includes('--repair') || args.includes('--ignore-version') || args.includes('--force-check');
+}
+
+function ensureJsonArg(args) {
+  return args.includes('--json') ? args : [...args, '--json'];
+}
+
+function withRepair(args) {
+  return wantsRepair(args) ? args : [...args, '--repair'];
+}
+
+function runUpdateForTarget(target, forwardArgs) {
+  const parseJson = forwardArgs.includes('--json');
+  const script = updateScriptPath(target.root);
+  const first = runNode(target.root, script, forwardArgs, { parseJson });
+  const runs = [{ command: `node Harness/scripts/wf-update-check.mjs ${forwardArgs.join(' ')}`.trim(), ...first }];
+  let effective = first;
+
+  if (
+    parseJson
+    && first.status === 0
+    && shouldAutoRepair(first.json, target.version)
+    && !wantsRepair(forwardArgs)
+  ) {
+    const repairArgs = withRepair(forwardArgs);
+    const repair = runNode(target.root, script, repairArgs, { parseJson });
+    runs.push({ command: `node Harness/scripts/wf-update-check.mjs ${repairArgs.join(' ')}`.trim(), ...repair });
+    effective = repair;
+  }
+
+  return { ...target, update: effective, runs };
+}
+
+function runPostUpdate(target, forwardArgs) {
+  const post = [];
+  const apply = wantsApply(forwardArgs);
+  const syncScript = syncScriptPath(target.root);
+  if (target.scope === 'global' && fs.existsSync(syncScript)) {
+    const syncArgs = apply ? ['--apply', '--json'] : ['--json'];
+    post.push({
+      step: 'sync-host-global',
+      ...runNode(target.root, syncScript, syncArgs, { parseJson: true }),
+    });
+  }
+  if (apply && fs.existsSync(validateScriptPath(target.root))) {
+    post.push({
+      step: 'validate',
+      ...runNode(target.root, validateScriptPath(target.root), [], { parseJson: false }),
+    });
+    post.push({
+      step: 'manifest-audit',
+      ...runNode(target.root, validateScriptPath(target.root), ['--manifest-audit'], { parseJson: false }),
+    });
+  }
+  if (apply && target.scope !== 'global' && fs.existsSync(scanCleanScriptPath(target.root))) {
+    post.push({
+      step: 'scan-clean',
+      ...runNode(target.root, scanCleanScriptPath(target.root), ['--json'], { parseJson: true }),
+    });
+  }
+  return post;
+}
+
+function printText(result) {
+  if (!result.targets.length) {
+    console.error(result.message);
+    return;
+  }
+  for (const target of result.targets) {
+    console.log(`\n[${target.scope}] ${target.root}`);
+    for (const run of target.runs || []) {
+      if (run.stdout) process.stdout.write(run.stdout);
+      if (run.stderr) process.stderr.write(run.stderr);
+    }
+    for (const post of target.post || []) {
+      console.log(`[post:${post.step}] exit ${post.status}`);
+      if (post.stdout) process.stdout.write(post.stdout);
+      if (post.stderr) process.stderr.write(post.stderr);
+    }
+  }
+}
+
+function main() {
+  const projectRoot = path.resolve(readFlagValue(rawArgs, '--project') || process.cwd());
+  const forwardArgs = stripFlagWithValue(rawArgs, '--project');
+  const effectiveArgs = JSON_OUT ? ensureJsonArg(forwardArgs) : forwardArgs;
+  const targets = discoverTargets(projectRoot);
+
+  if (targets.length === 0) {
+    const result = {
+      success: false,
+      status: 'no-harness-target',
+      projectRoot: normalizePath(projectRoot),
+      message: 'No project Harness updater or global Harness runtime was found. No project files were modified.',
+      targets: [],
+    };
+    if (JSON_OUT) console.log(JSON.stringify(result, null, 2));
+    else printText(result);
+    process.exitCode = 1;
+    return;
+  }
+
+  const updatedTargets = targets.map(target => {
+    const withUpdate = runUpdateForTarget(target, effectiveArgs);
+    return {
+      ...withUpdate,
+      post: runPostUpdate(withUpdate, effectiveArgs),
+    };
+  });
+
+  const failures = [];
+  for (const target of updatedTargets) {
+    if (target.update.status !== 0) failures.push(`${target.scope}: update exit ${target.update.status}`);
+    for (const post of target.post || []) {
+      if (post.status !== 0) failures.push(`${target.scope}: ${post.step} exit ${post.status}`);
+    }
+  }
+
+  const result = {
+    success: failures.length === 0,
+    status: failures.length === 0 ? 'ok' : 'failed',
+    projectRoot: normalizePath(projectRoot),
+    targets: updatedTargets.map(target => ({
+      ...target,
+      root: normalizePath(target.root),
+    })),
+    ...(failures.length ? { failures } : {}),
+  };
+
+  if (JSON_OUT) console.log(JSON.stringify(result, null, 2));
+  else printText(result);
+  if (failures.length) process.exitCode = 1;
+}
+
+main();

package/templates/common/Harness/settings.json

@@ -39,5 +39,40 @@
       "claimMinReadRatioPercent": 95,
       "claimMinUpliftPoints": 2
     }
+  },
+  "server": {
+    "host": "127.0.0.1",
+    "port": 0
+  },
+  "terminal": {
+    "enabled": false,
+    "attachMode": false,
+    "defaultRuntime": "codex"
+  },
+  "peers": {
+    "allowlist": [
+      "claude",
+      "cc",
+      "codex",
+      "opencode",
+      "gemini",
+      "qwen",
+      "deepseek",
+      "pi",
+      "aider",
+      "goose",
+      "amp",
+      "crush",
+      "cline",
+      "plandex",
+      "openclaw",
+      "chatgpt",
+      "openai"
+    ]
+  },
+  "ui": {
+    "theme": "auto",
+    "language": "zh",
+    "reducedMotion": false
   }
 }

package/templates/common/Harness/specs/guides/SETUP.md

@@ -55,6 +55,14 @@ Claude or Codex must follow this order during bootstrap. This sequence is broade
 
 Before writing, identify the project state:
 
+Choose the install scope before scaffold writes:
+
+- `--install-scope project` (default): full Harness scaffold is project-local.
+- `--install-scope global`: write shared runtime assets to the selected global Harness directory and copy Claude Code, Codex, and OpenCode command/skill surfaces to host-global directories while keeping `Harness/tasks/`, `Harness/PROGRESS.md`, project memory, research, architecture, and project settings under the target project.
+- Use `--global-dir <dir>` when the global runtime location must be explicit.
+- Use `--host-global-dir <dir>` only when the host-global copy base must be explicit; the installer creates `claude/`, `codex/`, and `opencode/` subdirectories under it.
+- Project settings in `Harness/settings.json` override global settings defaults. Existing user-authored files at config, command, skill, or agent paths are preserved or surfaced for review unless they carry a Harness ownership marker.
+
 | Project state | Required action |
 | --- | --- |
 | Empty or new project | Run the scaffold, then follow this file for 0-1 bootstrap |

package/templates/common/Harness/specs/protocols/MEMORY_PROTOCOL.md

@@ -10,6 +10,21 @@ Memory is downstream of evidence. It records reusable patterns, not raw transcri
 - **L2 = Startup Digest**: `Harness/memory/startup-hints.md`. Lightweight hints loaded at session start. Not a replacement for full router.
 - **L3 = Detailed Durable Memory**: `Harness/memory/*.md` files. Loaded only when scenario matches via `routes.md`.
 
+## Project/Global Memory Boundary
+
+- `Harness/tasks/` and `Harness/PROGRESS.md` are always project-local, even when the Harness runtime is installed globally.
+- Project memory lives in `Harness/memory/` and records repo-specific lessons, preferences, and tool patterns.
+- Global memory may live under the selected global Harness directory for cross-project lessons and preferences.
+- Global memory must never store project task state, secrets, raw transcripts, or private project facts.
+
+## Project/Global Settings Boundary
+
+- Project settings live in `Harness/settings.json` and override global settings.
+- Global settings defaults live in the selected global Harness runtime under `Harness/settings.json`.
+- Host-global settings are copied, not symlinked, into Claude Code, Codex, and OpenCode user config directories.
+- Settings and memory must never store secrets; use external secret stores or environment variables.
+- Existing user-authored config, command, skill, or agent files are user-owned unless they carry a Harness ownership marker.
+
 ## When To Write Memory
 
 Write memory when any condition applies:

package/templates/common/Harness/specs/protocols/TASK_ARCHIVE.md

@@ -11,7 +11,7 @@ Archived tasks move to `Harness/tasks/_archive/YYYY/<task-id>/`.
 ## What Is Never Archived
 
 - `Harness/tasks/_template/` - scaffold template, never moved.
-- `Harness/tasks/auto/` - WF-AUTO permanent state capsule, never moved unless
+- `Harness/tasks/continuous/` - WF-AUTO/WF-AUTO-SPARK permanent state capsule, never moved unless
   explicitly allowed by WF-AUTO docs.
 - `Harness/tasks/_archive/` - the archive directory itself.
 - Active, blocked, in-progress, running, pending, or needs-user-decision tasks.
@@ -46,21 +46,32 @@ machine state.
 - Do NOT delete historical evidence.
 - `Harness/PROGRESS.md` keeps the last 5 non-archived task entries in the Task
   Index.
-- When outer task capsules exceed 5 completed/abandoned/obsolete tasks, archive
-  the oldest safe tasks.
+- When outer task capsules exceed 5 completed/abandoned/obsolete tasks, remind
+  the user to run the task archive command. Do not auto-archive during unrelated
+  validation or closeout unless the user explicitly invokes archive apply mode.
 - The validator (`Harness/scripts/validate-harness.mjs`) warns when
   `Harness/tasks/` holds more than 5 outer task capsules (excluding `_archive`,
   `_template`, `auto`) and fails in `--strict` mode.
 
 ## Script
 
-Use `Harness/scripts/task-state.mjs archive`:
+User-facing command:
 
-- Default: dry-run.
+- Codex: `$wf-task-archive` or `/skills wf-task-archive`.
+- Claude Code/OpenCode: `/wf-task-archive`.
+
+Underlying implementation: `Harness/scripts/task-state.mjs archive`.
+
+- Default: dry-run (respects `--keep` cap, archives oldest-eligible up to cap).
 - `--apply` to execute.
+- Explicit `--apply` with no `--task` filter: archives **ALL** eligible tasks, bypassing `--keep`.
 - `--keep 5` to set the non-archived task threshold.
 - `--task <task-id>` to archive a specific task.
 - `--json` for machine-readable output.
+- After archiving, `Harness/tasks/_archive/INDEX.md` is regenerated with a full
+  task graph: roots, dependency chains, blocks relationships, and per-task details
+  (status, phase, goal, depends-on, blocks). The graph covers **all** archived tasks
+  across all years, so it stays accurate as tasks accumulate.
 - Run `node Harness/scripts/task-state.mjs archive --dry-run --json` before
   applying a risky cleanup.