create-harness-vibe-coding 0.8.18 → 0.8.19

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/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.
@@ -62,11 +62,16 @@ User-facing command:
 
 Underlying implementation: `Harness/scripts/task-state.mjs archive`.
 
-- Default: dry-run.
+- 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.
 

package/templates/common/Harness/specs/runtime/command-surface.json

@@ -210,6 +210,20 @@
         "codexSkill": true,
         "helpRow": true
       }
+    },
+    {
+      "id": "wf-ui",
+      "classification": "direct",
+      "aliases": ["/wf-ui", "$wf-ui", "/skills wf-ui"],
+      "entersWf": false,
+      "taskCapsulePolicy": "none",
+      "surfaces": {
+        "claudeCommand": true,
+        "opencodeCommand": true,
+        "claudeSkill": true,
+        "codexSkill": true,
+        "helpRow": true
+      }
     }
   ]
 }

package/templates/common/Harness/specs/workflows/WF-AUTO-SPARK.md

@@ -28,7 +28,7 @@ For task-state writes, CEO provides concise bullets and decisions; task-scribe f
 
 ## Startup: Roadmap Declaration
 
-Before first spark cycle, CEO MUST declare a roadmap. This is written to `Harness/tasks/auto/SPARK-ROADMAP.md`.
+Before first spark cycle, CEO MUST declare a roadmap. This is written to `Harness/tasks/continuous/SPARK-ROADMAP.md`.
 
 ### Roadmap Format
 
@@ -239,15 +239,15 @@ Re-Anchor Gate (every preset interval)
 
 ## Task Capsule & Recording
 
-WF-AUTO-SPARK uses a dedicated task capsule at `Harness/tasks/auto/`. Shared with `/wf-auto` — same capsule, different operational mode.
+WF-AUTO-SPARK uses a dedicated task capsule at `Harness/tasks/continuous/`. Shared with `/wf-auto` — same capsule, different operational mode.
 
 ### Capsule Structure
 
 | File | Purpose | Updated |
 |------|---------|---------|
-| `Harness/tasks/auto/SPARK-ROADMAP.md` | North Star + milestones + deviation log | At startup + every milestone change |
-| `Harness/tasks/auto/PLAN.md` | Current cycle's change spec (write set, acceptance criteria) | Before each implementation |
-| `Harness/tasks/auto/PROGRESS.md` | Cycle log, value reflections, cumulative stats, evidence | After each cycle |
+| `Harness/tasks/continuous/SPARK-ROADMAP.md` | North Star + milestones + deviation log | At startup + every milestone change |
+| `Harness/tasks/continuous/PLAN.md` | Current cycle's change spec (write set, acceptance criteria) | Before each implementation |
+| `Harness/tasks/continuous/PROGRESS.md` | Cycle log, value reflections, cumulative stats, evidence | After each cycle |
 | `Harness/PROGRESS.md` | Global task index — active spark session status | At session start, milestone, and stop |
 
 ### Heartbeat Protocol (per cycle, in `PROGRESS.md`)
@@ -314,9 +314,9 @@ This replaces the broken `/wf-auto` auto-continue. No silent drift across sessio
 | File | Purpose |
 |------|---------|
 | `Harness/specs/workflows/WF-AUTO-SPARK.md` | This spec |
-| `Harness/tasks/auto/SPARK-ROADMAP.md` | Active roadmap (created at startup) |
-| `Harness/tasks/auto/PLAN.md` | Per-cycle change spec |
-| `Harness/tasks/auto/PROGRESS.md` | Cycle log, heartbeat, evidence ledger |
+| `Harness/tasks/continuous/SPARK-ROADMAP.md` | Active roadmap (created at startup) |
+| `Harness/tasks/continuous/PLAN.md` | Per-cycle change spec |
+| `Harness/tasks/continuous/PROGRESS.md` | Cycle log, heartbeat, evidence ledger |
 | `Harness/PROGRESS.md` | Global task index linkage |
 | `.claude/skills/wf-auto-spark/SKILL.md` | Claude Code skill loader |
 | `.agents/skills/wf-auto-spark/SKILL.md` | Codex skill loader (mirror) |

package/templates/common/Harness/specs/workflows/WF-AUTO.md

