@walwal-harness/cli 7.1.28 → 7.1.29

package/apps/harness-dashboard/lib/harness-state.ts

@@ -793,6 +793,44 @@ interface HiredWorkerEntry {
   capability: string | null;
 }
 
+type MissionLifecycle = MissionDoc["lifecycle"];
+
+function normalizeMissionLifecycle(raw: unknown): MissionLifecycle {
+  const value = String(raw ?? "").toLowerCase().replace(/[_\s-]+/g, "-");
+  if (
+    value === "active" ||
+    value === "closed" ||
+    value === "cancelled" ||
+    value === "superseded" ||
+    value === "complete" ||
+    value === "blocked"
+  ) {
+    return value;
+  }
+  if (value === "done" || value === "completed") return "complete";
+  if (value === "canceled") return "cancelled";
+  return "unknown";
+}
+
+function readMissionState(missionPath: string): {
+  lifecycle: MissionLifecycle;
+  active: boolean | null;
+} {
+  const statePath = path.join(missionPath, "mission-state.json");
+  const state = readJsonSafe<{
+    lifecycle?: unknown;
+    status?: unknown;
+    active?: boolean;
+  }>(statePath);
+  if (!state.ok) return { lifecycle: "unknown", active: null };
+
+  const lifecycle = normalizeMissionLifecycle(state.value.lifecycle ?? state.value.status);
+  return {
+    lifecycle,
+    active: typeof state.value.active === "boolean" ? state.value.active : null,
+  };
+}
+
 function deriveWorkerProgress(worker: RawWorker): number | null {
   const status = (worker?.status ?? worker?.spawn_status ?? "").toLowerCase();
   if (status === "blocked" || status === "failed") return 0.35;
@@ -940,8 +978,20 @@ function workerDisplayName(content: string, hired: HiredWorkerEntry | undefined,
   return fallback;
 }
 
+function isHarnessRuntimeIdle(progress: RawProgress | null): boolean {
+  const status = (progress?.agent_status ?? "").toLowerCase();
+  const current = progress?.current_agent ?? null;
+  const next = progress?.next_agent ?? null;
+  return (
+    status === "completed" ||
+    status === "complete" ||
+    (status === "idle" && current === null && (next === null || String(next) === "none"))
+  );
+}
+
 function activeWorkerNames(progress: RawProgress | null): Set<string> {
   const active = new Set<string>();
+  if (isHarnessRuntimeIdle(progress)) return active;
   const workers = [
     ...(progress?.company_state?.workers ?? []),
     ...(progress?.company_state?.last_dispatch ?? []),
@@ -1111,6 +1161,7 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
   if (!existsSync(docsDir)) return [];
   const hiredWorkers = readHiredWorkers(rootDir);
   const activeWorkers = activeWorkerNames(progress);
+  const runtimeIdle = isHarnessRuntimeIdle(progress);
 
   const missionDirs: Array<{ rel: string; abs: string }> = [];
   const cxxDocNames = new Set(["ceo.md", "cto.md", "cqo.md", "coo.md", "cdo.md", "ops.md"]);
@@ -1145,7 +1196,7 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
     return "unknown";
   };
 
-  const missions = missionDirs
+  let missions = missionDirs
     .map(({ rel, abs: missionPath }) => {
       let mtime: Date;
       try { mtime = statSync(missionPath).mtime; } catch { mtime = new Date(0); }
@@ -1192,7 +1243,7 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
               status,
               owner: hired?.owner ?? owner,
               hired: !!hired,
-              active: activeWorkers.has(name) || (recentlyTouched && status !== "COMPLETE"),
+              active: !runtimeIdle && (activeWorkers.has(name) || (recentlyTouched && status !== "COMPLETE")),
               sourcePath: hired?.sourcePath ?? null,
               reportPath: path.relative(rootDir, reportAbs),
               updatedAt,
@@ -1216,10 +1267,10 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
           name: hired.name,
           displayName: workerDisplayName("", hired, hired.name),
           content: "",
-          status: activeWorkers.has(hired.name) ? "IN_PROGRESS" : "unknown",
+          status: !runtimeIdle && activeWorkers.has(hired.name) ? "IN_PROGRESS" : "unknown",
           owner: hired.owner,
           hired: true,
-          active: activeWorkers.has(hired.name),
+          active: !runtimeIdle && activeWorkers.has(hired.name),
           sourcePath: hired.sourcePath,
           reportPath: null,
           updatedAt: null,
@@ -1230,6 +1281,23 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
 
       const cxxRoles = ["ceo", "cto", "cqo", "coo", "cdo", "ops"] as const;
       const cxxPresent = cxxRoles.filter(role => existsSync(path.join(missionPath, `${role}.md`)));
+      const state = readMissionState(missionPath);
+      const protocolViolations: string[] = [];
+      for (const role of cxxPresent) {
+        if (role === "ceo") continue;
+        const roleWorkers = workers.filter((w) => w.owner === role);
+        const roleDoc = readMd(`${role}.md`) ?? "";
+        const hasManifest = /Worker Evidence Manifest/i.test(roleDoc);
+        const mentionsWorkerReport = new RegExp(`${role}/workers/`, "i").test(roleDoc);
+        if (roleWorkers.length === 0 || !hasManifest || !mentionsWorkerReport) {
+          protocolViolations.push(`${role}:missing-worker-evidence`);
+        }
+      }
+      for (const w of workers) {
+        if (w.owner === "unknown" || !w.hired) {
+          protocolViolations.push(`${w.owner}:${w.name}:not-hired-or-unowned`);
+        }
+      }
 
       const id = rel;
       const label = rel.split("/").pop() ?? rel;
@@ -1237,6 +1305,9 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
         missionId: id,
         ts: mtime.toISOString(),
         type: typeFromId(id),
+        lifecycle: state.lifecycle,
+        active: state.active ?? false,
+        protocolViolations,
         label,
         ceo: readMd("ceo.md"),
         cto: readMd("cto.md"),
@@ -1249,8 +1320,22 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
         cxxPresent: [...cxxPresent],
       } satisfies MissionDoc;
     })
-    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
-    .slice(0, limit);
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
+
+  const explicitActive = missions.some((m) => m.active);
+  if (!explicitActive) {
+    const latestOpen = missions.find(
+      (m) => m.lifecycle === "active" || m.lifecycle === "unknown"
+    );
+    if (latestOpen) {
+      missions = missions.map((m) => ({
+        ...m,
+        active: m.missionId === latestOpen.missionId,
+      }));
+    }
+  }
+
+  missions = missions.slice(0, limit);
 
   // When the CEO updates a goal directory in-place for a submission or hot-fix
   // (instead of creating a submission-* or hotfix-* subdirectory), the most

package/apps/harness-dashboard/lib/types.ts

@@ -340,6 +340,9 @@ export interface MissionDoc {
   missionId: string;
   ts: string;
   type: "goal" | "submission" | "hotfix" | "feature" | "unknown";
+  lifecycle: "active" | "closed" | "cancelled" | "superseded" | "complete" | "blocked" | "unknown";
+  active: boolean;
+  protocolViolations: string[];
   label: string;
   ceo: string | null;
   cto: string | null;

package/assets/templates/AGENTS.md.template

@@ -88,7 +88,7 @@ The Owner is the final acceptance reviewer, not a tester, QA worker, debugger, o
 4. CEO aggregates CXX outputs, routes to next CXX or reports to Owner.
 5. If the mission uses a runnable local, preview, Docker, or production-like environment, OPS watches the runtime while CQO evaluator workers run Playwright/E2E/API/visual/performance/regression checks.
 
-**Complete when:** `.harness/documents/goal-{index}-{name}/ceo.md` contains a final Owner report.
+**Complete when:** `.harness/documents/goal-{index}-{name}/ceo.md` contains a final Owner report and `mission-state.json` is terminal (`complete`, `closed`, `cancelled`, or `superseded`) with `active:false`.
 
 ### Submission
 
@@ -98,7 +98,7 @@ The Owner is the final acceptance reviewer, not a tester, QA worker, debugger, o
 4. Relevant CXX update `.harness/conventions/` when the new requirement changes durable project rules.
 5. Workers report under `{owning-cxx}/workers/`; CXX summarize choices in `{cxx}.md`.
 
-**Complete when:** the submission child directory has CEO/CXX records, required worker evidence, and any convention updates required by the new requirement.
+**Complete when:** the submission child directory has CEO/CXX records, required worker evidence, any convention updates required by the new requirement, and terminal `mission-state.json`.
 
 ### Hot Fix
 
@@ -150,9 +150,10 @@ Note: A docmeta skip decision on harness documents (ceo.md, cto.md, cqo.md, work
 11. **Lazy convention/gotcha loading** — CXX roles read `.harness/conventions/shared.md`, `.harness/conventions/{cxx}.md`, `.harness/gotchas/shared.md`, and `.harness/gotchas/{cxx}.md`, then follow only the related topic links listed in those CXX files. Workers read only the related links supplied by their owning CXX.
 12. **Implementation Notes required** — `ceo.md`, every `{cxx}.md`, and every worker report must end with one English `## Implementation Notes` section containing `Design Decisions`, `Deviations`, `Tradeoffs`, and `Open Questions`. Use `None` for empty subsections. Do not create a separate sidecar notes file; the notes belong at the bottom of the same role or worker report that produced the decision/evidence.
 13. **Structured runtime state** — If the harness must parse it, record it in JSON or JSONL. CXX todo queues, event history, heartbeat timestamps, preemption/resume state, and completion evidence belong in `.harness/todos/*.json*` or `.harness/events.jsonl`, not in free-form Markdown tables. Markdown remains for instructions, conventions, gotchas, skills, and human-readable mission narrative.
-14. **Owner is final acceptance only** — Owner is not a tester or QA substitute. CEO/CXX must not report "done, please check" until worker-backed verification proves the goal can be completed. Use unit tests, E2E, Playwright, test accounts, seeded data, build/run checks, logs, and CQO evidence before requesting Owner acceptance.
-15. **OPS watches CQO verification** — For runnable products, CQO PASS is invalid unless OPS has monitored the verification runtime or documented why OPS watch is not applicable. Open OPS incidents, missing runtime mapping, required log gaps, service down, health mismatch, or an unmonitored tested service block Owner acceptance.
-16. **Production incidents are company events** — After launch, user-impacting OPS signals route through CEO to CTO/CQO/OPS. CTO owns recovery, CQO owns regression confirmation, and OPS owns evidence plus close criteria.
+14. **Mission lifecycle is explicit** — Every goal, submission, and hot-fix directory must contain `mission-state.json` with `lifecycle` and `active`. Only one child mission under a goal may be active. Starting a newer submission/hot-fix closes, cancels, or supersedes the previous active child unless CEO records a deliberate TODO/resume plan.
+15. **Owner is final acceptance only** — Owner is not a tester or QA substitute. CEO/CXX must not report "done, please check" until worker-backed verification proves the goal can be completed. Use unit tests, E2E, Playwright, test accounts, seeded data, build/run checks, logs, and CQO evidence before requesting Owner acceptance.
+16. **OPS watches CQO verification** — For runnable products, CQO PASS is invalid unless OPS has monitored the verification runtime or documented why OPS watch is not applicable. Open OPS incidents, missing runtime mapping, required log gaps, service down, health mismatch, or an unmonitored tested service block Owner acceptance.
+17. **Production incidents are company events** — After launch, user-impacting OPS signals route through CEO to CTO/CQO/OPS. CTO owns recovery, CQO owns regression confirmation, and OPS owns evidence plus close criteria.
 
 ---
 

package/bin/init.js

@@ -112,6 +112,22 @@ function chmodShellScripts(dir) {
   }
 }
 
+function readJsonFileSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readTextFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
 function fileExists(p) {
   return fs.existsSync(p);
 }
@@ -451,6 +467,99 @@ function migrateExistingDocs() {
   log(`Migration report: ${reportPath}`);
 }
 
+function missionTypeFromDirName(name) {
+  if (/^goal[-_]/i.test(name)) return 'goal';
+  if (/^submission[-_]/i.test(name)) return 'submission';
+  if (/^hot[-_]?fix[-_]/i.test(name) || /^hotfix[-_]/i.test(name)) return 'hotfix';
+  return 'unknown';
+}
+
+function isTerminalMissionLifecycle(value) {
+  return ['closed', 'cancelled', 'superseded', 'complete', 'blocked'].includes(String(value || '').toLowerCase());
+}
+
+function collectMissionDirs(docsDir) {
+  const cxxDocs = new Set(['ceo.md', 'coo.md', 'cdo.md', 'cto.md', 'cqo.md', 'ops.md']);
+  const result = [];
+  const walk = (dir, rel = '') => {
+    if (!fs.existsSync(dir)) return;
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    const hasMissionDoc = entries.some((entry) => entry.isFile() && cxxDocs.has(entry.name));
+    if (rel && hasMissionDoc) {
+      let mtime = 0;
+      try { mtime = fs.statSync(dir).mtimeMs; } catch {}
+      const name = path.basename(rel);
+      result.push({ abs: dir, rel, name, type: missionTypeFromDirName(name), mtime });
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+      if (['workers', 'coo', 'cdo', 'cto', 'cqo', 'ops'].includes(entry.name)) continue;
+      walk(path.join(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+    }
+  };
+  walk(docsDir);
+  return result;
+}
+
+function ensureMissionLifecycleStates(opts = {}) {
+  const dryRun = opts.dryRun || false;
+  const backupDir = opts.backupDir || null;
+  const docsDir = path.join(HARNESS_DIR, 'documents');
+  if (!fs.existsSync(docsDir)) return { missing: 0, written: 0 };
+
+  const missions = collectMissionDirs(docsDir);
+  if (!missions.length) return { missing: 0, written: 0 };
+
+  const byGoal = new Map();
+  for (const mission of missions) {
+    const goalKey = mission.rel.split('/')[0];
+    if (!byGoal.has(goalKey)) byGoal.set(goalKey, []);
+    byGoal.get(goalKey).push(mission);
+  }
+
+  const writes = [];
+  for (const group of byGoal.values()) {
+    const children = group.filter((m) => m.rel.includes('/') && (m.type === 'submission' || m.type === 'hotfix'));
+    children.sort((a, b) => b.mtime - a.mtime);
+    const existingActiveChild = children.find((m) => {
+      const state = readJsonFileSafe(path.join(m.abs, 'mission-state.json'));
+      return state?.active === true && !isTerminalMissionLifecycle(state.lifecycle || state.status);
+    });
+    const activeChild = existingActiveChild || children[0] || null;
+
+    for (const mission of group) {
+      const statePath = path.join(mission.abs, 'mission-state.json');
+      if (fs.existsSync(statePath)) continue;
+      const isChild = mission.rel.includes('/');
+      const isActive = isChild
+        ? activeChild?.rel === mission.rel
+        : true;
+      writes.push({
+        path: statePath,
+        state: {
+          lifecycle: isActive ? 'active' : 'closed',
+          active: isActive,
+        },
+      });
+    }
+  }
+
+  if (dryRun) return { missing: writes.length, written: 0 };
+
+  for (const item of writes) {
+    if (backupDir) {
+      const rel = path.relative(HARNESS_DIR, item.path).replace(/[\\/]/g, '__');
+      if (fs.existsSync(item.path)) fs.writeFileSync(path.join(backupDir, rel), fs.readFileSync(item.path, 'utf8'));
+    }
+    fs.writeFileSync(item.path, JSON.stringify(item.state, null, 2) + '\n');
+  }
+  if (writes.length) {
+    log(`mission-state.json: ${writes.length}개 기존 mission에 lifecycle 보강`);
+  }
+  return { missing: writes.length, written: writes.length };
+}
+
 // ─────────────────────────────────────────
 // 1. .harness/ scaffolding
 // ─────────────────────────────────────────
@@ -585,6 +694,7 @@ function scaffoldHarness() {
     if (!fileExists(p) || isForce) fs.writeFileSync(p, '');
   }
   ensureStructuredRuntimeFiles();
+  ensureMissionLifecycleStates();
 
   // Migrate progress.json v1 → v2 (add mode + team_state fields)
   const progressPath = path.join(HARNESS_DIR, 'progress.json');
@@ -1094,55 +1204,129 @@ function installAgentTeamsEnv() {
   }
 }
 
-function setupAgentsMd() {
+const HARNESS_HEADER_MARKER = '<!-- walwal-harness:managed-header -->';
+const HARNESS_SECTION_START = '<!-- walwal-harness:agents:start -->';
+const HARNESS_SECTION_END = '<!-- walwal-harness:agents:end -->';
+const PRESERVED_CLAUDE_START = '<!-- walwal-harness:preserved-claude:start -->';
+const PRESERVED_CLAUDE_END = '<!-- walwal-harness:preserved-claude:end -->';
+
+function backupDocPath(filePath, backupDir, label) {
+  if (!filePath || !fs.existsSync(filePath)) return;
+  ensureDir(backupDir);
+  const safe = label.replace(/[^A-Za-z0-9_.-]/g, '_');
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  try {
+    fs.copyFileSync(filePath, path.join(backupDir, `${safe}.${ts}.bak`));
+  } catch {}
+}
+
+function renderHarnessAgentsSection() {
+  const templateSrc = path.join(PKG_ROOT, 'assets', 'templates', 'AGENTS.md.template');
+  let content = fs.existsSync(templateSrc)
+    ? fs.readFileSync(templateSrc, 'utf8')
+    : '# walwal-harness\n\nUse `/goal`, `/submission`, and `/hot-fix` for CEO/CXX/worker flow.\n';
+  content = content.replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0]);
+  content = content.replace(/\{\{DATE_ISO\}\}/g, new Date().toISOString());
+  return [
+    HARNESS_SECTION_START,
+    '',
+    content.trim(),
+    '',
+    HARNESS_SECTION_END,
+    ''
+  ].join('\n');
+}
+
+function ensureTopHarnessHeader(body) {
+  if (body.includes(HARNESS_HEADER_MARKER)) return body;
+  const header = [
+    HARNESS_HEADER_MARKER,
+    '> This project is walwal-harness enabled. Harness operating rules live in the marked walwal-harness section below.',
+    ''
+  ].join('\n');
+  return header + body.replace(/^\s+/, '');
+}
+
+function upsertMarkedBlock(body, start, end, block) {
+  const startIdx = body.indexOf(start);
+  const endIdx = body.indexOf(end);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const afterEnd = endIdx + end.length;
+    return body.slice(0, startIdx).replace(/\s*$/, '\n\n') + block.trim() + '\n' + body.slice(afterEnd).replace(/^\s*/, '\n');
+  }
+  const sep = body.trim() ? '\n\n' : '';
+  return body.replace(/\s*$/, '') + sep + block.trim() + '\n';
+}
+
+function normalizeDocBody(body) {
+  return String(body || '').replace(/\r\n/g, '\n').trim();
+}
+
+function ensureProjectAgentDocs(opts = {}) {
+  const dryRun = opts.dryRun || false;
+  const backupDir = opts.backupDir || path.join(HARNESS_DIR, 'archive', 'pre-harness-backup');
   const agentsMd = path.join(PROJECT_ROOT, 'AGENTS.md');
   const claudeMd = path.join(PROJECT_ROOT, 'CLAUDE.md');
 
-  // Run scan if no AGENTS.md
-  if (!fileExists(agentsMd) || isForce) {
-    log('Running project scan...');
-    try {
-      execSync(`bash "${path.join(PKG_ROOT, 'scripts', 'scan-project.sh')}" "${PROJECT_ROOT}"`, {
-        stdio: 'inherit'
-      });
-      execSync(`bash "${path.join(PKG_ROOT, 'scripts', 'init-agents-md.sh')}" "${PROJECT_ROOT}"`, {
-        stdio: 'inherit'
-      });
-    } catch (e) {
-      log('WARNING: Auto-scan failed. Run manually: bash scripts/scan-project.sh .');
-      // Create minimal AGENTS.md
-      const templateSrc = path.join(PKG_ROOT, 'assets', 'templates', 'AGENTS.md.template');
-      if (fs.existsSync(templateSrc)) {
-        let content = fs.readFileSync(templateSrc, 'utf8');
-        content = content.replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0]);
-        fs.writeFileSync(agentsMd, content);
-      }
-    }
+  const agentsTarget = fs.existsSync(agentsMd) ? fs.realpathSync(agentsMd) : agentsMd;
+  const existingAgents = readTextFileSafe(agentsMd) || '';
+  const claudeExists = fs.existsSync(claudeMd) || fs.existsSync(claudeMd);
+  const claudeIsSymlink = fs.existsSync(claudeMd) && fs.lstatSync(claudeMd).isSymbolicLink();
+  const claudeTarget = claudeExists ? fs.realpathSync(claudeMd) : null;
+  const claudeBody = claudeExists ? (readTextFileSafe(claudeMd) || '') : '';
+
+  let nextAgents = existingAgents;
+  nextAgents = ensureTopHarnessHeader(nextAgents);
+  nextAgents = upsertMarkedBlock(nextAgents, HARNESS_SECTION_START, HARNESS_SECTION_END, renderHarnessAgentsSection());
+
+  const normalizedClaude = normalizeDocBody(claudeBody);
+  const claudePointsAtAgents = claudeIsSymlink && claudeTarget === agentsTarget;
+  if (normalizedClaude && !claudePointsAtAgents) {
+    const preservedBlock = [
+      PRESERVED_CLAUDE_START,
+      '',
+      '## Preserved CLAUDE.md',
+      '',
+      normalizedClaude,
+      '',
+      PRESERVED_CLAUDE_END,
+      ''
+    ].join('\n');
+    nextAgents = upsertMarkedBlock(nextAgents, PRESERVED_CLAUDE_START, PRESERVED_CLAUDE_END, preservedBlock);
   }
 
-  // Ensure CLAUDE.md symlink
-  if (fileExists(agentsMd)) {
-    try {
-      const stat = fs.lstatSync(claudeMd);
-      if (!stat.isSymbolicLink()) {
-        // Backup existing CLAUDE.md
-        const backupDir = path.join(HARNESS_DIR, 'archive', 'pre-harness-backup');
-        ensureDir(backupDir);
-        fs.copyFileSync(claudeMd, path.join(backupDir, `CLAUDE.md.${Date.now()}.bak`));
-        fs.unlinkSync(claudeMd);
-        fs.symlinkSync('AGENTS.md', claudeMd);
-        log('CLAUDE.md backed up and replaced with symlink → AGENTS.md');
-      }
-    } catch (e) {
-      // CLAUDE.md doesn't exist
-      try {
-        fs.symlinkSync('AGENTS.md', claudeMd);
-        log('Created symlink: CLAUDE.md → AGENTS.md');
-      } catch (e2) {}
-    }
+  if (dryRun) {
+    log('  (dry-run) AGENTS.md: walwal-harness marked section merge 예정');
+    if (!claudePointsAtAgents) log('  (dry-run) CLAUDE.md: content preserved then symlink → AGENTS.md 예정');
+    return;
+  }
+
+  if (fs.existsSync(agentsTarget)) backupDocPath(agentsTarget, backupDir, 'AGENTS.md');
+  if (claudeExists && claudeTarget && claudeTarget !== agentsTarget) {
+    backupDocPath(claudeTarget, backupDir, 'CLAUDE.md');
+  }
+
+  ensureDir(path.dirname(agentsMd));
+  fs.writeFileSync(agentsMd, nextAgents.replace(/\s*$/, '\n'));
+  log(fs.existsSync(agentsTarget) ? 'AGENTS.md merged with walwal-harness marked section' : 'AGENTS.md created from walwal-harness template');
+
+  try {
+    if (fs.existsSync(claudeMd) || fs.lstatSync(claudeMd)) fs.unlinkSync(claudeMd);
+  } catch {}
+  try {
+    fs.symlinkSync('AGENTS.md', claudeMd);
+    log('CLAUDE.md replaced with symlink → AGENTS.md');
+  } catch (e) {
+    log(`WARNING: Could not create CLAUDE.md symlink (${e.message})`);
   }
 }
 
+function setupAgentsMd() {
+  const agentsMd = path.join(PROJECT_ROOT, 'AGENTS.md');
+  const claudeMd = path.join(PROJECT_ROOT, 'CLAUDE.md');
+  ensureProjectAgentDocs({ backupDir: path.join(HARNESS_DIR, 'archive', 'pre-harness-backup') });
+}
+
 // ─────────────────────────────────────────
 // 5. Playwright MCP check
 // ─────────────────────────────────────────
@@ -1300,6 +1484,8 @@ function detectMigrationNeeded() {
     harnessMdStale: false,
     agentsMissingOpsVerificationRules: false,
     agentsMissingCodexAdapterRules: false,
+    agentsMissingMissionLifecycleRules: false,
+    missionLifecycleMissing: false,
     rosterCodexPathsMissing: false,
     resourceIndexCodexWordingMissing: false,
     memoryMissingSystemEntries: [],
@@ -1427,8 +1613,19 @@ function detectMigrationNeeded() {
       ) {
         flags.agentsMissingCodexAdapterRules = true;
       }
+      if (
+        !agentsBody.includes('Mission Lifecycle Rules') &&
+        !agentsBody.includes('mission-state.json')
+      ) {
+        flags.agentsMissingMissionLifecycleRules = true;
+      }
     } catch {}
   }
