@walwal-harness/cli 7.1.51 → 7.1.53

package/CHANGELOG.md

@@ -4,7 +4,7 @@ docmeta:
   title: walwal-harness CHANGELOG
   type: output
   createdAt: 2026-05-07T00:00:00Z
-  updatedAt: 2026-06-05T00:00:00Z
+  updatedAt: 2026-06-24T00:00:00Z
   source:
     producer: agent
     skillId: harness-release
@@ -31,6 +31,19 @@ docmeta:
 
 ## Unreleased
 
+## 7.1.53 — Write-on-signal documents + `archive/` namespace reclaim (2026-06-24)
+- **`archive/` is now reserved for completed missions, never migrate/init backups.** Every backup snapshot moved out of `.harness/archive/` into a new `.harness/backups/` root: `bin/init.js` (migration snapshot dir, legacy-role migration, pre-harness doc extraction backup, AGENTS/CLAUDE doc backup), `init.sh refresh-ref`, `scripts/init-agents-md.sh`, and `scripts/init-ref-docs.sh`. The Owner expected `archive/` to hold a completed `goal + submission + hot-fix` per goal folder; the harness using it as a migrate backup dump conflicted with that meaning. Files are moved (not deleted), so recovery data is preserved. (Agreement: "archive/ 네임스페이스 탈환".)
+- `.harness/backups/` is added to the managed `.gitignore` block (`assets/templates/gitignore-append.txt`), and **`migrate` now refreshes the host `.gitignore` and best-effort untracks newly-ignored runtime paths** (previously only `init` did this), so migrating projects also stop committing backup/runtime noise.
+- **Hourly review is now write-on-signal.** `scripts/harness-hourly-review.sh` emits a meeting markdown only when the tick carries a real delta — an incident, goal drift, owner escalation, a required-execution contract, a handoff that needs execution, or a change in verdict since the last review. No-delta ticks increment `.meetings.heartbeat_count` instead of writing yet another byte-similar `M-*-hourly` doc (the source of hundreds of boilerplate meeting files). This is safe because the conductor routes off `progress.json` state, not this evidence file, and the no-signal path leaves the last real meeting pointer intact for the `read-decision` fallback. Gated by `company_mode.write_on_signal` (default `true`; `false` restores legacy always-write). (Agreement: 문서 ≠ 텔레메트리 · write-on-signal.)
+- **Wake stops persisting the static prompt.** `scripts/harness-wake.sh` assembles the hourly wake prompt in memory instead of writing a fresh `.harness/actions/wake/wake-<ts>.prompt.md` every tick — those were 100+ byte-identical templates differing only by timestamp/idle/force/review-path. `tmux` mode reuses one overwritten scratch file; each tick appends a single params-only line to `.harness/activity/wake.jsonl` (capped to the last 2000 lines). Per-tick agent logs are written only when an agent actually runs (record mode previously left empty `ops/wake/wake-*.log` files) and are rotated to the most recent 48. (Agreements: 정적 wake.prompt 비영속 · 보존정책 TTL/rotation.)
+- `migrate` injects `company_mode.write_on_signal` into existing `config.json` via a new `configWriteOnSignalMissing` detection, so upgraded projects adopt document suppression automatically.
+
+## 7.1.52 — Single shared dashboard install (drop per-project `node_modules`) (2026-06-23)
+- `scripts/harness-dashboard-up.sh` now installs the Brick Office dashboard **once per version** under `~/.walwal-harness/dashboard/<version>/` (override base with `WALWAL_HARNESS_HOME`) and serves every project from that one copy. Previously each project got its own copy plus a full `npm install`, duplicating identical `node_modules` (~597MB) + `.next` (~75MB) per project — 100 projects cost ~64GB of identical bytes. Now total cost is ~640MB regardless of project count.
+- `npm install` + `next build` run only on the first launch of a given version (guarded by a `.walwal-dashboard-ready` marker and an atomic `mkdir` build lock so concurrent launches don't race). Each project is then served with its own `HARNESS_ROOT` + `--port` via `next start`; since `next start` reads `.next` read-only, many dashboards run concurrently from the same install safely.
+- This is correct because the dashboard code is byte-identical across projects and `HARNESS_ROOT` is resolved at request time (`lib/harness-root.ts`; all routes are `force-dynamic`), so build output never bakes in a project. Supersedes both the pre-7.1.37 per-project-hashed home cache and the 7.1.37 project-local `.harness/dashboard/` copy.
+- `bin/init.js` now writes hook/statusLine commands in `settings.json` as project-root-relative paths (`bash scripts/...`) instead of absolute `PROJECT_ROOT` paths, so moving or renaming a project no longer breaks the harness Stop hook with `No such file` errors.
+
 ## 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.

package/README.md

@@ -164,7 +164,7 @@ Run on a different port:
 bash scripts/harness-dashboard-up.sh --port 3002
 ```
 
-Force-refresh the project-local dashboard runtime when an older dashboard is still shown:
+Force-rebuild the shared dashboard install when an older dashboard is still shown:
 
 ```bash
 bash scripts/harness-dashboard-up.sh --port 3002 --reinstall
@@ -175,9 +175,9 @@ Dashboard options:
 | Option | Role |
 |---|---|
 | `--port <port>` | Run Brick Office on a custom port, e.g. `3002` |
-| `--reinstall` | Delete and rebuild the project-local dashboard runtime under `.harness/dashboard/` |
+| `--reinstall` | Discard and rebuild the shared dashboard install for this version |
 
-The dashboard app copy lives under `.harness/dashboard/` for the current project. Generated dependencies and build output are ignored via `.gitignore`; the runtime files the dashboard reads remain the normal `.harness/` files.
+The dashboard code is identical across all projects, so it is installed **once per version** under `~/.walwal-harness/dashboard/<version>/` and shared by every project — a single `node_modules` plus one production build (`npm install` + `next build`) the first time, then reused. Each project is served with its own `HARNESS_ROOT` and port via `next start`, so you can run many dashboards at once without duplicating dependencies (100 projects still cost ~640MB, not 100×). Override the base directory with `WALWAL_HARNESS_HOME`.
 
 ### Company Auto-Chain State
 

package/assets/templates/config.json

@@ -190,6 +190,8 @@
     "hourly_wake_model_description": "Claude executor 에서 특정 모델을 강제하려면 HARNESS_WAKE_MODEL 또는 이 값을 사용한다. 비워두면 CLI 기본 모델을 사용한다.",
     "hourly_wake_mode": "headless",
     "hourly_wake_mode_description": "headless 는 백그라운드 실행, tmux 는 매시간 별도 tmux 세션, record 는 prompt/log만 생성한다.",
+    "write_on_signal": true,
+    "write_on_signal_description": "true 이면 hourly-review 가 델타(인시던트/목표드리프트/실행계약/판정 변화)가 있는 틱에서만 meeting 문서를 생성하고, 무신호 틱은 .meetings.heartbeat_count 만 증가시킨다. 문서≠텔레메트리·write-on-signal 합의에 따라 동일 boilerplate 문서 폭증을 막는다. false 로 두면 매 틱 문서를 남기는 레거시 동작.",
     "autonomous": true,
     "parallel_by_default": true
   },

