@walwal-harness/cli 7.1.47 → 7.1.49

package/CHANGELOG.md

@@ -4,7 +4,7 @@ docmeta:
   title: walwal-harness CHANGELOG
   type: output
   createdAt: 2026-05-07T00:00:00Z
-  updatedAt: 2026-05-07T00:00:00Z
+  updatedAt: 2026-06-05T00:00:00Z
   source:
     producer: agent
     skillId: harness-release
@@ -31,6 +31,11 @@ docmeta:
 
 ## Unreleased
 
+## 7.1.48 — Auto-managed `.harness` `.gitignore` + runtime untrack on init (2026-06-05)
+- `walwal-harness init` now writes/refreshes a marked managed block in the project-root `.gitignore` so machine-specific harness runtime/local state is never committed and never pollutes teammates' diffs. Ignored: live conductor `progress.json`/`progress.log`/`handoff.json`/`events.jsonl`, the `todos/` live queue (`state.json` + `events.jsonl`), `actions/`, `ops/`, `activity/`, `logs/`, `archive/` migration backups, and the `dashboard/` visualization tooling. Durable team knowledge stays tracked: `conventions/`, `gotchas/`, `documents/`, `memories/`, `memory.md`, `shared/`, `config.json`, `HARNESS.md`, `.bundle-version`.
+- Init also best-effort `git rm --cached`s any of those runtime paths committed before the ignore block existed (files stay on disk), fixing the "`.gitignore` added but already-tracked files keep showing as changes" case.
+- Canonical ignore list now lives in `assets/templates/gitignore-append.txt` as a single source of truth, consumed by both `bin/init.js` and `scripts/harness-dashboard-up.sh` (the dashboard launcher defers to init's managed block instead of appending its own narrow one).
+
 ## 7.1.38 — CEO approval authority for routine operations (2026-05-31)
 
 - CEO now has explicit authority to approve reversible routine operations without Owner confirmation, including mission consolidation/supersede cleanup, monitoring cadence, briefing templates, local cron/launchd/wake automation, dashboard refresh, and Telegram/dashboard notifications that use already configured credentials.
@@ -42,7 +47,7 @@ docmeta:
 - Dashboard runtime now lives under each project’s `.harness/dashboard/` instead of the shared `~/.walwal-harness/dashboard/` cache, with generated dependencies/build output ignored via `.gitignore`.
 - Dashboard heatmap is no longer filtered by the selected goal/submission/hot-fix; it shows all recorded activity while still preserving mission IDs on active cells.
 - Dashboard worker parsing now accepts `name`, `progress`, `eta`, and `report_path` telemetry and no longer treats docmeta-only report drafts as proof of live worker activity.
-- Init/migrate now best-effort registers the project with the hourly wake scheduler, and wake status now uses the macOS `launchctl print gui/$UID/...` state to avoid false `NOT loaded` reports.
+- Hourly wake registration is opt-in during init/migrate (`--enable-wake` or `WALWAL_ENABLE_WAKE=1`), and wake status now uses the macOS `launchctl print gui/$UID/...` state to avoid false `NOT loaded` reports.
 
 ## 7.1.36 — Stop hook active-loop guard + visible heatmap (2026-05-29)
 

package/HR-Resource/support-support-mcp-registry-steward/SKILL.md

@@ -74,4 +74,3 @@ Required sections:
 8. `## Implementation Notes`
 
 Use `None` for empty sections. Include exact evidence paths or tool names for every claim.
-

package/README.md

@@ -243,6 +243,7 @@ Features:
 
 Hourly autonomous wake:
 
+- Init/migrate does not auto-register launchd wake by default. Use `--enable-wake` or `WALWAL_ENABLE_WAKE=1` when you want installation/migration to register it; otherwise run `bash scripts/harness-wake-install.sh install .` from the target project.
 - `HARNESS_WAKE_EXECUTOR=claude|codex` selects `claude -p` or `codex exec`.
 - `HARNESS_WAKE_MODEL=<model>` optionally pins the Claude model for wake ticks.
 - Each wake tick prompts CEO to convene CXX + OPS, collect progress and decisions, dispatch the next action without asking Owner, and require CQO/OPS verification until the active goal works.
@@ -286,7 +287,7 @@ harness-hiring           → register and onboard worker
 | Version | Summary |
 |---|---|
 | 7.1.38 | CEO can approve reversible routine operations without Owner confirmation, including monitoring cadence, local scheduler activation, Telegram briefing formats with existing credentials, dashboard refresh, and consolidation/supersede cleanup |
-| 7.1.37 | Project-local dashboard runtime under `.harness/dashboard/`, unfiltered all-mission heatmap, worker telemetry parsing, and more reliable hourly wake registration/status |
+| 7.1.37 | Project-local dashboard runtime under `.harness/dashboard/`, unfiltered all-mission heatmap, worker telemetry parsing, and opt-in hourly wake registration/status |
 | 7.1.36 | Stop hook only validates worker evidence while chaining the active loop, scopes validation to the newest active mission, and makes the 24h heatmap visible at 10-minute resolution |
 | 7.1.35 | Fix dashboard heatmap mission scoping, choose the newest active mission for activity recording, and normalize duplicate active child mission states during init/migrate |
 | 7.1.34 | Fix dashboard 500 when `company_state.workers` is recorded as a keyed worker map instead of an array |

package/apps/harness-dashboard/lib/__tests__/brick-adapter.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { toContractState } from "../brick/adapter";
+import type { HarnessSnapshot } from "../types";
+
+function snapshotWithActivity(ts: string): HarnessSnapshot {
+  return {
+    version: "test",
+    ts: new Date().toISOString(),
+    projectName: "demo",
+    projectPath: "/tmp/demo",
+    errorBanner: null,
+    runtime: {
+      currentAgent: null,
+      agentStatus: "pending",
+      nextAgent: null,
+      updatedAt: null,
+      conductorState: "running",
+      ownerPrompt: null,
+    },
+    incidents: [],
+    missions: [],
+    ownerHistory: [],
+    gotchas: [],
+    conventions: [],
+    todos: [],
+    events: [],
+    activitySamples: [{ ts, laneId: "cto", count: 1, hotfix: false, missionId: "goal-1" }],
+    files: [],
+  };
+}
+
+describe("toContractState", () => {
+  it("does not mark a role active from stale historical activity samples", () => {
+    const now = Date.parse("2026-06-05T00:10:00Z");
+    const state = toContractState(snapshotWithActivity("2026-06-05T00:00:00Z"), true, now);
+    expect(state.agents.find((agent) => agent.id === "cto")?.status).toBe("idle");
+  });
+
+  it("marks a role active from recent activity samples", () => {
+    const now = Date.parse("2026-06-05T00:01:00Z");
+    const state = toContractState(snapshotWithActivity("2026-06-05T00:00:30Z"), true, now);
+    expect(state.agents.find((agent) => agent.id === "cto")?.status).toBe("active");
+  });
+});

package/apps/harness-dashboard/lib/__tests__/company-flow.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -267,4 +267,36 @@ describeHarnessShell("company-loop shell flows", () => {
     expect(progress.planner.requested_mode).toBeNull();
     expect(progress.meetings.requested_type).toBe("followup-review");
   });
+
+  it("company terminal transitions only update the newest current mission state", () => {
+    writeState(dir, {
+      current_agent: "ceo",
+      agent_status: "running",
+      next_agent: "none",
+      owner_prompt: { status: "routing" },
+      company_state: { state: "running", active_workers: 0 },
+      conductor: { state: "running", tracks: [] },
+    });
+    const docs = path.join(dir, ".harness", "documents");
+    const oldMission = path.join(docs, "goal-1-old");
+    const newMission = path.join(docs, "goal-2-new");
+    mkdirSync(oldMission, { recursive: true });
+    mkdirSync(newMission, { recursive: true });
+    const oldState = path.join(oldMission, "mission-state.json");
+    const newState = path.join(newMission, "mission-state.json");
+    writeFileSync(oldState, JSON.stringify({ lifecycle: "active", active: true }));
+    writeFileSync(newState, JSON.stringify({ lifecycle: "active", active: true }));
+    const oldDate = new Date("2026-05-01T00:00:00Z");
+    const newDate = new Date("2026-05-02T00:00:00Z");
+    utimesSync(oldState, oldDate, oldDate);
+    utimesSync(newState, newDate, newDate);
+
+    runBash("scripts/harness-company-block.sh", dir, ["needs-key"]);
+    expect(JSON.parse(readFileSync(oldState, "utf8")).lifecycle).toBe("active");
+    expect(JSON.parse(readFileSync(newState, "utf8")).lifecycle).toBe("blocked");
+
+    runBash("scripts/harness-company-complete.sh", dir, ["provided-key"]);
+    expect(JSON.parse(readFileSync(oldState, "utf8")).lifecycle).toBe("active");
+    expect(JSON.parse(readFileSync(newState, "utf8")).lifecycle).toBe("complete");
+  });
 });

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