@@ -113,7 +113,7 @@ WF-AUTO operates in explicit states. Without a state machine, "auto-degrade", "s
 | `auto.exhausted` | A-GATE passed permanently | Two different confirmation strategies return no actionable finding |
 | `paused` | User interrupted, waiting for direction | User says "stop" or interrupts at any point |
 
-**State transitions are CEO-owned.** The CEO decides which state to enter based on W0 results and checkpoint responses. The state machine is recorded in `Harness/tasks/auto/PROGRESS.md` at each transition.
+**State transitions are CEO-owned.** The CEO decides which state to enter based on W0 results and checkpoint responses. The state machine is recorded in `Harness/tasks/continuous/PROGRESS.md` at each transition.
 
 ## Adaptive coverage instead of a magic angle count
 
@@ -271,7 +271,7 @@ CEO NEVER writes production code (per WF-KERNEL State Ownership). Implementer wr
 
 ### RECORD
 
-Every cycle writes one entry to `Harness/tasks/auto/PROGRESS.md`:
+Every cycle writes one entry to `Harness/tasks/continuous/PROGRESS.md`:
 
 ```text
 ## Cycle N (timestamp) — State: auto.internal | auto.spark | auto.checkpoint
@@ -304,18 +304,18 @@ enabled `/wf-auto` tick hook may drive long-running auto-optimization.
 
 Manual or benchmark-driven single-cycle `/wf-auto` runs use the same bounded
 tick contract: they may stop because the caller explicitly requested one tick,
-but they still MUST create or update `Harness/tasks/auto/PLAN.md` and
-`Harness/tasks/auto/PROGRESS.md` before returning.
+but they still MUST create or update `Harness/tasks/continuous/PLAN.md` and
+`Harness/tasks/continuous/PROGRESS.md` before returning.
 
 The hook is not a role-enforcement mechanism, not a memory injection mechanism,
 and not WF-MAX state. It is only a bounded tick trigger:
 
 ```text
 wf-auto hook event
--> confirm /wf-auto is active in Harness/tasks/auto/
+-> confirm /wf-auto is active in Harness/tasks/continuous/
 -> check STOP/paused/user-interrupt state
 -> request exactly one W0-W5 tick or one Intent Checkpoint
--> append heartbeat/evidence to Harness/tasks/auto/PROGRESS.md
+-> append heartbeat/evidence to Harness/tasks/continuous/PROGRESS.md
 -> exit
 ```
 
@@ -324,7 +324,7 @@ Hard boundaries:
 - no execution-control hook is installed or registered by default
 - only `/wf-auto` may use a runtime hook to drive auto-optimization
 - the hook must run one bounded tick, not an unbounded process
-- the hook must respect `Harness/tasks/auto/STOP`, `state=paused`, user stop,
+- the hook must respect `Harness/tasks/continuous/STOP`, `state=paused`, user stop,
   and the Adaptive Coverage Exhaustion Gate
 - the hook must not enforce WF-MAX roles, writeSet, or agent identity
 - the hook must not inject memory directly; use `MEMORY_PROTOCOL.md` scenario
@@ -449,7 +449,7 @@ If a spark cycle's measured result is NEGLIGIBLE or REVERTED, increment `weakSpa
 
 ## CEO Constraints
 
-CEO tool boundaries follow [WF-KERNEL.md](WF-KERNEL.md) State Ownership: CEO plans, dispatches, synthesizes, and writes ONLY the auto task capsule (`Harness/tasks/auto/PROGRESS.md`, `Harness/tasks/auto/PLAN.md`). CEO never writes production source code — all implementation is delegated to Workers.
+CEO tool boundaries follow [WF-KERNEL.md](WF-KERNEL.md) State Ownership: CEO plans, dispatches, synthesizes, and writes ONLY the auto task capsule (`Harness/tasks/continuous/PROGRESS.md`, `Harness/tasks/continuous/PLAN.md`). CEO never writes production source code — all implementation is delegated to Workers.
 
 ## Anti-Pattern Catalog
 
@@ -509,10 +509,10 @@ Mini PRD-derived AC IDs in `/wf-auto`.
 
 ## Task Capsule
 
-WF-AUTO uses a dedicated task capsule at `Harness/tasks/auto/`:
+WF-AUTO uses a dedicated task capsule at `Harness/tasks/continuous/`:
 
