@walwal-harness/cli 7.1.47 → 7.1.48

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.

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

@@ -853,6 +853,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');
@@ -2621,6 +2717,8 @@ function main() {
   console.log('');
 
   scaffoldHarness();
+  ensureProjectGitignore();
+  gitUntrackLocalState();
   installSkills();
   installScripts();
   ensureWakeScheduler();

package/package.json

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

@@ -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"