@@ -123,6 +123,61 @@ describe("readHarnessState", () => {
     expect(mission.protocolViolations).toContain("cto:missing-worker-evidence");
   });
 
+  it("does not count roster-only hired workers as CXX evidence without a report file", () => {
+    const harnessDir = path.join(dir, ".harness");
+    const missionDir = path.join(harnessDir, "documents", "goal-1-dashboard");
+    mkdirSync(path.join(harnessDir, "shared", "HR-Resource", "react-ui-worker"), { recursive: true });
+    mkdirSync(missionDir, { recursive: true });
+    writeFileSync(path.join(missionDir, "ceo.md"), "# Dashboard\n");
+    writeFileSync(
+      path.join(missionDir, "cto.md"),
+      "# CTO\n\nWorker Evidence Manifest: cto/workers/react-ui-worker.md\n"
+    );
+    writeFileSync(
+      path.join(harnessDir, "shared", "HR-Resource", "react-ui-worker", "SKILL.md"),
+      "# React UI Worker\n"
+    );
+    writeFileSync(
+      path.join(harnessDir, "shared", "hr-roster.json"),
+      JSON.stringify({
+        hired: [
+          {
+            worker: "react-ui-worker",
+            owner: "cto",
+            skillPath: ".harness/shared/HR-Resource/react-ui-worker/SKILL.md",
+          },
+        ],
+      })
+    );
+
+    const mission = readHarnessState(dir).missions[0];
+    expect(mission.workers[0]).toMatchObject({ name: "react-ui-worker", reportPath: null });
+    expect(mission.protocolViolations).toContain("cto:missing-worker-evidence");
+  });
+
+  it("keeps an explicit active mission visible even when it is older than the latest page", () => {
+    const harnessDir = path.join(dir, ".harness");
+    const docsDir = path.join(harnessDir, "documents");
+    const activeDir = path.join(docsDir, "goal-0-operating");
+    mkdirSync(activeDir, { recursive: true });
+    writeFileSync(path.join(activeDir, "ceo.md"), "# Operating\n");
+    writeFileSync(path.join(activeDir, "mission-state.json"), JSON.stringify({ lifecycle: "operating", active: true }));
+    const oldDate = new Date("2026-05-01T00:00:00Z");
+    utimesSync(activeDir, oldDate, oldDate);
+
+    for (let i = 1; i <= 16; i += 1) {
+      const missionDir = path.join(docsDir, `goal-${i}-done`);
+      mkdirSync(missionDir, { recursive: true });
+      writeFileSync(path.join(missionDir, "ceo.md"), `# Done ${i}\n`);
+      writeFileSync(path.join(missionDir, "mission-state.json"), JSON.stringify({ lifecycle: "complete", active: false }));
+      const ts = new Date(`2026-05-${String(i + 1).padStart(2, "0")}T00:00:00Z`);
+      utimesSync(missionDir, ts, ts);
+    }
+
+    const missions = readHarnessState(dir).missions;
+    expect(missions.some((mission) => mission.missionId === "goal-0-operating" && mission.active)).toBe(true);
+  });
+
   it("positions only hired HR-Resource workers and marks active workers", () => {
     const harnessDir = path.join(dir, ".harness");
     const missionDir = path.join(harnessDir, "documents", "goal-1-dashboard");

package/apps/harness-dashboard/lib/__tests__/sandbox-e2e.test.ts

@@ -8,7 +8,7 @@
  * the values the live Scene.tsx renders, plus the Stop-hook autonomy behavior.
  *
  * Gated behind WALWAL_E2E=1 so it stays out of the fast unit suite and only
- * runs (and writes to ~/tmp) when explicitly requested:
+ * runs (and writes to the OS temp dir, or WALWAL_E2E_ROOT when set) when explicitly requested:
  *   WALWAL_E2E=1 npx vitest run sandbox-e2e
  */
 import { describe, it, expect, beforeAll } from "vitest";
@@ -111,7 +111,7 @@ function stopTick(sbx: string): { blocked: boolean; raw: string } {
   return { blocked: raw.includes('"decision"') && raw.includes('"block"'), raw };
 }
 
-const SBX_ROOT = path.join(os.homedir(), "tmp");
+const SBX_ROOT = process.env.WALWAL_E2E_ROOT ?? path.join(os.tmpdir(), "walwal-e2e");
 
 gate("walwal-harness sandbox e2e — two usage modes", () => {
   beforeAll(() => {
@@ -135,6 +135,71 @@ gate("walwal-harness sandbox e2e — two usage modes", () => {
     expect(lstatSync(path.join(sbx, "CLAUDE.md")).isSymbolicLink()).toBe(true);
   });
 
+  it("migrate preserves user AGENTS.md and hired roster while refreshing package-owned state", () => {
+    const sbx = path.join(SBX_ROOT, "walwal-sandbox-migrate-preserve");
+    init(sbx);
+    appendFileSync(path.join(sbx, "AGENTS.md"), "\n## User Rule\n\nKeep this project-specific rule.\n");
+    writeFileSync(path.join(sbx, ".harness", ".bundle-version"), "7.1.1\n");
+    mkdirSync(path.join(sbx, ".harness", "shared", "HR-Resource", "react-ui-worker"), { recursive: true });
+    writeFileSync(path.join(sbx, ".harness", "shared", "HR-Resource", "react-ui-worker", "SKILL.md"), "# React UI Worker\n");
+    const rosterPath = path.join(sbx, ".harness", "shared", "hr-roster.json");
+    writeFileSync(
+      rosterPath,
+      JSON.stringify(
+        {
+          hired: [
+            {
+              worker: "react-ui-worker",
+              owner: "cto",
+              skillPath: ".claude/skills/react-ui-worker/SKILL.md",
+            },
+          ],
+        },
+        null,
+        2
+      )
+    );
+
+    execFileSync("node", [path.join(repoRoot, "bin", "init.js"), "migrate", "--dry-run", "--project-root", sbx], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe",
+    });
+    expect(readFileSync(path.join(sbx, ".harness", ".bundle-version"), "utf8")).toBe("7.1.1\n");
+    expect(JSON.parse(readFileSync(rosterPath, "utf8")).hired[0].skillPaths).toBeUndefined();
+
+    execFileSync("node", [path.join(repoRoot, "bin", "init.js"), "migrate", "--project-root", sbx], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe",
+    });
+    const agents = readFileSync(path.join(sbx, "AGENTS.md"), "utf8");
+    expect(agents).toContain("Keep this project-specific rule.");
+    const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+    expect(roster.hired[0].skillPaths.codex).toContain(".codex/skills/");
+    expect(roster.hired[0].skillPaths.source).toBe(".harness/shared/HR-Resource/react-ui-worker/SKILL.md");
+    expect(readFileSync(path.join(sbx, ".harness", ".bundle-version"), "utf8")).toBe("7.1.48\n");
+  });
+
+  it("gitignore management untracks runtime state without untracking shared harness files", () => {
+    const sbx = path.join(SBX_ROOT, "walwal-sandbox-gitignore");
+    init(sbx);
+    execFileSync("git", ["init"], { cwd: sbx, encoding: "utf8", stdio: "pipe" });
+    execFileSync("git", ["add", "-f", ".harness/progress.json"], { cwd: sbx, encoding: "utf8", stdio: "pipe" });
+    execFileSync("git", ["add", ".harness/memory.md"], { cwd: sbx, encoding: "utf8", stdio: "pipe" });
+    expect(execFileSync("git", ["ls-files", ".harness/progress.json"], { cwd: sbx, encoding: "utf8" }).trim()).toBe(".harness/progress.json");
+    expect(execFileSync("git", ["ls-files", ".harness/memory.md"], { cwd: sbx, encoding: "utf8" }).trim()).toBe(".harness/memory.md");
+
+    execFileSync("node", [path.join(repoRoot, "bin", "init.js"), "init", "--force", "--project-root", sbx], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe",
+    });
+
+    expect(execFileSync("git", ["ls-files", ".harness/progress.json"], { cwd: sbx, encoding: "utf8" }).trim()).toBe("");
+    expect(execFileSync("git", ["ls-files", ".harness/memory.md"], { cwd: sbx, encoding: "utf8" }).trim()).toBe(".harness/memory.md");
+  });
+
   // ───────────────────────────────────────────────────────────────────────
   // MODE 1 — AUTONOMY: Owner sets a broad goal, the company runs itself, and
   // the loop must (a) keep going while work remains and (b) stop CLEANLY at

package/apps/harness-dashboard/lib/brick/adapter.ts

@@ -186,7 +186,11 @@ export function toContractState(
   // ---- agents --------------------------------------------------------
   const hasRecentSample = (role: AgentRole): boolean =>
     snapshot.activitySamples.some(
-      (s) => (s.laneId === role || s.laneId.startsWith(role + ":")) && s.count > 0
+      (s) => {
+        if ((s.laneId !== role && !s.laneId.startsWith(role + ":")) || s.count <= 0) return false;
+        const t = parseTs(s.ts);
+        return t != null && nowMs - t <= STALE_MS;
+      }
     );
   const runtimeBlocked =
     (rt.agentStatus ?? "").toLowerCase() === "blocked" ||

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

@@ -615,7 +615,7 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
       const protocolViolations: string[] = [];
       for (const role of cxxPresent) {
         if (role === "ceo") continue;
-        const roleWorkers = workers.filter((w) => w.owner === role);
+        const roleWorkers = workers.filter((w) => w.owner === role && w.reportPath);
         const roleDoc = readMd(`${role}.md`) ?? "";
         const hasManifest = /Worker Evidence Manifest/i.test(roleDoc);
         const mentionsWorkerReport = new RegExp(`${role}/workers/`, "i").test(roleDoc);
@@ -677,7 +677,17 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
     }
   }
 
-  missions = missions.slice(0, limit);
+  const activePinned = missions.filter((m) => m.active);
+  const limited = missions.slice(0, limit);
+  if (activePinned.length) {
+    const seen = new Set(limited.map((m) => m.missionId));
+    for (const mission of activePinned) {
+      if (!seen.has(mission.missionId)) limited.push(mission);
+    }
+    missions = limited;
+  } else {
+    missions = limited;
+  }
 
   // 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/next.config.mjs

@@ -1,9 +1,7 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   reactStrictMode: true,
-  experimental: {
-    typedRoutes: false,
-  },
+  typedRoutes: false,
 };
 
 export default nextConfig;

package/apps/harness-dashboard/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "description": "Brick Office — walwal-harness 라이브 대시보드 (Phase C)",
   "scripts": {
-    "dev:dashboard": "next dev -p 3001",
+    "dev:dashboard": "next dev",
     "build": "next build",
     "start": "next start -p 3001",
     "lint": "next lint",

package/assets/templates/gitignore-append.txt

@@ -1,6 +1,26 @@
-# walwal-harness dashboard runtime
-.harness/dashboard/apps/harness-dashboard/node_modules/
-.harness/dashboard/apps/harness-dashboard/.next/
-.harness/dashboard/apps/harness-dashboard/.turbo/
-.harness/dashboard/apps/harness-dashboard/tsconfig.tsbuildinfo
-.harness/dashboard/.download/
+# >>> walwal-harness managed (local/runtime state — do not edit between markers) >>>
+# Auto-managed by `walwal-harness init` (refreshed on every init).
+# Edit the package template assets/templates/gitignore-append.txt, not this block.
+#
+# SHARED with teammates (kept in git): .harness/{conventions,gotchas,documents,
+#   memories,shared}/  .harness/{memory.md,config.json,HARNESS.md,.bundle-version}
+# Everything listed below is machine-specific runtime or local tooling — never shared.
+#
+# Live conductor todo-queue + transition log (heartbeats churn each tick; embeds local paths)
+.harness/todos/state.json
+.harness/todos/events.jsonl
+# Live conductor / handoff / event state (rewritten every run)
+.harness/progress.json
+.harness/progress.log
+.harness/handoff.json
+.harness/events.jsonl
+# Active-sprint, service-ops, activity heatmap & logs runtime
+.harness/actions/
+.harness/ops/
+.harness/activity/
+.harness/logs/
+# Migration & pre-harness backup snapshots (local-only)
+.harness/archive/
+# Brick Office dashboard — local visualization tool + per-env data & build artifacts
+.harness/dashboard/
+# <<< walwal-harness managed <<<

package/bin/init.js

@@ -20,6 +20,7 @@ const subcommandArgs = args.filter(a => !a.startsWith('-') && a !== subcommand);
 const isAuto = args.includes('--auto');
 const isForce = args.includes('--force');
 const isHelp = args.includes('--help') || args.includes('-h');
+const isWakeEnabled = args.includes('--enable-wake') || process.env.WALWAL_ENABLE_WAKE === '1';
 
 function getOptionValue(name) {
   const eqPrefix = `${name}=`;
@@ -853,6 +854,102 @@ function ensureHarnessEnv() {
   log('.env: HARNESS_BASE_PORT placeholder added — CEO/CXX must choose an available value before starting services');
 }
 
+// ── .gitignore management ───────────────────────────────────────────────────
+// Keep the host project's root .gitignore in sync with the harness's local/runtime
+// state so high-churn conductor files, backups, and dashboard tooling never get
+// committed (and pollute teammates' diffs). The canonical entry list ships in
+// assets/templates/gitignore-append.txt — single source of truth, also consumed by
+// scripts/harness-dashboard-up.sh.
+const GITIGNORE_MARKER_BEGIN = '# >>> walwal-harness managed';
+const GITIGNORE_MARKER_END = '# <<< walwal-harness managed';
+
+function readGitignoreBlock() {
+  const tplPath = path.join(PKG_ROOT, 'assets', 'templates', 'gitignore-append.txt');
+  if (!fileExists(tplPath)) return null;
+  const block = fs.readFileSync(tplPath, 'utf8').replace(/\s+$/, '');
+  return block || null;
+}
+
+// Non-comment, non-empty lines of the managed block = the local/runtime pathspecs.
+function localPathsFromBlock(block) {
+  return block
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith('#'));
+}
+
+// Write or refresh the marked managed block in the project-root .gitignore.
+// Idempotent: an existing block is replaced in place; everything else is preserved.
+function ensureProjectGitignore() {
+  const block = readGitignoreBlock();
+  if (!block) {
+    log('  → .gitignore: skipped (managed template missing)');
+    return;
+  }
+  const gitignorePath = path.join(PROJECT_ROOT, '.gitignore');
+  const original = fileExists(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+  const lines = original.length ? original.split('\n') : [];
+
+  const beginLine = lines.findIndex((l) => l.startsWith(GITIGNORE_MARKER_BEGIN));
+  let next;
+  if (beginLine !== -1) {
+    let endLine = lines.findIndex((l, i) => i >= beginLine && l.startsWith(GITIGNORE_MARKER_END));
+    if (endLine === -1) endLine = lines.length - 1; // tolerate a truncated block
+    next = [...lines.slice(0, beginLine), ...block.split('\n'), ...lines.slice(endLine + 1)].join('\n');
+  } else {
+    const head = original.replace(/\n*$/, '');
+    next = (head ? head + '\n\n' : '') + block + '\n';
+  }
+  if (!next.endsWith('\n')) next += '\n';
+  if (next !== original) {
+    fs.writeFileSync(gitignorePath, next);
+    log(beginLine !== -1
+      ? '  → .gitignore: refreshed walwal-harness managed block'
+      : '  → .gitignore: added walwal-harness runtime/local ignore block');
+  }
+}
+
+// Best-effort: a project that committed runtime state before the ignore block existed
+// keeps showing churn until those paths leave the index. Drop them from tracking
+// (files stay on disk). Never fail init over git: a non-repo / missing-git / odd state
+// is a quiet no-op.
+function gitUntrackLocalState() {
+  const block = readGitignoreBlock();
+  if (!block) return;
+  try {
+    const inside = execSync('git rev-parse --is-inside-work-tree', {
+      cwd: PROJECT_ROOT, stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString().trim();
+    if (inside !== 'true') return;
+  } catch {
+    return; // not a git repo / git unavailable
+  }
+
+  const removed = [];
+  for (const rel of localPathsFromBlock(block)) {
+    let tracked = '';
+    try {
+      tracked = execSync(`git ls-files -- ${shellQuote(rel)}`, {
+        cwd: PROJECT_ROOT, stdio: ['ignore', 'pipe', 'ignore'],
+      }).toString().trim();
+    } catch {
+      continue;
+    }
+    if (!tracked) continue;
+    try {
+      execSync(`git rm -r --cached --quiet --ignore-unmatch -- ${shellQuote(rel)}`, {
+        cwd: PROJECT_ROOT, stdio: ['ignore', 'ignore', 'ignore'],
+      });
+      removed.push(rel);
+    } catch {
+      // leave it tracked; non-fatal
+    }
+  }
+  if (removed.length) {
+    log(`  → git: untracked ${removed.length} now-ignored runtime path(s), kept on disk (${removed.join(', ')})`);
+  }
+}
+
 function ensureStructuredRuntimeFiles({ dryRun = false } = {}) {
   const todosDir = path.join(HARNESS_DIR, 'todos');
   const statePath = path.join(todosDir, 'state.json');
@@ -963,7 +1060,10 @@ function refreshScriptsForMigrate({ dryRun = false, backupDir = null } = {}) {
   chmodShellScripts(scriptsDest);
 }
 
-function ensureWakeScheduler({ dryRun = false } = {}) {
+function ensureWakeScheduler({ dryRun = false, enabled = false } = {}) {
+  if (!enabled || process.env.WALWAL_SKIP_WAKE === '1') {
+    return;
+  }
   const wakeInstall = path.join(PROJECT_ROOT, 'scripts', 'harness-wake-install.sh');
   if (!fs.existsSync(wakeInstall)) return;
 
@@ -1493,6 +1593,7 @@ Usage:
 Runtime (always-on company mode):
   - Stop 훅이 매 turn 종료 시 다음 부서로 자동 연쇄.
   - 1시간 안전망 wake (선택): bash scripts/harness-wake-install.sh install .
+    init/migrate 중 자동 등록하려면 --enable-wake 를 명시하세요.
   - 3D 대시보드 (선택): bash scripts/harness-dashboard-up.sh
   - Owner 입력은 GOAL 모호성, submission, hot-fix, escalation, 결과 보고에만 필요합니다.
 
@@ -2054,7 +2155,7 @@ function runMigrate(opts = {}) {
   // Runtime scripts are package-owned. Migrate must refresh them so existing
   // projects receive wake/meeting/OPS fixes without requiring a full init.
   refreshScriptsForMigrate({ dryRun, backupDir });
-  ensureWakeScheduler({ dryRun });
+  ensureWakeScheduler({ dryRun, enabled: opts.enableWake === true });
   migrateActivityHistory({ dryRun });
   updateRuleRegistryLinks(flags.ruleRegistryLinks || [], { dryRun, backupDir });
 
@@ -2589,7 +2690,7 @@ function main() {
   }
 
   if (subcommand === 'migrate') {
-    runMigrate({ dryRun: args.includes('--dry-run') });
+    runMigrate({ dryRun: args.includes('--dry-run'), enableWake: isWakeEnabled });
     return;
   }
 
@@ -2621,9 +2722,11 @@ function main() {
   console.log('');
 
   scaffoldHarness();
+  ensureProjectGitignore();
+  gitUntrackLocalState();
   installSkills();
   installScripts();
-  ensureWakeScheduler();
+  ensureWakeScheduler({ enabled: isWakeEnabled });
   installCommands();
   installSessionHook();
   installStatusline();
@@ -2684,7 +2787,7 @@ function main() {
   console.log('');
 
   if (subcommand === 'init' && subcommandArgs.includes('migrate')) {
-    runMigrate({ dryRun: args.includes('--dry-run') });
+    runMigrate({ dryRun: args.includes('--dry-run'), enableWake: isWakeEnabled });
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.47",
+  "version": "7.1.49",
   "description": "Company-style AI agent harness for Claude and Codex. Installs commands, CXX agents, skills, HR-Resource hiring pool, and project-local .harness runtime state.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/harness-company-block.sh

@@ -31,6 +31,27 @@ command -v jq >/dev/null 2>&1 || {
   exit 1
 }
 
+state_mtime() {
+  stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0
+}
+
+pick_active_mission_state() {
+  local best=""
+  local best_mtime=0
+  local state active mtime
+  [ -d "$DOCS" ] || return 0
+  while IFS= read -r -d '' state; do
+    active="$(jq -r '.active // false' "$state" 2>/dev/null || echo false)"
+    [ "$active" = "true" ] || continue
+    mtime="$(state_mtime "$state")"
+    if [ "${mtime:-0}" -ge "$best_mtime" ]; then
+      best="$state"
+      best_mtime="${mtime:-0}"
+    fi
+  done < <(find "$DOCS" -name mission-state.json -type f -print0)
+  [ -n "$best" ] && printf '%s\n' "$best"
+}
+
 if ! bash "$SCRIPT_DIR/harness-progress-set.sh" "$PROJECT_ROOT" \
   '.company_state.state = "idle" |
    .conductor.state = "blocked" |
@@ -69,17 +90,17 @@ fi
 
 DOCS="$PROJECT_ROOT/.harness/documents"
 if [ -d "$DOCS" ]; then
-  find "$DOCS" -name mission-state.json -type f -print0 | while IFS= read -r -d '' state; do
-    active="$(jq -r '.active // false' "$state" 2>/dev/null || echo false)"
-    lifecycle="$(jq -r '.lifecycle // .status // "unknown"' "$state" 2>/dev/null || echo unknown)"
+  target_state="$(pick_active_mission_state)"
+  if [ -n "$target_state" ]; then
+    lifecycle="$(jq -r '.lifecycle // .status // "unknown"' "$target_state" 2>/dev/null || echo unknown)"
     case "$lifecycle" in
-      closed|cancelled|superseded|complete|completed|blocked) continue ;;
+      closed|cancelled|superseded|complete|completed|blocked) ;;
+      *)
+        tmp="$(mktemp)"
+        jq --arg r "$REASON" '.lifecycle = "blocked" | .active = false | .blocked_reason = $r | .blocked_at = (now | todate)' "$target_state" > "$tmp" && mv "$tmp" "$target_state"
+        ;;
     esac
-    if [ "$active" = "true" ]; then
-      tmp="$(mktemp)"
-      jq --arg r "$REASON" '.lifecycle = "blocked" | .active = false | .blocked_reason = $r | .blocked_at = (now | todate)' "$state" > "$tmp" && mv "$tmp" "$state"
-    fi
-  done
+  fi
 fi
 
 if command -v node >/dev/null 2>&1 && [ -f "$SCRIPT_DIR/harness-activity-record.js" ]; then

package/scripts/harness-company-complete.sh

@@ -25,6 +25,29 @@ command -v jq >/dev/null 2>&1 || {
   exit 1
 }
 
+state_mtime() {
+  stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0
+}
+
+pick_transition_mission_state() {
+  local best=""
+  local best_mtime=0
+  local state active lifecycle mtime
+  [ -d "$DOCS" ] || return 0
+  while IFS= read -r -d '' state; do
+    active="$(jq -r '.active // false' "$state" 2>/dev/null || echo false)"
+    lifecycle="$(jq -r '.lifecycle // .status // "unknown"' "$state" 2>/dev/null || echo unknown)"
+    if [ "$active" = "true" ] || [ "$lifecycle" = "blocked" ]; then
+      mtime="$(state_mtime "$state")"
+      if [ "${mtime:-0}" -ge "$best_mtime" ]; then
+        best="$state"
+        best_mtime="${mtime:-0}"
+      fi
+    fi
+  done < <(find "$DOCS" -name mission-state.json -type f -print0)
+  [ -n "$best" ] && printf '%s\n' "$best"
+}
+
 if ! bash "$SCRIPT_DIR/harness-progress-set.sh" "$PROJECT_ROOT" \
   '.company_state.state = "idle" |
    .company_state.active_workers = 0 |
@@ -64,19 +87,17 @@ fi
 
 DOCS="$PROJECT_ROOT/.harness/documents"
 if [ -d "$DOCS" ]; then
-  find "$DOCS" -name mission-state.json -type f -print0 | while IFS= read -r -d '' state; do
-    active="$(jq -r '.active // false' "$state" 2>/dev/null || echo false)"
-    lifecycle="$(jq -r '.lifecycle // .status // "unknown"' "$state" 2>/dev/null || echo unknown)"
+  target_state="$(pick_transition_mission_state)"
+  if [ -n "$target_state" ]; then
+    lifecycle="$(jq -r '.lifecycle // .status // "unknown"' "$target_state" 2>/dev/null || echo unknown)"
     case "$lifecycle" in
-      closed|cancelled|superseded|complete|completed) continue ;;
+      closed|cancelled|superseded|complete|completed) ;;
+      *)
+        tmp="$(mktemp)"
+        jq '.lifecycle = "complete" | .active = false | .completed_at = (now | todate) | del(.blocked_reason) | del(.blocked_at)' "$target_state" > "$tmp" && mv "$tmp" "$target_state"
+        ;;
     esac
-    # A mission left "blocked" (active=false) is resumed and completed here, so
-    # clear its blocker fields too — block -> complete must leave no stale state.
-    if [ "$active" = "true" ] || [ "$lifecycle" = "blocked" ]; then
-      tmp="$(mktemp)"
-      jq '.lifecycle = "complete" | .active = false | .completed_at = (now | todate) | del(.blocked_reason) | del(.blocked_at)' "$state" > "$tmp" && mv "$tmp" "$state"
-    fi
-  done
+  fi
 fi
 
 if command -v node >/dev/null 2>&1 && [ -f "$SCRIPT_DIR/harness-activity-record.js" ]; then

package/scripts/harness-dashboard-up.sh

@@ -53,22 +53,27 @@ fi
 
 ensure_gitignore() {
   local gitignore="${HARNESS_ROOT}/.gitignore"
-  local marker="# walwal-harness dashboard runtime"
+  # `walwal-harness init` owns the canonical managed block (covers .harness/dashboard/
+  # plus all other runtime/local state). If it's already present, nothing to add.
+  local managed_marker="# >>> walwal-harness managed"
+  if [[ -f "$gitignore" ]] && grep -Fq "$managed_marker" "$gitignore"; then
+    return
+  fi
+  # Prefer the package's canonical template (single source of truth shared with init.js);
+  # fall back to a dashboard-only block for older packages that lack the template.
+  local tpl="${PACKAGE_ROOT}/assets/templates/gitignore-append.txt"
   local block
-  block="$(cat <<'EOF'
+  if [[ -f "$tpl" ]]; then
+    block="$(cat "$tpl")"
+  else
+    block="$(cat <<'EOF'
 # walwal-harness dashboard runtime
-.harness/dashboard/apps/harness-dashboard/node_modules/
-.harness/dashboard/apps/harness-dashboard/.next/
-.harness/dashboard/apps/harness-dashboard/.turbo/
-.harness/dashboard/apps/harness-dashboard/tsconfig.tsbuildinfo
-.harness/dashboard/.download/
+.harness/dashboard/
 EOF
 )"
-  if [[ -f "$gitignore" ]] && grep -Fq "$marker" "$gitignore"; then
-    return
   fi
   mkdir -p "$(dirname "$gitignore")"
-  if [[ -s "$gitignore" ]] && [[ "$(tail -c 1 "$gitignore" 2>/dev/null || true)" != "" ]]; then
+  if [[ -f "$gitignore" ]] && [[ -s "$gitignore" ]] && [[ "$(tail -c 1 "$gitignore" 2>/dev/null || true)" != "" ]]; then
     printf '\n' >> "$gitignore"
   fi
   printf '%s\n' "$block" >> "$gitignore"
@@ -125,4 +130,4 @@ echo "║  실시간 (SSE) 시각화합니다. Ctrl+C 로 종료.
 echo "╚══════════════════════════════════════════════════════════╝"
 echo ""
 
-HARNESS_ROOT="${HARNESS_ROOT}" npm run dev:dashboard -- -p "${PORT}"
+HARNESS_ROOT="${HARNESS_ROOT}" npm run dev:dashboard -- -H 127.0.0.1 -p "${PORT}"