-- `Harness/tasks/auto/PROGRESS.md` — cycle log, exhaustion evidence, cumulative stats
-- `Harness/tasks/auto/PLAN.md` — current cycle's change spec
+- `Harness/tasks/continuous/PROGRESS.md` — cycle log, exhaustion evidence, cumulative stats
+- `Harness/tasks/continuous/PLAN.md` — current cycle's change spec
 
 Unlike normal task capsules, this one is never archived — it's the permanent home of the auto-optimization state.
 
@@ -522,6 +522,6 @@ Closeout happens exactly once, when A-GATE passes permanently:
 
 1. CEO records final exhaustion evidence: dynamic obligations, selected and skipped probes, coverage, confidence, and two different confirmation strategies
 2. CEO writes summary: total cycles, files changed, findings addressed, findings rejected, residual risk
-3. CEO marks `Harness/tasks/auto/PROGRESS.md` as "WF-AUTO EXHAUSTED" with timestamp
+3. CEO marks `Harness/tasks/continuous/PROGRESS.md` as "WF-AUTO EXHAUSTED" with timestamp
 4. `Harness/PROGRESS.md` is updated with the auto session outcome
 5. No further automatic action is taken

package/templates/common/Harness/tasks/_template/NAMING.md

@@ -3,20 +3,20 @@
 ## Format
 
 ```
-task-<verb>-<noun>[-detail]
+task-<verb>-<noun>[-detail]-<MMDD>
 ```
 
-All task directories MUST have the `task-` prefix. This distinguishes tasks from system directories at a glance.
+All task directories MUST have the `task-` prefix and end with a 4-digit month-day suffix (MMDD, e.g. `0729` for July 29). This distinguishes tasks from system directories and provides chronological ordering.
 
 ## Rules
 
 | Rule | Example ✓ | Example ✗ |
 |------|-----------|-----------|
-| `task-` prefix required | `task-fix-ceo-inheritance` | `fix-ceo-inheritance` |
-| kebab-case (lowercase, hyphens) | `task-fix-ceo-inheritance` | `task-fix_ceo_inheritance` |
-| Verb-first after prefix | `task-add-goal-persistence` | `task-goal-persistence-add` |
-| 2-5 words after prefix, <=46 total chars | `task-refactor-role-contract` | `task-refactor-the-entire-role-contract-model` |
-| No abbreviations unless domain-standard | `task-fix-auth-middleware` | `task-fx-ath-mdw` |
+| `task-` prefix + MMDD suffix required | `task-fix-ceo-inheritance-0730` | `fix-ceo-inheritance-0730` |
+| kebab-case (lowercase, hyphens) | `task-fix-ceo-inheritance-0730` | `task-fix_ceo_inheritance-0730` |
+| Verb-first after prefix | `task-add-goal-persistence-0730` | `task-goal-persistence-add-0730` |
+| 2-5 words after prefix + MMDD date, <=46 total chars | `task-refactor-role-contract-0729` | `task-refactor-the-entire-role-contract-model-0729` |
+| No abbreviations unless domain-standard | `task-fix-auth-middleware-0730` | `task-fx-ath-mdw-0730` |
 
 ## Reserved Names
 
@@ -27,7 +27,7 @@ All task directories MUST have the `task-` prefix. This distinguishes tasks from
 
 ## Task ID Lifecycle
 
-1. Created by copying `_template/` → `task-<verb>-<noun>/`
+1. Created by copying `_template/` → `task-<verb>-<noun>-<MMDD>/`
 2. Directory name IS the task ID - used in `Harness/PROGRESS.md` and dispatch packets
 3. Directory archived (not renamed) when task completes
 4. Task ID is immutable after creation (changing it breaks cross-references)
@@ -36,12 +36,12 @@ All task directories MUST have the `task-` prefix. This distinguishes tasks from
 ## Examples
 
 ```
-task-add-dark-mode-support
-task-fix-auth-token-expiry
-task-update-harness-lifecycle-docs
-task-remove-legacy-config-files
-task-refactor-agent-dispatch-model
-task-migrate-to-esm-imports
-task-audit-security-headers
-task-benchmark-wf-max-throughput
+task-add-dark-mode-support-0729
+task-fix-auth-token-expiry-0730
+task-update-harness-lifecycle-docs-0728
+task-remove-legacy-config-files-0731
+task-refactor-agent-dispatch-model-0801
+task-migrate-to-esm-imports-0802
+task-audit-security-headers-0803
+task-benchmark-wf-max-throughput-0804
 ```