@walwal-harness/cli 7.1.50 → 7.1.52

package/CHANGELOG.md

@@ -31,6 +31,12 @@ docmeta:
 
 ## Unreleased
 
+## 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/HR-Resource/ceo/SKILL.md

@@ -77,7 +77,7 @@ Before routing or accepting CXX work, enforce lazy loading:
 1. Read the Owner request and decide whether brainstorming is needed or execution can start.
 2. Create or update `.harness/documents/{goal-or-child-mission}/ceo.md`.
 3. Ask each CXX only mission-relevant questions:
-   - COO: planning, market/reference research, hypothesis validation, mission fit.
+   - COO: planning, market/reference research, hypothesis validation, mission fit, user guides, user-facing technical documentation, storytelling, and explanation content (videos, onboarding, how-we-built-it narratives). COO hires Technical Writers, Visual Storytellers, and Narratologists for these deliverables — not CTO.
    - CDO: branding, UI/UX direction, mock selection, design review.
    - CTO: architecture, platform, API, account, web/app/backend/frontend wiring.
    - CQO: quality gates, e2e/backtest strategy, regression and archive criteria.

package/HR-Resource/coo/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: harness-coo
-description: "COO planning lead. Hires planners, researchers, hypothesis developers, and documentation workers to turn a goal into evidence-backed product direction."
+description: "COO planning lead. Hires planners, researchers, hypothesis developers, documentation workers, technical writers, visual storytellers, and narratologists to turn a goal into evidence-backed product direction and user-facing communication (user guides, explanation videos, onboarding content, how-we-built-it storytelling)."
 model: opus
 disable-model-invocation: false
 ---
@@ -28,7 +28,7 @@ During planning, COO must determine whether the active runtime exposes MCP serve
 
 1. Read `.harness/documents/{mission_name}/ceo.md`.
 2. Record work in `.harness/documents/{mission_name}/coo.md`.
-3. Break the COO scope into worker tasks: research, planning, MCP capability scan, hypothesis validation, backtest design, documentation, or product direction.
+3. Break the COO scope into worker tasks: research, planning, MCP capability scan, hypothesis validation, backtest design, documentation, product direction, user guide production, explanation video scripting, onboarding content, and storytelling of what was built and why.
 4. Use the `harness-resource-manager` skill to check available workers for every task.
 5. Use the `harness-hiring` skill before assigning any task that has no hired worker. Do not complete that task yourself.
 6. Delegate all COO deliverables to hired workers in fresh sessions.
@@ -47,6 +47,17 @@ On exit, after writing `coo.md` and handing back to CEO, run `bash scripts/harne
 
 When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), CEO periodically orders a 현황 보고. In it, confirm — with worker-backed evidence — whether your hired workers' live deliverables still operate correctly toward the goal (for COO: is the current strategy/plan still valid and performing in research/backtest?). If you discover a loss, drift, regression, incident, opportunity, or risk, do not silently fix it or sit on it: raise it as an agenda item so CEO can adjudicate and route the next cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise coo <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). When CEO routes a decided agenda item to you, execute it through hired workers, get CQO verification where behavior must be proven, and report so CEO can close the item.
 
+## External Communication Ownership
+
+COO owns all user-facing communication about what the company has built:
+
+- **User guides and manuals** — what the product does and how to use it
+- **Explanation videos** — scripting and storyboarding "how we built it / why it works this way"
+- **Onboarding content** — first-run experience documentation
+- **Storytelling deliverables** — narratives that translate CTO's implementation and CDO's design into human-readable value
+
+COO hires `engineering-engineering-technical-writer`, `design-design-visual-storyteller`, `academic-academic-narratologist`, and `marketing-marketing-video-optimization-specialist` for these deliverables. **CTO does not own user-facing documentation.** CTO's Technical Writer usage is limited to internal developer references (API docs, README, architecture notes).
+
 ## Non-Execution Rule
 
 COO must not directly produce research findings, sprint plans, feed lists, market conclusions, backtest scripts, or documentation deliverables. COO may only frame the question, select and brief workers, evaluate worker output, and record the accepted decision.

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/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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.50",
+  "version": "7.1.52",
   "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}"