package/assets/templates/gitignore-append.txt

@@ -19,7 +19,9 @@
 .harness/ops/
 .harness/activity/
 .harness/logs/
-# Migration & pre-harness backup snapshots (local-only)
+# Migration / init / refresh backup snapshots (local-only — never shared)
+.harness/backups/
+# Completed-mission archive + sprint outputs (local runtime; goal+submission+hot-fix)
 .harness/archive/
 # Brick Office dashboard — local visualization tool + per-env data & build artifacts
 .harness/dashboard/

package/bin/init.js

@@ -190,7 +190,11 @@ function shellQuote(value) {
 }
 
 function harnessScriptCommand(scriptName) {
-  return `bash ${shellQuote(path.join(PROJECT_ROOT, 'scripts', scriptName))}`;
+  // Relative path (resolved from the project root — where Claude Code runs hooks
+  // and the statusLine). A relative path survives the project being moved or
+  // renamed; an absolute PROJECT_ROOT path bakes in the install-time location
+  // and breaks the moment the directory is relocated.
+  return `bash ${shellQuote(path.join('scripts', scriptName))}`;
 }
 
 function replaceHarnessHookCommand(entries, marker, command) {
@@ -282,7 +286,9 @@ function extractMarkdownEntryBlocks(md, prefix) {
 function migrateLegacyRoleEntries(dir, files, kind) {
   const prefix = kind === 'gotchas' ? 'G' : 'C';
   const migrated = [];
-  const backupDir = path.join(HARNESS_DIR, 'archive', 'pre-v7-role-migration');
+  // Backup snapshots live under .harness/backups/, never .harness/archive/ —
+  // archive/ is reserved for completed-mission outputs (goal+submission+hot-fix).
+  const backupDir = path.join(HARNESS_DIR, 'backups', 'pre-v7-role-migration');
   for (const file of files) {
     const sourcePath = path.join(dir, file);
     if (!fs.existsSync(sourcePath)) continue;
@@ -382,8 +388,9 @@ function migrateExistingDocs() {
       continue;
     }
 
-    // Backup
-    const backupPath = path.join(HARNESS_DIR, 'archive', `pre-harness-${path.basename(docPath)}.bak`);
+    // Backup (under .harness/backups/, not archive/ — archive holds completed missions)
+    const backupPath = path.join(HARNESS_DIR, 'backups', `pre-harness-${path.basename(docPath)}.bak`);
+    ensureDir(path.dirname(backupPath));
     fs.writeFileSync(backupPath, content);
     report.push(`Backed up: ${docPath} → ${backupPath}`);
 
@@ -460,7 +467,7 @@ function migrateExistingDocs() {
     ``,
     `## Backups`,
     ``,
-    `Original documents were preserved in \`.harness/archive/pre-harness-*.md.bak\`.`,
+    `Original documents were preserved in \`.harness/backups/pre-harness-*.md.bak\`.`,
     ``
   ].join('\n');
   fs.writeFileSync(reportPath, reportContent);
@@ -1421,7 +1428,7 @@ function normalizeDocBody(body) {
 
 function ensureProjectAgentDocs(opts = {}) {
   const dryRun = opts.dryRun || false;
-  const backupDir = opts.backupDir || path.join(HARNESS_DIR, 'archive', 'pre-harness-backup');
+  const backupDir = opts.backupDir || path.join(HARNESS_DIR, 'backups', 'pre-harness-backup');
   const agentsMd = path.join(PROJECT_ROOT, 'AGENTS.md');
   const claudeMd = path.join(PROJECT_ROOT, 'CLAUDE.md');
 
@@ -1481,7 +1488,7 @@ function ensureProjectAgentDocs(opts = {}) {
 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') });
+  ensureProjectAgentDocs({ backupDir: path.join(HARNESS_DIR, 'backups', 'pre-harness-backup') });
 }
 
 // ─────────────────────────────────────────
@@ -1638,6 +1645,7 @@ function detectMigrationNeeded() {
     configLegacyRouting: false,
     configRuntimeVerificationMissing: false,
     configWakeModelMissing: false,
+    configWriteOnSignalMissing: false,
     coreSkillsStale: false,
     hrResourcePoolStale: false,
     harnessMdStale: false,
@@ -1747,6 +1755,9 @@ function detectMigrationNeeded() {
       if (c.company_mode && c.company_mode.hourly_wake_model === undefined) {
         flags.configWakeModelMissing = true;
       }
+      if (c.company_mode && c.company_mode.write_on_signal === undefined) {
+        flags.configWriteOnSignalMissing = true;
+      }
       if (
         c.behavior?.auto_route_dispatcher !== undefined ||
         c.behavior?.auto_route_dispatcher_description ||
@@ -2031,6 +2042,10 @@ function showMigrationProposal(flags) {
     console.log('  • config.json: company_mode.hourly_wake_model 추가 가능');
     console.log('    Claude wake tick 에서 --model 을 환경변수/설정으로 지정할 수 있습니다.');
   }
+  if (flags.configWriteOnSignalMissing) {
+    console.log('  • config.json: company_mode.write_on_signal 추가 가능');
+    console.log('    무신호(델타 부재) 틱은 meeting 문서 대신 heartbeat 만 남겨 문서 폭증을 막습니다.');
+  }
   if (flags.configLegacyRouting) {
     console.log('  • config.json: legacy dispatcher/conductor wording → v7 CEO/CXX wording');
   }
@@ -2087,7 +2102,7 @@ function showMigrationProposal(flags) {
   console.log('  미리보기:  npx walwal-harness migrate --dry-run');
   console.log('');
   console.log('  ※ 자동 강제 X — 사용자가 명령을 실행할 때만 변경됩니다.');
-  console.log('  ※ 변경 전 .harness/archive/migration-<ts>/ 에 자동 백업.');
+  console.log('  ※ 변경 전 .harness/backups/migration-<ts>/ 에 자동 백업 (archive/ 는 완료 미션 전용).');
   console.log('');
 }
 
@@ -2114,6 +2129,7 @@ function runMigrate(opts = {}) {
     !flags.configLegacyRouting &&
     !flags.configRuntimeVerificationMissing &&
     !flags.configWakeModelMissing &&
+    !flags.configWriteOnSignalMissing &&
     !flags.coreSkillsStale &&
     !flags.hrResourcePoolStale &&
     !flags.harnessMdStale &&
@@ -2140,9 +2156,20 @@ function runMigrate(opts = {}) {
   log(dryRun ? '=== DRY RUN — 실제 변경 없음 ===' : '=== Migration 적용 ===');
 
   const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  const backupDir = path.join(HARNESS_DIR, 'archive', `migration-${ts}`);
+  // Migration backups go to .harness/backups/, not .harness/archive/. archive/ is
+  // the completed-mission namespace (goal+submission+hot-fix); it must not collect
+  // migrate snapshots. (Owner agreement: "archive/ 네임스페이스 탈환".)
+  const backupDir = path.join(HARNESS_DIR, 'backups', `migration-${ts}`);
   if (!dryRun) ensureDir(backupDir);
   ensureStructuredRuntimeFiles({ dryRun });
+  // Keep the host .gitignore in sync so migrating projects also ignore the new
+  // .harness/backups/ snapshot root (and drop any previously-tracked runtime noise).
+  if (!dryRun) {
+    ensureProjectGitignore();
+    gitUntrackLocalState();
+  } else {
+    log('  (dry-run) .gitignore: walwal-harness managed block refresh 예정 (.harness/backups/ 포함)');
+  }
   ensureProjectAgentDocs({ dryRun, backupDir });
   flags.agentsMissingOpsVerificationRules = false;
   flags.agentsMissingCodexAdapterRules = false;
@@ -2190,7 +2217,7 @@ function runMigrate(opts = {}) {
   // 2. config.json — inject company_mode/runtime verification from template if missing
   const configPath = path.join(HARNESS_DIR, 'config.json');
   const tplPath = path.join(PKG_ROOT, 'assets', 'templates', 'config.json');
-  if ((flags.configMissingCompanyMode || flags.configLegacyRouting || flags.configRuntimeVerificationMissing || flags.configWakeModelMissing) && fs.existsSync(configPath) && fs.existsSync(tplPath)) {
+  if ((flags.configMissingCompanyMode || flags.configLegacyRouting || flags.configRuntimeVerificationMissing || flags.configWakeModelMissing || flags.configWriteOnSignalMissing) && fs.existsSync(configPath) && fs.existsSync(tplPath)) {
     const original = fs.readFileSync(configPath, 'utf8');
     const c = JSON.parse(original);
     const tpl = JSON.parse(fs.readFileSync(tplPath, 'utf8'));
@@ -2221,6 +2248,13 @@ function runMigrate(opts = {}) {
         configChanged = true;
         log('  config.json: hourly_wake_model 섹션 동기화');
       }
+      if (flags.configWriteOnSignalMissing) {
+        c.company_mode = c.company_mode || {};
+        c.company_mode.write_on_signal = tpl.company_mode.write_on_signal ?? true;
+        c.company_mode.write_on_signal_description = tpl.company_mode.write_on_signal_description;
+        configChanged = true;
+        log('  config.json: write_on_signal (무신호 틱 문서 억제) 섹션 동기화');
+      }
       if (flags.configRuntimeVerificationMissing && tpl.runtime?.verification) {
         c.runtime = c.runtime || {};
         c.runtime.verification = deepMerge(tpl.runtime.verification, c.runtime.verification || {});

package/init.sh

@@ -181,13 +181,15 @@ run_refresh_ref() {
   fi
 
   local ref_path="${project_root}/.harness/ref/${role}-${stack}.md"
-  local archive_dir="${project_root}/.harness/archive"
-  mkdir -p "$archive_dir"
+  # Ref backups go to .harness/backups/, not .harness/archive/. archive/ is the
+  # completed-mission namespace and must not collect tooling backups.
+  local backups_dir="${project_root}/.harness/backups/refs"
+  mkdir -p "$backups_dir"
 
   if [ -f "$ref_path" ]; then
-    local backup="${archive_dir}/ref-${role}-${stack}-$(date +%Y%m%d%H%M%S).md"
+    local backup="${backups_dir}/ref-${role}-${stack}-$(date +%Y%m%d%H%M%S).md"
     mv "$ref_path" "$backup"
-    echo "archive: $backup"
+    echo "backup: $backup"
   fi
 
   echo ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.51",
+  "version": "7.1.53",
   "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-dashboard-up.sh

@@ -1,14 +1,23 @@
 #!/usr/bin/env bash
-# walwal-harness — Brick Office dashboard launcher
+# walwal-harness — Brick Office dashboard launcher (shared single-install)
 #
-# 처음 쓰는 사용자도 한 줄로 대시보드를 띄워볼 수 있게 만든 helper.
-# npm 패키지에 포함된 apps/harness-dashboard 를 프로젝트별 runtime 영역
-# (.harness/dashboard/) 에 복사 후 dev 실행한다.
-# 구버전 호환을 위해 패키지에 dashboard 가 없으면 git sparse-checkout 으로 fallback 한다.
+# 대시보드 코드는 모든 프로젝트에서 byte 단위로 동일하다 (패키지가 버전 고정으로
+# 배포). 프로젝트마다 다른 것은 HARNESS_ROOT(어느 .harness/ 를 볼지)와 PORT 뿐이고,
+# HARNESS_ROOT 는 lib/harness-root.ts 가 *런타임*에 읽는다. 따라서 설치본은 하나면
+# 충분하다.
+#
+# 이 런처는 버전별 단일 설치본을 ~/.walwal-harness/dashboard/<version>/ 에 두고
+# (npm install + next build 를 버전당 딱 한 번), 각 프로젝트는 HARNESS_ROOT+PORT 만
+# 바꿔 `next start` 로 띄운다. next start 는 .next 를 읽기전용으로 쓰므로 같은 폴더에서
+# 여러 프로젝트를 동시에 서빙해도 안전하다. 프로젝트가 100개여도 node_modules/.next 는
+# 단 1벌(~640MB).
+#
+# 구버전 호환: 패키지에 dashboard 가 없으면 git sparse-checkout 으로 fallback 한다.
 #
 # Usage:
-#   bash scripts/harness-dashboard-up.sh                 # install + dev (port 3001)
+#   bash scripts/harness-dashboard-up.sh                 # build(최초 1회) + serve (port 3001)
 #   bash scripts/harness-dashboard-up.sh --port 3050     # override port
+#   bash scripts/harness-dashboard-up.sh --reinstall     # 공유 설치본 폐기 후 재빌드
 #   HARNESS_ROOT=/path/to/project bash ...               # explicit harness root
 set -euo pipefail
 
@@ -23,12 +32,13 @@ while [[ $# -gt 0 ]]; do
     --port) PORT="$2"; shift 2 ;;
     --reinstall) REINSTALL=true; shift ;;
     --help|-h)
-      sed -n '2,16p' "$0"
+      sed -n '2,28p' "$0"
       exit 0 ;;
     *) echo "[brick-office] unknown arg: $1" >&2; exit 2 ;;
   esac
 done
 
+# --- target project (the one whose .harness/ we visualize) ---
 if [[ -z "${HARNESS_ROOT:-}" ]]; then
   HARNESS_ROOT="$(pwd)"
 fi
@@ -38,87 +48,91 @@ if [[ ! -d "${HARNESS_ROOT}/.harness" ]]; then
   exit 3
 fi
 
-LOCAL_DIR="${HARNESS_ROOT}/.harness/dashboard"
-VERSION_FILE="${LOCAL_DIR}/.walwal-dashboard-version"
-
+# --- locate the packaged dashboard source + its version ---
 PACKAGE_ROOT="${HARNESS_ROOT}/node_modules/@walwal-harness/cli"
 PACKAGED_DASHBOARD="${PACKAGE_ROOT}/${DASHBOARD_PATH}"
 if [[ -f "${PACKAGE_ROOT}/package.json" ]]; then
   PACKAGE_VERSION="$(node -p "require('${PACKAGE_ROOT}/package.json').version" 2>/dev/null || echo unknown)"
 fi
 
+# --- shared, version-keyed install (the whole point: one copy for ALL projects) ---
+SHARED_BASE="${WALWAL_HARNESS_HOME:-$HOME/.walwal-harness}/dashboard"
+VERSION_KEY="${PACKAGE_VERSION}"
+[[ "$VERSION_KEY" == "unknown" || -z "$VERSION_KEY" ]] && VERSION_KEY="edge"
+SHARED_DIR="${SHARED_BASE}/${VERSION_KEY}"           # node_modules + .next + source live here
+READY_MARKER="${SHARED_DIR}/.walwal-dashboard-ready" # written only after a successful build
+LOCK_DIR="${SHARED_BASE}/.build-lock-${VERSION_KEY}" # mkdir-based build mutex (atomic)
+
 if [[ "$REINSTALL" == "true" ]]; then
-  rm -rf "$LOCAL_DIR"
+  rm -rf "$SHARED_DIR"
 fi
 
-ensure_gitignore() {
-  local gitignore="${HARNESS_ROOT}/.gitignore"
-  # `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
-  if [[ -f "$tpl" ]]; then
-    block="$(cat "$tpl")"
+echo "[brick-office] HARNESS_ROOT   = ${HARNESS_ROOT}"
+echo "[brick-office] shared install = ${SHARED_DIR}  (version ${VERSION_KEY})"
+
+# Copy the dashboard source into the shared dir. Leaves any existing node_modules
+# in place (the package tarball ships no node_modules), so a re-entry after a failed
+# build keeps the installed deps.
+populate_source() {
+  mkdir -p "$SHARED_DIR"
+  if [[ -d "${PACKAGED_DASHBOARD}" ]]; then
+    cp -R "${PACKAGED_DASHBOARD}/." "${SHARED_DIR}/"
   else
-    block="$(cat <<'EOF'
-# walwal-harness dashboard runtime
-.harness/dashboard/
-EOF
-)"
-  fi
-  mkdir -p "$(dirname "$gitignore")"
-  if [[ -f "$gitignore" ]] && [[ -s "$gitignore" ]] && [[ "$(tail -c 1 "$gitignore" 2>/dev/null || true)" != "" ]]; then
-    printf '\n' >> "$gitignore"
+    echo "[brick-office] 패키지에 dashboard 없음 — git sparse-checkout fallback (~5MB)."
+    local dl="${SHARED_BASE}/.download-${VERSION_KEY}"
+    rm -rf "$dl"; mkdir -p "$dl"
+    (
+      cd "$dl"
+      git init -q
+      git remote add origin "${REPO_URL}" 2>/dev/null || true
+      git config core.sparseCheckout true
+      echo "${DASHBOARD_PATH}/" > .git/info/sparse-checkout
+      git fetch --depth=1 origin main -q
+      git checkout main -q
+    )
+    cp -R "${dl}/${DASHBOARD_PATH}/." "${SHARED_DIR}/"
+    rm -rf "$dl"
   fi
-  printf '%s\n' "$block" >> "$gitignore"
 }
 
-ensure_gitignore
+# build = install deps + production build, guarded by a single-writer lock so two
+# projects launching at once don't race on the same shared dir. The EXIT trap is a
+# safety net: under `set -e` a failed npm install / next build aborts the script, and
+# the trap then frees the lock (and leaves no READY_MARKER → next launch rebuilds).
+build_shared() {
+  local waited=0
+  mkdir -p "$SHARED_BASE"   # lock dir is created with plain mkdir, so its parent must exist
+  while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+    # someone else finished the build while we were waiting → done, nothing to own.
+    [[ -f "$READY_MARKER" ]] && return 0
+    sleep 1; waited=$((waited + 1))
+    if (( waited > 600 )); then
+      echo "[brick-office] stale build lock (>10m) — 강제 해제." >&2
+      rm -rf "$LOCK_DIR"
+    fi
+  done
+  trap 'rm -rf "$LOCK_DIR"' EXIT
 
-echo "[brick-office] HARNESS_ROOT = ${HARNESS_ROOT}"
-echo "[brick-office] dashboard runtime path = ${LOCAL_DIR}"
-
-if [[ -d "${PACKAGED_DASHBOARD}" ]]; then
-  INSTALLED_VERSION=""
-  if [[ -f "${VERSION_FILE}" ]]; then
-    INSTALLED_VERSION="$(cat "${VERSION_FILE}" 2>/dev/null || true)"
-  fi
-  if [[ ! -d "${LOCAL_DIR}/${DASHBOARD_PATH}" || "${INSTALLED_VERSION}" != "${PACKAGE_VERSION}" ]]; then
-    echo "[brick-office] dashboard sync from npm package @walwal-harness/cli@${PACKAGE_VERSION}"
-    rm -rf "${LOCAL_DIR:?}/${DASHBOARD_PATH}"
-    mkdir -p "${LOCAL_DIR}/apps"
-    cp -R "${PACKAGED_DASHBOARD}" "${LOCAL_DIR}/apps/"
-    printf '%s\n' "${PACKAGE_VERSION}" > "${VERSION_FILE}"
+  # double-checked: another waiter may have built it just before we got the lock.
+  if [[ -f "$READY_MARKER" && "$(cat "$READY_MARKER" 2>/dev/null || true)" == "$VERSION_KEY" ]]; then
+    rm -rf "$LOCK_DIR"; trap - EXIT; return 0
   fi
-elif [[ ! -d "${LOCAL_DIR}/${DASHBOARD_PATH}" ]]; then
-  echo "[brick-office] 첫 실행 — git sparse-checkout 으로 dashboard 만 가져옵니다 (~5MB)."
-  rm -rf "${LOCAL_DIR}/.download"
-  mkdir -p "${LOCAL_DIR}/.download"
-  cd "${LOCAL_DIR}/.download"
-  git init -q
-  git remote add origin "${REPO_URL}" 2>/dev/null || true
-  git config core.sparseCheckout true
-  echo "${DASHBOARD_PATH}/" > .git/info/sparse-checkout
-  git fetch --depth=1 origin main -q
-  git checkout main -q
-  mkdir -p "${LOCAL_DIR}/apps"
-  rm -rf "${LOCAL_DIR:?}/${DASHBOARD_PATH}"
-  cp -R "${DASHBOARD_PATH}" "${LOCAL_DIR}/apps/"
-  rm -rf "${LOCAL_DIR}/.download"
-  echo "[brick-office] 다운로드 완료."
-fi
 
-cd "${LOCAL_DIR}/${DASHBOARD_PATH}"
+  [[ -f "${SHARED_DIR}/package.json" ]] || populate_source
+
+  echo "[brick-office] npm install (버전당 1회, ~30s)..."
+  ( cd "$SHARED_DIR" && npm install --no-audit --no-fund --loglevel=error )
+
+  echo "[brick-office] next build (버전당 1회)..."
+  ( cd "$SHARED_DIR" && ./node_modules/.bin/next build )
+
+  printf '%s\n' "$VERSION_KEY" > "$READY_MARKER"
+  echo "[brick-office] 빌드 완료 — 이후 모든 프로젝트가 이 설치본을 공유합니다."
+  rm -rf "$LOCK_DIR"; trap - EXIT
+}
 
-if [[ ! -d node_modules ]]; then
-  echo "[brick-office] npm install (한 번만 실행, ~30s)..."
-  npm install --no-audit --no-fund --loglevel=error
+if [[ ! -f "$READY_MARKER" || "$(cat "$READY_MARKER" 2>/dev/null || true)" != "$VERSION_KEY" ]]; then
+  build_shared
 fi
 
 echo ""
@@ -130,4 +144,5 @@ echo "║  실시간 (SSE) 시각화합니다. Ctrl+C 로 종료.
 echo "╚══════════════════════════════════════════════════════════╝"
 echo ""
 
-HARNESS_ROOT="${HARNESS_ROOT}" npm run dev:dashboard -- -H 127.0.0.1 -p "${PORT}"
+cd "$SHARED_DIR"
+HARNESS_ROOT="${HARNESS_ROOT}" exec ./node_modules/.bin/next start -H 127.0.0.1 -p "${PORT}"

package/scripts/harness-hourly-review.sh

@@ -40,7 +40,9 @@ meeting_rel=".harness/actions/meetings/$id/meeting-$id.md"
 meeting_path="$PROJECT_ROOT/$meeting_rel"
 log_path="$PROJECT_ROOT/.harness/progress.log"
 
-mkdir -p "$meeting_dir"
+# meeting_dir is created lazily, only when this tick actually has a signal worth a
+# meeting doc (see the write-on-signal gate below). No-signal ticks must not even
+# leave an empty M-*-hourly directory behind.
 
 ops_report=""
 if [ -x "$SCRIPT_DIR/harness-service-ops-monitor.sh" ]; then
@@ -300,6 +302,49 @@ if [ "$verdict" = "working" ] && [ "$handoff_requires_execution" = "true" ]; the
     }')"
 fi
 
+# ── Write-on-signal gate ────────────────────────────────────────────────────
+# Agreement: 문서 ≠ 텔레메트리. A no-delta hourly tick must not emit yet another
+# identical meeting doc — it bumps a heartbeat counter instead. A "signal" is an
+# incident, goal drift, owner escalation, a required-execution contract, a handoff
+# that needs execution, or a change in verdict since the last recorded review.
+# Control flow (conductor-tick.sh) routes off progress.json state, not this file,
+# so suppressing the markdown on quiet ticks is safe.
+write_on_signal="$(jq -r '.company_mode.write_on_signal // true' "$CONFIG" 2>/dev/null || echo true)"
+last_verdict="$(jq -r '.meetings.last_reason // ""' "$PROGRESS" 2>/dev/null || echo "")"
+has_signal=true
+if [ "$write_on_signal" = "true" ]; then
+  has_signal=false
+  case "$verdict" in
+    incident|goal_drift|owner_needed) has_signal=true ;;
+  esac
+  [ "$required_execution_json" != "null" ] && has_signal=true
+  [ "$handoff_requires_execution" = "true" ] && has_signal=true
+  # A change in verdict since the last recorded review is a state transition worth a
+  # minute (this also makes the first-ever review a signal, since last_verdict is "").
+  [ "$verdict" != "$last_verdict" ] && has_signal=true
+fi
+
+if [ "$has_signal" != "true" ]; then
+  # No delta — heartbeat only. Keep service-ops health fresh, leave the last real
+  # meeting pointer intact (read-decision fallback still resolves), and record that
+  # this tick was a quiet checkpoint rather than a meeting.
+  jq --arg ts "$ts" --arg verdict "$verdict" '
+    .meetings.last_reason = $verdict |
+    .meetings.last_review_at = $ts |
+    .meetings.heartbeat_count = ((.meetings.heartbeat_count // 0) + 1) |
+    .meetings.last_heartbeat_at = $ts |
+    .meetings.last_heartbeat_verdict = $verdict |
+    .service_ops.monitor.last_hourly_review = $ts
+  ' "$PROGRESS" > "${PROGRESS}.tmp" && mv "${PROGRESS}.tmp" "$PROGRESS" || { rm -f "${PROGRESS}.tmp"; exit 1; }
+  hb="$(jq -r '.meetings.heartbeat_count // 0' "$PROGRESS" 2>/dev/null || echo '?')"
+  echo "$ts | meeting-manager | hourly-heartbeat | $verdict | no-signal (heartbeat #$hb, no meeting doc)" >> "$log_path"
+  # stdout: last real meeting path so the wake prompt keeps context (empty if none).
+  jq -r '.meetings.last_review_path // empty' "$PROGRESS" 2>/dev/null || true
+  exit 0
+fi
+
+mkdir -p "$meeting_dir"
+
 decision_json="$(jq -n \
   --arg owner "$decision_owner" \
   --arg action_type "$decision_action" \

package/scripts/harness-wake.sh

@@ -130,7 +130,7 @@ start_headless_tick() {
   local idle="$2"
   local force="$3"
   local review_path="$4"
-  local mode executor wake_model agent_bin stamp wake_dir ops_dir prompt_rel log_rel prompt_path log_path pid_file old_pid pid status tmux_session session_name session_safe
+  local mode executor wake_model agent_bin stamp ops_dir activity_dir prompt_scratch log_rel log_path pid_file old_pid pid status tmux_session session_name session_safe wake_prompt log_note
 
   if command -v jq >/dev/null 2>&1 && [ -f "$project_root/.harness/config.json" ]; then
     mode="${HARNESS_WAKE_MODE:-$(jq -r '.company_mode.hourly_wake_mode // "headless"' "$project_root/.harness/config.json" 2>/dev/null || echo headless)}"
@@ -142,13 +142,17 @@ start_headless_tick() {
     wake_model="${HARNESS_WAKE_MODEL:-}"
   fi
   stamp="$(date -u "+%Y%m%dT%H%M%SZ")"
-  wake_dir="$project_root/.harness/actions/wake"
   ops_dir="$project_root/.harness/ops/wake"
-  mkdir -p "$wake_dir" "$ops_dir"
-
-  prompt_rel=".harness/actions/wake/wake-${stamp}.prompt.md"
+  activity_dir="$project_root/.harness/activity"
+  mkdir -p "$ops_dir" "$activity_dir"
+
+  # The wake prompt is a static template parameterized only by project/idle/force/
+  # review-path. Per the write-on-signal agreement we assemble it in memory rather
+  # than persisting a fresh wake-<ts>.prompt.md every tick (those 100+ identical
+  # templates were pure noise). tmux mode, which feeds the prompt over stdin, reuses
+  # one overwritten scratch file instead of N timestamped ones.
+  prompt_scratch="$ops_dir/current.prompt.md"
   log_rel=".harness/ops/wake/wake-${stamp}.log"
-  prompt_path="$project_root/$prompt_rel"
   log_path="$project_root/$log_rel"
   pid_file="$ops_dir/wake.pid"
 
@@ -160,7 +164,7 @@ start_headless_tick() {
     fi
   fi
 
-  cat > "$prompt_path" <<EOF
+  wake_prompt="$(cat <<EOF
 You are harness-ceo waking for the walwal-harness hourly executive loop.
 
 Project root: $project_root
@@ -219,7 +223,11 @@ Required final shape for this tick:
 - NEXT checkpoint:
 - Evidence paths:
 EOF
+)"
 
+  # log_note tracks the on-disk artifact for this tick. record mode and
+  # BLOCKED_RUNTIME never spawn an agent, so they leave no (previously empty) log.
+  log_note="(none)"
   case "$mode" in
     record)
       status="recorded"
@@ -229,18 +237,19 @@ EOF
         (
           cd "$project_root" || exit 1
           if [ "$executor" = "codex" ]; then
-            "$agent_bin" exec -C "$project_root" "$(cat "$prompt_path")" > "$log_path" 2>&1
+            "$agent_bin" exec -C "$project_root" "$wake_prompt" > "$log_path" 2>&1
           else
             if [ -n "$wake_model" ]; then
-              "$agent_bin" -p "$(cat "$prompt_path")" --model "$wake_model" > "$log_path" 2>&1
+              "$agent_bin" -p "$wake_prompt" --model "$wake_model" > "$log_path" 2>&1
             else
-              "$agent_bin" -p "$(cat "$prompt_path")" > "$log_path" 2>&1
+              "$agent_bin" -p "$wake_prompt" > "$log_path" 2>&1
             fi
           fi
         ) &
         pid=$!
         echo "$pid" > "$pid_file"
         status="spawned executor=$executor pid=$pid"
+        log_note="$log_rel"
       else
         status="BLOCKED_RUNTIME ${executor}-not-found"
       fi
@@ -249,18 +258,20 @@ EOF
       if ! command -v tmux >/dev/null 2>&1; then
         status="BLOCKED_RUNTIME tmux-not-found"
       elif agent_bin="$(resolve_agent_bin "$executor")"; then
+        printf '%s\n' "$wake_prompt" > "$prompt_scratch"
         session_safe="$(basename "$project_root" | tr -c '[:alnum:]_' '_')"
         session_name="walwal_${session_safe}_${stamp}"
         if [ "$executor" = "codex" ]; then
-          tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' exec -C '$project_root' - < '$prompt_path' 2>&1 | tee '$log_path'"
+          tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' exec -C '$project_root' - < '$prompt_scratch' 2>&1 | tee '$log_path'"
         else
           if [ -n "$wake_model" ]; then
-            tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' -p \"\$(cat '$prompt_path')\" --model '$wake_model' 2>&1 | tee '$log_path'"
+            tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' -p \"\$(cat '$prompt_scratch')\" --model '$wake_model' 2>&1 | tee '$log_path'"
           else
-            tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' -p \"\$(cat '$prompt_path')\" 2>&1 | tee '$log_path'"
+            tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' -p \"\$(cat '$prompt_scratch')\" 2>&1 | tee '$log_path'"
           fi
         fi
         status="spawned-tmux executor=$executor session=$session_name"
+        log_note="$log_rel"
       else
         status="BLOCKED_RUNTIME ${executor}-not-found"
       fi
@@ -270,13 +281,41 @@ EOF
       ;;
   esac
 
-  echo "$(date -u "+%Y-%m-%dT%H:%M:%SZ") | wake | agent-tick | $status | idle=${idle}s | force=${force} | mode=${mode} | prompt=$prompt_rel | log=$log_rel" >> "$project_root/.harness/progress.log"
-  say "wake-agent: $project_root (idle ${idle}s, force=${force}, mode=${mode}, executor=${executor}) → $status $log_rel"
+  # Per-tick wake telemetry = one params-only line, not a full prompt copy. This
+  # is the "if you must keep something, keep one line in activity.jsonl" path from
+  # the wake-template agreement, with rotation so it never grows unbounded.
+  if command -v jq >/dev/null 2>&1; then
+    jq -nc \
+      --arg ts "$(date -u "+%Y-%m-%dT%H:%M:%SZ")" \
+      --arg stamp "$stamp" \
+      --argjson idle "${idle:-0}" \
+      --arg force "$force" \
+      --arg mode "$mode" \
+      --arg executor "$executor" \
+      --arg status "$status" \
+      --arg review "${review_path:-}" \
+      --arg log "$log_note" \
+      '{ts:$ts,stamp:$stamp,idle:$idle,force:$force,mode:$mode,executor:$executor,status:$status,review:$review,log:$log}' \
+      >> "$activity_dir/wake.jsonl" 2>/dev/null || true
+    if [ -f "$activity_dir/wake.jsonl" ] && tail -n 2000 "$activity_dir/wake.jsonl" > "$activity_dir/wake.jsonl.tmp" 2>/dev/null; then
+      mv "$activity_dir/wake.jsonl.tmp" "$activity_dir/wake.jsonl"
+    else
+      rm -f "$activity_dir/wake.jsonl.tmp" 2>/dev/null || true
+    fi
+  fi
+
+  # Rotate per-tick agent logs: keep only the most recent 48 (~2 days hourly).
+  ls -1t "$ops_dir"/wake-*.log 2>/dev/null | tail -n +49 | while IFS= read -r old_log; do
+    rm -f "$old_log"
+  done
+
+  echo "$(date -u "+%Y-%m-%dT%H:%M:%SZ") | wake | agent-tick | $status | idle=${idle}s | force=${force} | mode=${mode} | log=$log_note" >> "$project_root/.harness/progress.log"
+  say "wake-agent: $project_root (idle ${idle}s, force=${force}, mode=${mode}, executor=${executor}) → $status $log_note"
 
   run_conductor_fallback "$project_root" "$status"
 
   if tmux_session="$(find_tmux_session "$project_root" 2>/dev/null)"; then
-    tmux display-message -t "$tmux_session" "walwal wake headless tick: $status ($log_rel)" 2>/dev/null || true
+    tmux display-message -t "$tmux_session" "walwal wake headless tick: $status ($log_note)" 2>/dev/null || true
   fi
 }
 

package/scripts/init-agents-md.sh

@@ -8,7 +8,8 @@ SCAN_RESULT="${PROJECT_ROOT}/.harness/actions/scan-result.json"
 export SCAN_RESULT PROJECT_ROOT
 AGENTS_FILE="${PROJECT_ROOT}/AGENTS.md"
 CLAUDE_FILE="${PROJECT_ROOT}/CLAUDE.md"
-BACKUP_DIR="${PROJECT_ROOT}/.harness/archive/pre-harness-backup"
+# Backups live under .harness/backups/, not archive/ (archive = completed missions).
+BACKUP_DIR="${PROJECT_ROOT}/.harness/backups/pre-harness-backup"
 
 if [ ! -f "$SCAN_RESULT" ]; then
   echo "ERROR: scan-result.json not found. Run scan-project.sh first."

package/scripts/init-ref-docs.sh

@@ -44,8 +44,9 @@ done
 SCAN="${PROJECT_ROOT}/.harness/actions/scan-result.json"
 REF_DIR="${PROJECT_ROOT}/.harness/ref"
 META="${REF_DIR}/.generated.json"
-ARCHIVE_DIR="${PROJECT_ROOT}/.harness/archive"
-mkdir -p "$REF_DIR" "$ARCHIVE_DIR"
+# Ref backups go to .harness/backups/refs, not archive/ (archive = completed missions).
+BACKUP_DIR="${PROJECT_ROOT}/.harness/backups/refs"
+mkdir -p "$REF_DIR" "$BACKUP_DIR"
 [ -f "$META" ] || echo "{}" > "$META"
 
 # ───── 감지된 스택 목록 ─────
@@ -192,9 +193,9 @@ process_one() {
     return 0
   fi
   if [ -f "$path" ] && $REFRESH; then
-    local backup="${ARCHIVE_DIR}/ref-${role}-${stack}-$(date +%Y%m%d%H%M%S).md"
+    local backup="${BACKUP_DIR}/ref-${role}-${stack}-$(date +%Y%m%d%H%M%S).md"
     cp "$path" "$backup"
-    echo "archived: $backup"
+    echo "backup: $backup"
   fi
 
   local answer="y"