+  const docsDir = path.join(HARNESS_DIR, 'documents');
+  if (fs.existsSync(docsDir)) {
+    flags.missionLifecycleMissing = collectMissionDirs(docsDir)
+      .some((mission) => !fs.existsSync(path.join(mission.abs, 'mission-state.json')));
+  }
   if (fs.existsSync(rosterPath)) {
     try {
       const roster = JSON.parse(fs.readFileSync(rosterPath, 'utf8'));
@@ -1764,6 +1961,8 @@ function runMigrate(opts = {}) {
     !flags.agentsMissingOpsVerificationRules &&
     !flags.rosterCodexPathsMissing &&
     !flags.resourceIndexCodexWordingMissing &&
+    !flags.agentsMissingMissionLifecycleRules &&
+    !flags.missionLifecycleMissing &&
     (!flags.memoryMissingSystemEntries || flags.memoryMissingSystemEntries.length === 0) &&
     gotchaMissingTotal === 0 &&
     conventionMissingTotal === 0 &&
@@ -1785,6 +1984,14 @@ function runMigrate(opts = {}) {
   const backupDir = path.join(HARNESS_DIR, 'archive', `migration-${ts}`);
   if (!dryRun) ensureDir(backupDir);
   ensureStructuredRuntimeFiles({ dryRun });
+  ensureProjectAgentDocs({ dryRun, backupDir });
+  flags.agentsMissingOpsVerificationRules = false;
+  flags.agentsMissingCodexAdapterRules = false;
+  flags.agentsMissingMissionLifecycleRules = false;
+  const missionStateResult = ensureMissionLifecycleStates({ dryRun, backupDir });
+  if (dryRun && missionStateResult.missing > 0) {
+    log(`  (dry-run) mission-state.json: ${missionStateResult.missing}개 기존 mission에 lifecycle 보강 예정`);
+  }
 
   // Runtime scripts are package-owned. Migrate must refresh them so existing
   // projects receive wake/meeting/OPS fixes without requiring a full init.
@@ -2099,6 +2306,31 @@ function runMigrate(opts = {}) {
     }
   }
 
+  if (flags.agentsMissingMissionLifecycleRules) {
+    const agentsPath = path.join(PROJECT_ROOT, 'AGENTS.md');
+    if (fs.existsSync(agentsPath)) {
+      const original = fs.readFileSync(agentsPath, 'utf8');
+      const block = [
+        '',
+        '---',
+        '',
+        '## walwal-harness Mission Lifecycle Rules — v7.1.28',
+        '',
+        '- Every goal, submission, and hot-fix directory must contain `mission-state.json` with `lifecycle` and `active`.',
+        '- Only one child mission under a goal may be active. Starting a newer submission/hot-fix closes, cancels, or supersedes the previous active child unless CEO records a deliberate TODO/resume plan.',
+        '- CXX completion requires a Worker Evidence Manifest plus worker report paths under `{owning-cxx}/workers/`. A CXX report without hired worker evidence is a protocol violation.',
+        '- Worker execution should be shown as worker activity; CXX activity is coordination only.',
+        ''
+      ].join('\n');
+      log('  AGENTS.md: mission lifecycle / CXX hire-only rules append');
+      if (!dryRun) {
+        fs.writeFileSync(path.join(backupDir, 'AGENTS.mission-lifecycle.md'), original);
+        const sep = original.endsWith('\n') ? '' : '\n';
+        fs.writeFileSync(agentsPath, original + sep + block);
+      }
+    }
+  }
+
   // 7. Bundle version stamp — record which package version was last applied.
   if (flags.bundleVersionStale) {
     const { current, installed } = flags.bundleVersionStale;

package/commands/goal.md

@@ -14,14 +14,16 @@ Codex adapter:
 
 Required flow:
 1. Create or update a goal under `.harness/documents/goal-{goal_index}-{goal_name}/`.
-2. Record CEO decisions in `.harness/documents/goal-{goal_index}-{goal_name}/ceo.md`.
-3. CEO decides whether brainstorming is needed or whether CXX questions can be issued immediately.
-4. CEO asks COO, CDO, CTO, and CQO only the questions needed for this goal.
-5. CXX roles must start in a fresh session context. Do not let the default model impersonate a missing worker.
-6. CXX roles must not directly execute specialist deliverables. They must use hired workers for research, planning, design, implementation, QA, ops checks, and documentation.
-7. If a required CXX or worker skill is missing, CEO must invoke the installed `harness-hiring` skill before assigning the work.
-8. CEO must require worker report paths under `.harness/documents/goal-{goal_index}-{goal_name}/{owning-cxx}/workers/` before accepting CXX completion.
-9. Do not invoke internal roles through slash commands; commands are Owner entrypoints only.
+2. Write `.harness/documents/goal-{goal_index}-{goal_name}/mission-state.json` with `{"lifecycle":"active","active":true}` before routing CXX.
+3. Record CEO decisions in `.harness/documents/goal-{goal_index}-{goal_name}/ceo.md`.
+4. CEO decides whether brainstorming is needed or whether CXX questions can be issued immediately.
+5. CEO asks COO, CDO, CTO, and CQO only the questions needed for this goal.
+6. CXX roles must start in a fresh session context. Do not let the default model impersonate a missing worker.
+7. CXX roles must not directly execute specialist deliverables. They must use hired workers for research, planning, design, implementation, QA, ops checks, and documentation.
+8. If a required CXX or worker skill is missing, CEO must invoke the installed `harness-hiring` skill before assigning the work.
+9. CEO must require a Worker Evidence Manifest and worker report paths under `.harness/documents/goal-{goal_index}-{goal_name}/{owning-cxx}/workers/` before accepting CXX completion.
+10. When the goal is accepted, cancelled, superseded, blocked, or closed, update `mission-state.json` to `complete`, `cancelled`, `superseded`, `blocked`, or `closed` and set `active:false`.
+11. Do not invoke internal roles through slash commands; commands are Owner entrypoints only.
 
 Note: A goal is the company's objective. Submissions and hot-fixes that happen while pursuing it should be recorded under that goal directory.