taskforce-loop-engineering 0.15.11 → 0.15.13

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 0.15.13 - 2026-08-28
+
+- Add the project-first read-only operator workspace with terminal contracts, milestone/project status separation, revision lineage, human gates, external-action reservations, and acceptance/final-judge timelines.
+- Couple the Dashboard service to OpenClaw and Hermes gateway startup and verify the wiring in platform doctors and installer self-tests.
+- Support fail-closed `localhost` and Tailnet-only Dashboard listening modes without binding all network interfaces.
+
+## 0.15.12 - 2026-08-28
+
+- Fix public CI setup on repositories that intentionally do not commit an npm lockfile.
+
 ## 0.15.11 - 2026-08-28
 
 - Add a transactional state kernel with typed effects, receipt chaining, CAS/fencing, exact-effect replay, crash recovery, and completion fencing.

package/README.md

@@ -39,7 +39,7 @@ when publication is separately approved.
 
 ## Read-only operator dashboard (P3)
 
-Version 0.12 adds a dependency-free operator projection over projects, queues, P0 gates, P1 action reservations and P2 typed todo ownership. Use `dashboard-inspect`, `dashboard-health`, `dashboard-export`, or the loopback-only `dashboard-serve`. See [docs/operator-dashboard.md](docs/operator-dashboard.md) for API, security and schema details.
+Version 0.12 adds a dependency-free operator projection over projects, queues, P0 gates, P1 action reservations and P2 typed todo ownership. Use `dashboard-inspect`, `dashboard-health`, `dashboard-export`, or `dashboard-serve`. Gateway autostart installation supports local-only and Tailnet-only listening without binding all interfaces. See [docs/operator-dashboard.md](docs/operator-dashboard.md) for API, security and schema details.
 
 The consolidated P0-P3 local release contract and evidence ledger are recorded in [docs/release-0.12-acceptance.md](docs/release-0.12-acceptance.md). Publishing, tagging, pushing, and production installation remain separate release actions.
 

package/docs/operator-dashboard.md

@@ -12,9 +12,32 @@ loop-engineering dashboard-export --output-dir /tmp/loop-dashboard --root /path/
 loop-engineering dashboard-serve --root /path/to/workspace
 ```
 
-`dashboard-serve` binds to `127.0.0.1` and an ephemeral port by default. A wider bind is rejected unless `--allow-non-loopback` is explicit. The server has no authentication and is intended for trusted local use. The CLI never starts it during checks or installation.
+`dashboard-serve` binds to `127.0.0.1` and an ephemeral port by default. A wider bind is rejected unless `--allow-non-loopback` is explicit. The server has no authentication and is intended for trusted local use.
 
-Endpoints are `GET /api/v1/overview`, `/api/v1/health`, `/api/v1/todos`, `/api/v1/todos/:id`, and `/api/v1/actions`. Overview and todo lists support `q` and `state` filters. Private raw files are not served.
+The OpenClaw and Hermes integration installers also install a Dashboard service on port `4174` and systemd gateway drop-ins. Starting `openclaw-gateway.service` or `hermes-gateway.service` therefore starts the read-only Dashboard. The default `localhost` mode binds only `127.0.0.1`. Optional `tailscale` mode resolves `tailscale ip -4` at install time and binds only that Tailnet address; it never binds `0.0.0.0`. Tailnet access is governed by Tailscale ACLs/Grants, while the Dashboard itself remains read-only and has no application-level login.
+
+```bash
+loop-engineering-dashboard-autostart-install --root /path/to/workspace
+loop-engineering-dashboard-autostart-install --root /path/to/workspace --confirm-install
+loop-engineering-dashboard-autostart-install --root /path/to/workspace --listen tailscale --confirm-install
+```
+
+To make the workspace follow either the OpenClaw or Hermes user gateway lifecycle, install the loopback-only systemd integration:
+
+```sh
+loop-engineering-dashboard-autostart-install --root /path/to/workspace
+loop-engineering-dashboard-autostart-install --root /path/to/workspace --confirm-install
+```
+
+This creates `loop-engineering-dashboard.service` on fixed port `4174` and systemd drop-ins for `openclaw-gateway.service` and `hermes-gateway.service`. Starting either gateway pulls in the same idempotent dashboard service. Use `--listen localhost` (the default) for local-only access or `--listen tailscale` for Tailnet access. The Tailscale mode fails closed if it cannot resolve exactly one `100.x` IPv4 address. Restrict port `4174` with Tailnet ACLs/Grants when the Tailnet contains users or devices that should not see project metadata.
+
+The platform installers expose the same choice as `--dashboard-listen localhost|tailscale` and accept `--tailscale-bin` when the CLI is outside `PATH`.
+
+Endpoints are `GET /api/v1/overview`, `/api/v1/health`, `/api/v1/projects`, `/api/v1/projects/:id`, `/api/v1/todos`, `/api/v1/todos/:id`, and `/api/v1/actions`. Overview and todo lists support `q` and `state` filters. Private raw files are not served.
+
+The browser workspace leads with projects rather than queue rows. A project card keeps milestone progress separate from terminal acceptance; project detail exposes the terminal outcome/rules, milestone acceptance, checkpoint revision lineage, human gates, reservations, acceptance reviews, and the independent final-judge event. Task workspaces are linked to a project only by explicit `checkpoint.project_id`, so the projection does not guess ownership from names. Unlinked tasks remain available in `task_workspaces` and the operational queue.
+
+The interface is responsive down to a narrow phone viewport, keyboard-operable for project selection, dependency-free, and safe for static export. It remains deliberately read-only: there are no approve, retry, settle, resume, or mutation controls.
 
 ## Projection and security rules
 

package/docs/operator-workspace-project.md

@@ -0,0 +1,30 @@
+# Operator workspace project contract
+
+## Terminal outcome
+
+An operator can use a local browser workspace every day to understand a Loop Engineering project's terminal contract, milestone progress and total-project status; trace checkpoint revisions, human gates, external-action reservations, acceptance reviews, and the independent final judge; and do so without granting the UI mutation authority or exposing raw/private artifacts.
+
+No single page, milestone, checkpoint, or passing test subset completes this project. Completion requires every milestone below, the release checks, and an independent final judgement to pass together.
+
+## Milestones
+
+1. **Project projection and information architecture** — project-first projection, terminal/milestone separation, task linkage, revision and acceptance timeline, project detail API, responsive read-only workspace, security regression coverage, and operator documentation. Status: implemented and independently accepted.
+2. **Daily interaction experience** — persistent URL filters and selection, accessible navigation/focus states, useful empty/error states, gate/reservation inspection, and responsive/accessibility assertions. Status: implemented and accepted.
+3. **Release hardening** — schema compatibility, realistic large-workspace benchmark, live/static export tests, documentation, package dry run, full regression, and independent final judge. Status: implemented and accepted.
+
+## Acceptance mapping
+
+- Terminal contract, milestone and project status: milestone 1 projection/API/UI tests.
+- Revision lineage and acceptance/final-judge timeline: milestone 1 task workspace fixtures.
+- Human gates and external-action reservations: milestones 1–2 projection and inspection views.
+- Safe read-only boundary: no mutation endpoints or controls; loopback default, explicit non-loopback override, redaction, XSS/path traversal checks.
+- Information architecture, interaction and responsive UI: milestones 1–2.
+- Tests, documentation and release-level acceptance: milestones 1–3.
+
+## Explicit boundaries
+
+The workspace does not approve gates, resume tasks, settle reservations, modify contracts, repair artifacts, or serve arbitrary evidence files. Those actions remain in governed CLI/control-plane workflows. A future authenticated mutation product would require a separate authority model and project contract.
+
+## Project completion rule
+
+The project reached its terminal acceptance candidate after all three milestones passed, all required checks were recorded, no required item remained unmet, and the independent 25-check final judgement returned `accept`. Milestone 1 acceptance was recorded only as a stage completion; project completion is based on the combined terminal evidence.

package/lib/operator-dashboard.mjs

@@ -142,8 +142,51 @@ async function projects(root, warnings) {
     const base = path.join(runtime, id);
     const intake = await json(path.join(base, 'intake', 'latest.json'), warnings, root);
     const backlog = await json(path.join(base, 'backlog', 'initial.json'), warnings, root);
+    const terminalContract = await json(path.join(base, 'terminal-contract.json'), warnings, root);
     const completion = await json(path.join(base, 'completion', 'latest.json'), warnings, root);
-    result.push(clean({ id, goal: intake?.goal ?? intake?.brief ?? null, queue: intake?.queue ?? null, status: completion?.status ?? (completion ? 'completed' : 'active'), acceptance: intake?.acceptance ?? null, backlog: backlog?.tasks ?? backlog?.items ?? backlog ?? null, evidence_links: [intake && relativeLink(root, path.join(base, 'intake', 'latest.json')), backlog && relativeLink(root, path.join(base, 'backlog', 'initial.json')), completion && relativeLink(root, path.join(base, 'completion', 'latest.json'))].filter(Boolean) }));
+    const milestones = (backlog?.tasks ?? backlog?.items ?? (Array.isArray(backlog) ? backlog : [])).map((item, index) => ({
+      id: item.id ?? `milestone-${index + 1}`, title: item.title ?? item.task ?? `Milestone ${index + 1}`,
+      status: item.status ?? 'pending', acceptance: item.acceptance ?? [], evidence: item.evidence ?? []
+    }));
+    const accepted = completion?.terminalAccepted === true || terminalContract?.terminalState?.accepted === true;
+    result.push(clean({
+      id, goal: intake?.goal ?? intake?.brief ?? null, brief: intake?.brief ?? null, queue: intake?.queue ?? null,
+      status: accepted ? 'completed' : completion?.status ?? terminalContract?.status ?? 'active', terminal_accepted: accepted,
+      project_summary: { completed_milestones: milestones.filter((item) => ['completed', 'accepted'].includes(item.status)).length, total_milestones: milestones.length, unmet: completion?.unmet ?? terminalContract?.unmet ?? [], blockers: completion?.blockers ?? terminalContract?.blockers ?? [] },
+      terminal_contract: terminalContract ? { status: terminalContract.status ?? null, terminal_state: terminalContract.terminalState ?? null, milestone_rule: terminalContract.milestoneRule ?? null, completion_rule: terminalContract.completionRule ?? null, requirements: terminalContract.requirements ?? [], residual_risks: terminalContract.residualRisks ?? [] } : null,
+      acceptance: intake?.acceptance ?? null, milestones, completion: completion ?? null,
+      evidence_links: [intake && relativeLink(root, path.join(base, 'intake', 'latest.json')), backlog && relativeLink(root, path.join(base, 'backlog', 'initial.json')), terminalContract && relativeLink(root, path.join(base, 'terminal-contract.json')), completion && relativeLink(root, path.join(base, 'completion', 'latest.json'))].filter(Boolean)
+    }));
+  }
+  return result.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+async function taskWorkspaces(root, warnings) {
+  const loops = path.join(root, 'runtime', 'loops'); const result = [];
+  for (const queue of (await dirs(loops)).filter((name) => !['control-plane', 'action-reservations', 'execution-ledger', 'projects'].includes(name))) {
+    const tasksRoot = path.join(loops, queue, 'tasks');
+    for (const taskId of await dirs(tasksRoot)) {
+      const base = path.join(tasksRoot, taskId);
+      const [contract, finalJudgement, humanContext, amendment] = await Promise.all([
+        json(path.join(base, 'task_contract.json'), warnings, root), json(path.join(base, 'final_judgement.json'), warnings, root),
+        json(path.join(base, 'human_input_context.json'), warnings, root), json(path.join(base, 'amendments', 'latest.json'), warnings, root)
+      ]);
+      const checkpoints = []; const reviews = [];
+      for (const file of await files(path.join(base, 'checkpoints'))) { const item = await json(file, warnings, root); if (item) checkpoints.push({ ...clean(item), evidence_link: relativeLink(root, file) }); }
+      for (const file of await files(path.join(base, 'reviews'))) { const item = await json(file, warnings, root); if (item) reviews.push({ ...clean(item), evidence_link: relativeLink(root, file) }); }
+      if (!contract && !checkpoints.length && !finalJudgement) continue;
+      const projectIds = [...new Set(checkpoints.map((item) => item.project_id).filter(Boolean))];
+      const timeline = [
+        ...checkpoints.map((item) => ({ type: 'checkpoint', at: item.created_at ?? null, id: item.checkpoint_id, status: item.status, summary: item.summary, revision_of: item.revises_checkpoint_id ?? null, amendment_version: item.amendment_version ?? 0, evidence_link: item.evidence_link })),
+        ...reviews.map((item) => {
+          const failed = Array.isArray(item.failed) ? item.failed : item.failed == null ? [] : [item.failed];
+          const passed = Array.isArray(item.passed) ? item.passed : item.passed == null ? [] : [item.passed];
+          return { type: 'acceptance_review', at: item.created_at ?? null, id: item.checkpoint_id, status: item.status, summary: failed.map(String).join('; ') || passed.slice(0, 2).map(String).join('; '), evidence_link: item.evidence_link };
+        }),
+        ...(finalJudgement ? [{ type: 'final_judge', at: finalJudgement.created_at ?? null, id: 'final_judgement', status: finalJudgement.outcome, summary: (finalJudgement.reasons ?? []).join('; '), evidence_link: relativeLink(root, path.join(base, 'final_judgement.json')) }] : [])
+      ].sort((a, b) => String(a.at ?? '').localeCompare(String(b.at ?? '')) || a.type.localeCompare(b.type));
+      result.push(clean({ id: taskId, queue, title: contract?.title ?? taskId, scope: contract?.task_scope ?? null, project_ids: projectIds, amendment_version: amendment?.version ?? amendment?.amendment_version ?? 0, final_judgement: finalJudgement?.outcome ?? null, gates: humanContext?.gates ?? [], revision_lineage: checkpoints.map((item) => ({ checkpoint_id: item.checkpoint_id, milestone_id: item.milestone_id ?? item.checkpoint_id, revises_checkpoint_id: item.revises_checkpoint_id ?? null, sequence: item.sequence ?? null, status: item.status })), timeline, evidence_links: [relativeLink(root, path.join(base, 'task_contract.json'))].filter(Boolean) }));
+    }
   }
   return result.sort((a, b) => a.id.localeCompare(b.id));
 }
@@ -152,13 +195,14 @@ export async function buildOperatorProjection(root, options = {}) {
   const resolved = path.resolve(root); const now = options.now ? new Date(options.now) : new Date();
   if (Number.isNaN(now.getTime())) throw new Error('Invalid projection time.');
   const warnings = []; const before = await stat(path.join(resolved, 'runtime', 'loops')).catch(() => null);
-  const [control, reservations, steps, queueList, projectList, trustEvidence] = await Promise.all([controlPlane(resolved, warnings, now.getTime()), actions(resolved, warnings, now.getTime()), executionSteps(resolved, warnings, now.getTime()), legacyQueues(resolved, warnings, now.getTime()), projects(resolved, warnings), productionEvidence(resolved, warnings)]);
+  const [control, reservations, steps, queueList, projectList, taskList, trustEvidence] = await Promise.all([controlPlane(resolved, warnings, now.getTime()), actions(resolved, warnings, now.getTime()), executionSteps(resolved, warnings, now.getTime()), legacyQueues(resolved, warnings, now.getTime()), projects(resolved, warnings), taskWorkspaces(resolved, warnings), productionEvidence(resolved, warnings)]);
   const newest = [control.updated_at, ...control.todos.map((item) => item.updated_at), ...reservations.map((item) => item.updated_at), ...steps.map((item) => item.updated_at), ...queueList.flatMap((queue) => queue.tasks.map((item) => item.updated_at))].filter(Boolean).sort().at(-1) ?? null;
   const counts = Object.fromEntries([...STATES].map((state) => [state, 0]));
   for (const item of [...control.todos, ...queueList.flatMap((queue) => queue.tasks)]) counts[item.state] += 1;
   const after = await stat(path.join(resolved, 'runtime', 'loops')).catch(() => null);
   if (before && after && before.mtimeMs !== after.mtimeMs) warnings.push({ code: 'concurrent_update', artifact: 'runtime/loops', message: 'Artifacts changed while the projection was read; refresh recommended.' });
-  return clean({ schema_version: DASHBOARD_SCHEMA_VERSION, generated_at: now.toISOString(), source: { root: resolved, read_only: true, newest_artifact_at: newest, freshness_seconds: newest ? Math.max(0, Math.floor((now.getTime() - Date.parse(newest)) / 1000)) : null }, health: { status: warnings.length ? 'degraded' : 'ok', warnings }, overview: { counts, queue_count: queueList.length, project_count: projectList.length, todo_count: control.todos.length, action_count: reservations.length, step_count: steps.length, reconciliation_required_steps: steps.filter((item) => item.state === 'reconciliation_required').length, production_trust: trustEvidence?.passed ? 'passed' : trustEvidence ? 'failed' : 'not_generated' }, projects: projectList, queues: queueList, todos: control.todos, agents: control.agents, handoffs: control.handoffs, gates: control.todos.filter((item) => ['parked', 'waiting_for_human', 'waiting_for_external_condition', 'timed_out_or_escalated'].includes(item.state)).map((item) => ({ todo_id: item.id, state: item.state, gate: item.gate, next_action: item.next_action })), actions: reservations, execution_steps: steps, production_evidence: trustEvidence, cost: { quotas: control.quotas, requested_total: control.todos.reduce((sum, item) => sum + Number(item.cost?.amount ?? 0), 0) } });
+  const projectsWithTasks = projectList.map((project) => ({ ...project, tasks: taskList.filter((task) => task.project_ids.includes(project.id)) }));
+  return clean({ schema_version: DASHBOARD_SCHEMA_VERSION, generated_at: now.toISOString(), source: { root: resolved, read_only: true, newest_artifact_at: newest, freshness_seconds: newest ? Math.max(0, Math.floor((now.getTime() - Date.parse(newest)) / 1000)) : null }, health: { status: warnings.length ? 'degraded' : 'ok', warnings }, overview: { counts, queue_count: queueList.length, project_count: projectList.length, task_workspace_count: taskList.length, todo_count: control.todos.length, action_count: reservations.length, step_count: steps.length, reconciliation_required_steps: steps.filter((item) => item.state === 'reconciliation_required').length, production_trust: trustEvidence?.passed ? 'passed' : trustEvidence ? 'failed' : 'not_generated' }, projects: projectsWithTasks, task_workspaces: taskList, queues: queueList, todos: control.todos, agents: control.agents, handoffs: control.handoffs, gates: [...control.todos.filter((item) => ['parked', 'waiting_for_human', 'waiting_for_external_condition', 'timed_out_or_escalated'].includes(item.state)).map((item) => ({ todo_id: item.id, state: item.state, gate: item.gate, next_action: item.next_action })), ...taskList.flatMap((task) => task.gates.map((gate) => ({ task_id: task.id, ...gate })))], actions: reservations, execution_steps: steps, production_evidence: trustEvidence, cost: { quotas: control.quotas, requested_total: control.todos.reduce((sum, item) => sum + Number(item.cost?.amount ?? 0), 0) } });
 }
 
 export function filterProjection(projection, options = {}) {
@@ -173,8 +217,8 @@ export function dashboardHealth(projection, options = {}) {
   return { schema_version: DASHBOARD_SCHEMA_VERSION, status: projection.health.status === 'ok' && !stale ? 'ok' : 'degraded', read_only: true, stale, freshness_seconds: projection.source.freshness_seconds, warnings: projection.health.warnings };
 }
 
-function html() {
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Loop Engineering Operator Dashboard</title><style>body{font:14px system-ui;margin:2rem;background:#10151c;color:#e8edf2}input,select{padding:.55rem;background:#18222e;color:inherit;border:1px solid #445}table{width:100%;border-collapse:collapse;margin-top:1rem}th,td{text-align:left;padding:.55rem;border-bottom:1px solid #344}.pill{padding:.2rem .5rem;border-radius:1rem;background:#25364a}a{color:#78b7ff}</style></head><body><h1>Loop Engineering</h1><p id="health">Loading read-only projection…</p><input id="q" placeholder="Search"><select id="s"><option value="">All states</option></select><table><thead><tr><th>State</th><th>Task</th><th>Owner</th><th>Next action</th></tr></thead><tbody id="rows"></tbody></table><script>const states=['runnable','active','parked','waiting_for_human','waiting_for_external_condition','timed_out_or_escalated','reconciliation_required','blocked','completed','failed'];s.innerHTML+=states.map(x=>'<option>'+x+'</option>').join('');async function draw(){const p=new URLSearchParams({q:q.value,state:s.value});const d=await fetch('/api/v1/overview?'+p).then(r=>r.json());health.textContent=d.health.status+' · '+d.overview.todo_count+' typed todos · '+d.overview.queue_count+' queues';const all=[...d.todos,...d.queues.flatMap(x=>x.tasks)];rows.replaceChildren(...all.map(x=>{const tr=document.createElement('tr');for(const v of [x.state,x.title,x.owner??'—',x.next_action??'—']){const td=document.createElement('td');td.textContent=String(v);tr.append(td)}return tr}))}q.oninput=draw;s.onchange=draw;draw()</script></body></html>`;
+function html(dataUrl = '/api/v1/overview?') {
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Loop Engineering Workspace</title><style>:root{color-scheme:dark;--bg:#091018;--panel:#111c28;--line:#26384b;--muted:#91a5b8;--accent:#77d6c9}*{box-sizing:border-box}body{font:14px/1.5 ui-sans-serif,system-ui;margin:0;background:var(--bg);color:#eef6fb}header{position:sticky;top:0;z-index:2;padding:1rem clamp(1rem,4vw,3rem);background:#091018ee;border-bottom:1px solid var(--line);backdrop-filter:blur(12px)}h1,h2,h3,p{margin:.2rem 0}.eyebrow,.muted{color:var(--muted)}main{padding:1.25rem clamp(1rem,4vw,3rem);display:grid;gap:1rem}.stats,.projects,.split{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:.8rem}.card{background:linear-gradient(150deg,#142230,#0d1822);border:1px solid var(--line);border-radius:14px;padding:1rem;min-width:0}.stat strong{font-size:1.65rem}.bar{height:7px;background:#223141;border-radius:9px;overflow:hidden;margin:.75rem 0}.bar i{display:block;height:100%;background:var(--accent)}.pill{display:inline-block;padding:.15rem .5rem;border-radius:1rem;background:#24384a;color:#d9edf8}.ok{color:#7ee2a8}.warn{color:#ffcf70}button,input,select{padding:.65rem;background:#111d29;color:inherit;border:1px solid #3a5268;border-radius:8px}button.project{width:100%;text-align:left;font:inherit}button.project[aria-pressed=true]{border-color:var(--accent)}table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:.6rem;border-bottom:1px solid var(--line);vertical-align:top}.scroll{overflow:auto}.timeline{border-left:2px solid var(--line);padding-left:1rem}.event{margin:.65rem 0}.project{cursor:pointer}.project:focus-visible,input:focus-visible,select:focus-visible{outline:3px solid var(--accent);outline-offset:2px}#detail:empty{display:none}.empty{padding:1rem;text-align:center;color:var(--muted)}@media(max-width:640px){header{position:static}.desktop{display:none}td,th{min-width:120px}.split{grid-template-columns:1fr}input,select{width:100%;margin-top:.4rem}}</style></head><body><header><div class="eyebrow">READ-ONLY OPERATOR WORKSPACE</div><h1>Loop Engineering</h1><p id="health" role="status" aria-live="polite">Loading durable artifacts…</p></header><main><section class="stats" id="stats" aria-label="Workspace summary"></section><section aria-labelledby="projects-title"><h2 id="projects-title">Projects</h2><p class="muted">Project completion is separate from milestone completion.</p><div class="projects" id="projects"></div></section><section class="card" id="detail" tabindex="-1" aria-live="polite"></section><section class="card"><div class="split"><div><h2>Operational queue</h2><p class="muted">Human gates, reservations and reconciliation remain visible and immutable here.</p></div><div><label>Search <input id="q" placeholder="Task, owner or action"></label><label>State <select id="s"><option value="">All states</option></select></label></div></div><div class="scroll"><table><thead><tr><th>State</th><th>Task</th><th class="desktop">Owner</th><th>Next action</th></tr></thead><tbody id="rows"></tbody></table></div></section></main><script>const dataUrl=${JSON.stringify(dataUrl)},initial=new URLSearchParams(location.search);const states=['runnable','active','parked','waiting_for_human','waiting_for_external_condition','timed_out_or_escalated','reconciliation_required','blocked','completed','failed'];s.innerHTML+=states.map(x=>'<option>'+x+'</option>').join('');q.value=initial.get('q')??'';s.value=initial.get('state')??'';let selected=initial.get('project'),model=null;const el=(tag,text,cls)=>{const n=document.createElement(tag);n.textContent=text??'';if(cls)n.className=cls;return n};function syncUrl(){if(dataUrl.startsWith('./'))return;const p=new URLSearchParams();if(q.value)p.set('q',q.value);if(s.value)p.set('state',s.value);if(selected)p.set('project',selected);history.replaceState(null,'','?'+p)}function projectDetail(p,focus=false){selected=p.id;detail.replaceChildren();detail.append(el('h2',p.id),el('p',p.goal,'muted'));const c=p.terminal_contract;if(c){detail.append(el('h3','Terminal contract'),el('p',c.terminal_state?.userVisibleOutcome??'No user-visible outcome recorded'),el('p',c.milestone_rule??'','warn'))}detail.append(el('h3','Milestones'));const list=el('div');for(const m of p.milestones??[])list.append(el('p',(m.status??'pending')+' · '+m.title));detail.append(list,el('h3','Gates & reservations'));const operational=el('div');const gates=(p.tasks??[]).flatMap(x=>x.gates??[]);operational.append(el('p',(gates.length?gates.length+' human/external gate(s)':'No project gates')+' · '+model.actions.length+' workspace reservation(s)','muted'));detail.append(operational,el('h3','Acceptance & final judge timeline'));const tl=el('div',null,'timeline');const events=(p.tasks??[]).flatMap(x=>x.timeline??[]);if(!events.length)tl.append(el('p','No acceptance events yet.','empty'));for(const t of events)tl.append(el('div',(t.at??'undated')+' · '+t.type+' · '+t.status+' — '+(t.summary??''),'event'));detail.append(tl);syncUrl();drawProjects();if(focus)detail.focus()}function drawProjects(){projects.replaceChildren(...model.projects.map(p=>{const n=el('button',null,'card project');n.type='button';n.setAttribute('aria-pressed',String(selected===p.id));const done=p.project_summary?.completed_milestones??0,total=p.project_summary?.total_milestones??0;n.append(el('span',p.terminal_accepted?'PROJECT ACCEPTED':String(p.status).toUpperCase(),p.terminal_accepted?'pill ok':'pill'),el('h3',p.id),el('p',p.goal,'muted'));const b=el('div',null,'bar'),i=el('i');i.style.width=(total?done/total*100:0)+'%';b.append(i);n.append(b,el('p',done+' / '+total+' milestones'));n.onclick=()=>projectDetail(p,true);return n}));if(!model.projects.length)projects.append(el('p','No project artifacts found.','card empty'))}async function draw(){try{const params=new URLSearchParams({q:q.value,state:s.value});const response=await fetch(dataUrl+(dataUrl.includes('?')?params:''));if(!response.ok)throw new Error('HTTP '+response.status);model=await response.json();health.textContent=model.health.status+' · generated '+new Date(model.generated_at).toLocaleString()+' · source is read-only';stats.replaceChildren(...[['Projects',model.overview.project_count],['Task workspaces',model.overview.task_workspace_count],['Human gates',model.gates.length],['Reservations',model.overview.action_count]].map(([k,v])=>{const n=el('div',null,'card stat');n.append(el('div',k,'muted'),el('strong',v));return n}));drawProjects();const all=[...model.todos,...model.queues.flatMap(x=>x.tasks)];rows.replaceChildren(...all.map(x=>{const tr=el('tr');for(const [v,c] of [[x.state,''],[x.title,''],[x.owner??'—','desktop'],[x.next_action??'—','']])tr.append(el('td',String(v),c));return tr}));if(!all.length){const td=el('td','No matching operational work.','empty');td.colSpan=4;const tr=el('tr');tr.append(td);rows.append(tr)}const chosen=model.projects.find(p=>p.id===selected);if(chosen)projectDetail(chosen)}catch(error){health.textContent='Unable to load workspace · '+error.message;health.className='warn'}}q.oninput=()=>{syncUrl();draw()};s.onchange=()=>{syncUrl();draw()};addEventListener('popstate',()=>location.reload());draw()</script></body></html>`;
 }
 
 function loopback(host) { return host === '127.0.0.1' || host === '::1' || host === 'localhost'; }
@@ -195,6 +239,8 @@ export async function createDashboardServer(root, options = {}) {
       else if (url.pathname === '/api/v1/todos') body = filterProjection(projection, { query: url.searchParams.get('q'), state: url.searchParams.get('state') }).todos;
       else if (url.pathname.startsWith('/api/v1/todos/')) body = projection.todos.find((item) => item.id === safeId(decodeURIComponent(url.pathname.slice('/api/v1/todos/'.length)))) ?? null;
       else if (url.pathname === '/api/v1/actions') body = projection.actions;
+      else if (url.pathname === '/api/v1/projects') body = projection.projects;
+      else if (url.pathname.startsWith('/api/v1/projects/')) body = projection.projects.find((item) => item.id === safeId(decodeURIComponent(url.pathname.slice('/api/v1/projects/'.length)))) ?? null;
       else { response.writeHead(404); return response.end('not found'); }
       response.writeHead(body === null ? 404 : 200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' }); response.end(request.method === 'HEAD' ? '' : `${JSON.stringify(body)}\n`);
     } catch (error) { response.writeHead(500, { 'content-type': 'application/json; charset=utf-8' }); response.end(`${JSON.stringify({ error: 'projection_failed', message: String(error.message) })}\n`); }
@@ -207,6 +253,6 @@ export async function exportDashboard(root, outputDir, options = {}) {
   const target = path.resolve(outputDir); const projection = await buildOperatorProjection(root, options);
   await mkdir(target, { recursive: true });
   await writeFile(path.join(target, 'projection.json'), `${JSON.stringify(projection, null, 2)}\n`);
-  await writeFile(path.join(target, 'index.html'), html().replace("fetch('/api/v1/overview?'+p)", "fetch('./projection.json')"));
+  await writeFile(path.join(target, 'index.html'), html('./projection.json'));
   return { schema_version: DASHBOARD_SCHEMA_VERSION, output_dir: target, files: ['index.html', 'projection.json'], read_only_source: true };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.15.11",
+  "version": "0.15.13",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",
@@ -14,10 +14,12 @@
     "loop-engineering-hermes-install": "scripts/hermes-install.mjs",
     "loop-engineering-hermes-doctor": "scripts/hermes-doctor.mjs",
     "loop-engineering-hermes-smoke": "scripts/hermes-smoke.mjs",
+    "loop-engineering-dashboard-autostart-install": "scripts/dashboard-autostart-install.mjs",
     "run-loop-cron.sh": "scripts/run-loop-cron.sh"
   },
   "scripts": {
-    "test": "npm run check && npm run check:competitive",
+    "test": "npm run check && npm run check:competitive && npm run check:operator-workspace",
+    "check:operator-workspace": "node --check scripts/operator-workspace-final-judgement.mjs && node --check scripts/dashboard-autostart-install.mjs && node scripts/dashboard-autostart-self-test.mjs && node scripts/operator-workspace-final-judgement.mjs",
     "check:competitive": "node --check lib/transactional-state-kernel.mjs && node --check lib/goal-api.mjs && node scripts/competitive-acceptance.mjs",
     "check:adapters": "node --check lib/runtime-adapter-sdk.mjs && node scripts/runtime-adapter-conformance.mjs",
     "demo:adapter": "node examples/adapter-sdk-demo.mjs",

package/scripts/dashboard-autostart-install.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+function parseArgs(argv) {
+  const out = { root: process.cwd(), listen: 'localhost', host: null, port: 4174, tailscaleBin: 'tailscale', systemctlBin: 'systemctl', confirmInstall: false, json: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--root') out.root = path.resolve(argv[++i]);
+    else if (arg === '--listen') out.listen = argv[++i];
+    else if (arg === '--host') out.host = argv[++i];
+    else if (arg === '--port') out.port = Number(argv[++i]);
+    else if (arg === '--tailscale-bin') out.tailscaleBin = argv[++i];
+    else if (arg === '--systemctl-bin') out.systemctlBin = argv[++i];
+    else if (arg === '--confirm-install') out.confirmInstall = true;
+    else if (arg === '--json') out.json = true;
+    else if (arg === '--help') out.help = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (!['localhost', 'tailscale'].includes(out.listen)) throw new Error('--listen must be localhost or tailscale.');
+  if (out.host && out.listen === 'tailscale') throw new Error('--host cannot be combined with --listen tailscale.');
+  if (out.host && !['127.0.0.1', '::1', 'localhost'].includes(out.host)) throw new Error('--host only accepts a loopback address; use --listen tailscale for Tailnet access.');
+  if (!Number.isInteger(out.port) || out.port < 1 || out.port > 65535) throw new Error('--port must be an integer from 1 to 65535.');
+  return out;
+}
+
+function systemdEscapePath(value) {
+  return [...value].map((character) => {
+    if (/[A-Za-z0-9_/:.\-]/.test(character)) return character;
+    return `\\x${character.codePointAt(0).toString(16).padStart(2, '0')}`;
+  }).join('');
+}
+
+function run(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = ''; let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => resolve({ code: 127, stdout, stderr: `${stderr}${error.message}` }));
+    child.on('close', (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+  console.log('Usage: loop-engineering-dashboard-autostart-install --root <workspace> [--listen localhost|tailscale] [--port 4174] [--tailscale-bin tailscale] [--confirm-install] [--json]');
+  process.exit(0);
+}
+
+const packageRoot = path.resolve(new URL('..', import.meta.url).pathname);
+const cli = path.join(packageRoot, 'bin', 'loop-engineering.mjs');
+const userSystemdDir = path.join(process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || '', '.config'), 'systemd', 'user');
+const dashboardUnit = 'loop-engineering-dashboard.service';
+const gatewayUnits = ['openclaw-gateway.service', 'hermes-gateway.service'];
+const servicePath = path.join(userSystemdDir, dashboardUnit);
+const host = args.listen === 'localhost' ? (args.host || '127.0.0.1') : await (async () => {
+  const result = await run(args.tailscaleBin, ['ip', '-4']);
+  if (result.code !== 0) throw new Error(`Cannot resolve Tailscale IPv4 address: ${(result.stderr || result.stdout).trim() || `exit ${result.code}`}`);
+  const addresses = result.stdout.split(/\s+/).filter(Boolean);
+  if (addresses.length !== 1 || !/^100\.(?:\d{1,3}\.){2}\d{1,3}$/.test(addresses[0])) throw new Error(`Expected exactly one Tailscale IPv4 address, received: ${addresses.join(', ') || 'none'}`);
+  return addresses[0];
+})();
+const nonLoopback = args.listen === 'tailscale' ? ' --allow-non-loopback' : '';
+const service = `[Unit]\nDescription=Taskforce Loop Engineering read-only project workspace\nAfter=network.target\n\n[Service]\nType=simple\nWorkingDirectory=${systemdEscapePath(args.root)}\nExecStart=${systemdEscapePath(process.execPath)} ${systemdEscapePath(cli)} dashboard-serve --root ${systemdEscapePath(args.root)} --host ${host} --port ${args.port}${nonLoopback}\nRestart=on-failure\nRestartSec=3s\nNoNewPrivileges=true\nPrivateTmp=true\n\n[Install]\nWantedBy=default.target\n`;
+const dropIn = `[Unit]\nWants=${dashboardUnit}\nAfter=${dashboardUnit}\n`;
+const report = {
+  status: args.confirmInstall ? 'installed' : 'plan_only',
+  listen: args.listen,
+  host,
+  dashboard: `http://${host}:${args.port}/`,
+  readOnly: true,
+  service: servicePath,
+  gatewayDropIns: gatewayUnits.map((unit) => path.join(userSystemdDir, `${unit}.d`, 'loop-engineering-dashboard.conf')),
+  writesEnabled: args.confirmInstall
+};
+
+if (args.confirmInstall) {
+  await mkdir(userSystemdDir, { recursive: true });
+  await writeFile(servicePath, service);
+  for (const unit of gatewayUnits) {
+    const directory = path.join(userSystemdDir, `${unit}.d`);
+    await mkdir(directory, { recursive: true });
+    await writeFile(path.join(directory, 'loop-engineering-dashboard.conf'), dropIn);
+  }
+  const reload = await run(args.systemctlBin, ['--user', 'daemon-reload']);
+  if (reload.code !== 0) throw new Error(`Cannot reload user systemd units: ${(reload.stderr || reload.stdout).trim()}`);
+}
+
+console.log(args.json ? JSON.stringify(report, null, 2) : `${report.status}: ${report.dashboard}\nservice: ${report.service}\ngateways: ${gatewayUnits.join(', ')}`);

package/scripts/dashboard-autostart-self-test.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { chmod, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-dashboard-autostart-'));
+const mockSystemctl = path.join(root, 'systemctl.mjs');
+const mockTailscale = path.join(root, 'tailscale.mjs');
+const calls = path.join(root, 'calls.jsonl');
+process.env.XDG_CONFIG_HOME = path.join(root, 'xdg');
+process.env.SYSTEMCTL_CAPTURE = calls;
+await writeFile(mockSystemctl, `#!/usr/bin/env node\nimport { appendFile } from 'node:fs/promises';\nawait appendFile(process.env.SYSTEMCTL_CAPTURE, JSON.stringify(process.argv.slice(2)) + '\\n');\n`);
+await chmod(mockSystemctl, 0o755);
+await writeFile(mockTailscale, `#!/usr/bin/env node\nif (process.argv.slice(2).join(' ') !== 'ip -4') process.exit(2);\nconsole.log('100.64.10.20');\n`);
+await chmod(mockTailscale, 0o755);
+const installer = new URL('./dashboard-autostart-install.mjs', import.meta.url).pathname;
+const result = await new Promise((resolve) => {
+  const child = spawn(process.execPath, [installer, '--root', root, '--port', '4174', '--systemctl-bin', mockSystemctl, '--confirm-install', '--json'], { env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+  let stdout = ''; let stderr = '';
+  child.stdout.on('data', (chunk) => { stdout += chunk; }); child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.on('close', (code) => resolve({ code, stdout, stderr }));
+});
+if (result.code !== 0) throw new Error(result.stderr);
+const report = JSON.parse(result.stdout);
+if (report.status !== 'installed' || report.dashboard !== 'http://127.0.0.1:4174/') throw new Error('unexpected install report');
+const unitDir = path.join(process.env.XDG_CONFIG_HOME, 'systemd', 'user');
+const service = await readFile(path.join(unitDir, 'loop-engineering-dashboard.service'), 'utf8');
+if (!service.includes('dashboard-serve') || !service.includes('--port 4174') || !service.includes('NoNewPrivileges=true')) throw new Error('dashboard service is incomplete');
+for (const gateway of ['openclaw-gateway.service', 'hermes-gateway.service']) {
+  const dropIn = await readFile(path.join(unitDir, `${gateway}.d`, 'loop-engineering-dashboard.conf'), 'utf8');
+  if (!dropIn.includes('Wants=loop-engineering-dashboard.service') || !dropIn.includes('After=loop-engineering-dashboard.service')) throw new Error(`${gateway} is not wired to dashboard`);
+}
+if (!(await readFile(calls, 'utf8')).includes('["--user","daemon-reload"]')) throw new Error('systemd daemon was not reloaded');
+const tailnetResult = await new Promise((resolve) => {
+  const child = spawn(process.execPath, [installer, '--root', root, '--listen', 'tailscale', '--tailscale-bin', mockTailscale, '--port', '4174', '--systemctl-bin', mockSystemctl, '--confirm-install', '--json'], { env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+  let stdout = ''; let stderr = '';
+  child.stdout.on('data', (chunk) => { stdout += chunk; }); child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.on('close', (code) => resolve({ code, stdout, stderr }));
+});
+if (tailnetResult.code !== 0) throw new Error(tailnetResult.stderr);
+const tailnetReport = JSON.parse(tailnetResult.stdout);
+if (tailnetReport.listen !== 'tailscale' || tailnetReport.dashboard !== 'http://100.64.10.20:4174/') throw new Error('unexpected Tailnet install report');
+const tailnetService = await readFile(path.join(unitDir, 'loop-engineering-dashboard.service'), 'utf8');
+if (!tailnetService.includes('--host 100.64.10.20') || !tailnetService.includes('--allow-non-loopback')) throw new Error('Tailnet dashboard service is incomplete');
+console.log('dashboard autostart self-test passed');

package/scripts/hermes-doctor.mjs

@@ -14,7 +14,8 @@ async function present(file) { try { await access(file); return true; } catch {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) { console.log('Usage: loop-engineering-hermes-doctor [--root workspace] [--queue agent-tasks] [--hermes-bin hermes] [--json]'); return; }
-  const required = [`configs/loops/queues/${args.queue}.json`, 'configs/loops/workspace-health.json', 'scripts/loops/hermes-loop-dispatch.mjs', 'scripts/loops/hermes-loop.mjs', 'scripts/loops/hermes-loop-notify.mjs', 'runtime/loop-engineering-hermes-install.json', 'AGENTS.md'];
+  const systemdUserDir = path.join(process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || '', '.config'), 'systemd', 'user');
+  const required = [`configs/loops/queues/${args.queue}.json`, 'configs/loops/workspace-health.json', 'scripts/loops/hermes-loop-dispatch.mjs', 'scripts/loops/hermes-loop.mjs', 'scripts/loops/hermes-loop-notify.mjs', 'runtime/loop-engineering-hermes-install.json', 'AGENTS.md', path.relative(args.root, path.join(systemdUserDir, 'loop-engineering-dashboard.service')), path.relative(args.root, path.join(systemdUserDir, 'hermes-gateway.service.d', 'loop-engineering-dashboard.conf'))];
   const checks = []; for (const relative of required) checks.push({ id: `file:${relative}`, ok: await present(path.join(args.root, relative)) });
   const cli = await run(args.hermesBin, ['--version'], { cwd: args.root }); checks.push({ id: 'hermes_cli', ok: cli.code === 0, detail: (cli.stdout || cli.stderr).trim().slice(0, 300) });
   const sendHelp = await run(args.hermesBin, ['send', '--help'], { cwd: args.root }); checks.push({ id: 'hermes_send', ok: sendHelp.code === 0, detail: (sendHelp.stdout || sendHelp.stderr).trim().slice(0, 300) });

package/scripts/hermes-install-self-test.mjs

@@ -27,7 +27,7 @@ if (process.env.SYSTEMCTL_CAPTURE) await appendFile(process.env.SYSTEMCTL_CAPTUR
 function run(command, args, options = {}) { return new Promise((resolve) => { const child = spawn(command, args, { cwd: options.cwd || root, env: options.env || process.env, stdio: ['ignore', 'pipe', 'pipe'] }); let stdout = ''; let stderr = ''; child.stdout.on('data', (chunk) => { stdout += chunk; }); child.stderr.on('data', (chunk) => { stderr += chunk; }); child.on('close', (code) => resolve({ code, stdout, stderr })); }); }
 const installer = new URL('./hermes-install.mjs', import.meta.url).pathname; const doctor = new URL('./hermes-doctor.mjs', import.meta.url).pathname; const smoke = new URL('./hermes-smoke.mjs', import.meta.url).pathname; const loopBin = new URL('../bin/loop-engineering.mjs', import.meta.url).pathname;
 const base = ['--root', root, '--queue', 'hermes-tasks', '--hermes-bin', mockHermes, '--systemctl-bin', mockSystemctl];
-const plan = await run(process.execPath, [installer, ...base, '--json']); const planReport = JSON.parse(plan.stdout); if (plan.code !== 0 || planReport.status !== 'plan_only' || planReport.confirmationSummary?.targetPlatform !== 'Hermes' || planReport.confirmationSummary?.writesEnabled !== false || !path.isAbsolute(planReport.confirmationSummary?.platformCli || '') || !planReport.confirmationSummary?.notificationTarget.includes('Hermes')) throw new Error(`Hermes install plan failed: ${plan.stderr}`);
+const plan = await run(process.execPath, [installer, ...base, '--json']); const planReport = JSON.parse(plan.stdout); if (plan.code !== 0 || planReport.status !== 'plan_only' || planReport.confirmationSummary?.targetPlatform !== 'Hermes' || planReport.confirmationSummary?.writesEnabled !== false || !path.isAbsolute(planReport.confirmationSummary?.platformCli || '') || !planReport.confirmationSummary?.notificationTarget.includes('Hermes') || planReport.dashboardAutostart?.gateway !== 'hermes-gateway.service') throw new Error(`Hermes install plan failed: ${plan.stderr}`);
 const humanPlan = await run(process.execPath, [installer, ...base]); if (humanPlan.code !== 0 || !humanPlan.stdout.includes('Installation confirmation') || !humanPlan.stdout.includes('target platform: Hermes') || !humanPlan.stdout.includes('writes enabled: no (plan only)')) throw new Error('human-readable Hermes confirmation summary missing');
 const install = await run(process.execPath, [installer, ...base, '--confirm-install', '--json']); if (install.code !== 0 || JSON.parse(install.stdout).status !== 'installed') throw new Error(`Hermes install failed: ${install.stderr}`);
 const queue = JSON.parse(await readFile(path.join(root, 'configs/loops/queues/hermes-tasks.json'), 'utf8')); if (queue.dispatcher !== 'node scripts/loops/hermes-loop-dispatch.mjs' || queue.scheduler?.required !== true) throw new Error('Hermes queue wiring missing');
@@ -38,6 +38,7 @@ const dispatcher = await readFile(path.join(root, 'scripts/loops/hermes-loop-dis
 const notifier = path.join(root, 'scripts/loops/hermes-loop-notify.mjs'); const notify = await run(process.execPath, [notifier, 'hello from loop'], { env: { ...process.env, HERMES_SEND_CAPTURE: sendCapture, LOOP_NOTIFICATION_SOURCE: JSON.stringify({ channel: 'telegram', target: 'telegram:12345' }) } }); if (notify.code !== 0) throw new Error(`Hermes notifier failed: ${notify.stderr}`);
 const sent = JSON.parse(await readFile(sendCapture, 'utf8')); if (!sent.includes('telegram:12345') || !sent.includes('hello from loop')) throw new Error('Hermes notifier did not preserve delivery target/message');
 const serviceFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/hermes-loop-hermes-tasks-scheduler.service'); const timerFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/hermes-loop-hermes-tasks-scheduler.timer'); const service = await readFile(serviceFile, 'utf8'); if (service.includes('WorkingDirectory="') || !service.includes('\\x20') || !service.includes('\\xe5\\xae\\x89\\xe8\\xa3\\x85')) throw new Error('Hermes systemd paths were not escaped');
+const dashboardServiceFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/loop-engineering-dashboard.service'); const dashboardDropIn = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/hermes-gateway.service.d/loop-engineering-dashboard.conf'); if (!(await readFile(dashboardServiceFile, 'utf8')).includes('dashboard-serve') || !(await readFile(dashboardDropIn, 'utf8')).includes('Wants=loop-engineering-dashboard.service')) throw new Error('Hermes installer did not install Dashboard gateway autostart');
 const verify = await run('systemd-analyze', ['verify', serviceFile, timerFile]); if (verify.code !== 0) throw new Error(`Hermes systemd units invalid: ${verify.stderr || verify.stdout}`);
 const doctorResult = await run(process.execPath, [doctor, '--root', root, '--queue', 'hermes-tasks', '--hermes-bin', mockHermes, '--json']); if (doctorResult.code !== 0 || JSON.parse(doctorResult.stdout).status !== 'ok') throw new Error(`Hermes doctor failed: ${doctorResult.stderr || doctorResult.stdout}`);
 const smokeResult = await run(process.execPath, [smoke, '--root', root, '--queue', 'hermes-tasks', '--hermes-bin', mockHermes, '--loop-bin', loopBin, '--json']); if (smokeResult.code !== 0 || JSON.parse(smokeResult.stdout).status !== 'ok') throw new Error(`Hermes smoke failed: ${smokeResult.stderr || smokeResult.stdout}`);

package/scripts/hermes-install.mjs

@@ -5,13 +5,15 @@ import { spawn } from 'node:child_process';
 import path from 'node:path';
 
 function parseArgs(argv) {
-  const out = { root: process.cwd(), queue: 'agent-tasks', hermesBin: 'hermes', systemctlBin: 'systemctl', language: 'auto', json: false, confirmInstall: false, force: false };
+  const out = { root: process.cwd(), queue: 'agent-tasks', hermesBin: 'hermes', systemctlBin: 'systemctl', dashboardListen: 'localhost', tailscaleBin: 'tailscale', language: 'auto', json: false, confirmInstall: false, force: false };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === '--root') out.root = path.resolve(argv[++i]);
     else if (arg === '--queue') out.queue = argv[++i];
     else if (arg === '--hermes-bin') out.hermesBin = argv[++i];
     else if (arg === '--systemctl-bin') out.systemctlBin = argv[++i];
+    else if (arg === '--dashboard-listen') out.dashboardListen = argv[++i];
+    else if (arg === '--tailscale-bin') out.tailscaleBin = argv[++i];
     else if (arg === '--language') out.language = argv[++i];
     else if (arg === '--confirm-install') out.confirmInstall = true;
     else if (arg === '--force') out.force = true;
@@ -19,6 +21,7 @@ function parseArgs(argv) {
     else if (arg === '--help' || arg === '-h') out.help = true;
     else throw new Error(`Unknown argument: ${arg}`);
   }
+  if (!['localhost', 'tailscale'].includes(out.dashboardListen)) throw new Error('--dashboard-listen must be localhost or tailscale.');
   return out;
 }
 
@@ -145,7 +148,7 @@ function instructionsBlock({ queue, language }) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   args.language = resolveLanguage(args.language);
-  if (args.help) { console.log('Usage: loop-engineering-hermes-install [--root workspace] [--queue agent-tasks] [--language auto|en|zh] [--hermes-bin hermes] [--systemctl-bin systemctl] [--confirm-install] [--force] [--json]'); return; }
+  if (args.help) { console.log('Usage: loop-engineering-hermes-install [--root workspace] [--queue agent-tasks] [--dashboard-listen localhost|tailscale] [--tailscale-bin tailscale] [--language auto|en|zh] [--hermes-bin hermes] [--systemctl-bin systemctl] [--confirm-install] [--force] [--json]'); return; }
   safeId(args.queue, 'queue');
   args.hermesBin = await resolveExecutable(args.hermesBin);
   const hermes = await run(args.hermesBin, ['--version'], { cwd: args.root });
@@ -155,8 +158,9 @@ async function main() {
   const unit = `hermes-loop-${args.queue}-scheduler.service`; const timer = `hermes-loop-${args.queue}-scheduler.timer`;
   const files = { workspaceHealth: path.join(args.root, 'configs/loops/workspace-health.json'), queueConfig: path.join(args.root, 'configs/loops/queues', `${args.queue}.json`), dispatcher: path.join(args.root, 'scripts/loops/hermes-loop-dispatch.mjs'), wrapper: path.join(args.root, 'scripts/loops/hermes-loop.mjs'), notifier: path.join(args.root, 'scripts/loops/hermes-loop-notify.mjs'), manifest: path.join(args.root, 'runtime/loop-engineering-hermes-install.json'), instructions: path.join(args.root, 'AGENTS.md'), schedulerService: path.join(systemdUserDir, unit), schedulerTimer: path.join(systemdUserDir, timer) };
   const conflicts = []; for (const [kind, file] of Object.entries(files)) if (!['instructions', 'workspaceHealth', 'manifest'].includes(kind) && await exists(file)) conflicts.push(path.relative(args.root, file));
-  const confirmationSummary = { targetPlatform: 'Hermes', platformCli: args.hermesBin, workspace: args.root, queue: args.queue, scheduler: `systemd user timer ${timer}`, notificationTarget: text(args.language, 'source-bound at runtime (original Hermes conversation)', '运行时绑定到原始 Hermes 会话'), writesEnabled: args.confirmInstall };
-  const report = { version: 1, platform: 'hermes', language: args.language, status: args.confirmInstall ? 'installed' : 'plan_only', readOnly: !args.confirmInstall, root: args.root, queue: args.queue, hermesBin: args.hermesBin, hermesVersion: (hermes.stdout || hermes.stderr).trim().slice(0, 200), scheduler: { required: true, unit, timer }, confirmationSummary, files: Object.fromEntries(Object.entries(files).map(([key, file]) => [key, path.relative(args.root, file)])), conflicts };
+  const dashboardDescription = args.dashboardListen === 'tailscale' ? 'read-only Tailnet address on port 4174 coupled to hermes-gateway.service' : 'read-only http://127.0.0.1:4174/ coupled to hermes-gateway.service';
+  const confirmationSummary = { targetPlatform: 'Hermes', platformCli: args.hermesBin, workspace: args.root, queue: args.queue, scheduler: `systemd user timer ${timer}`, dashboard: dashboardDescription, notificationTarget: text(args.language, 'source-bound at runtime (original Hermes conversation)', '运行时绑定到原始 Hermes 会话'), writesEnabled: args.confirmInstall };
+  const report = { version: 1, platform: 'hermes', language: args.language, status: args.confirmInstall ? 'installed' : 'plan_only', readOnly: !args.confirmInstall, root: args.root, queue: args.queue, hermesBin: args.hermesBin, hermesVersion: (hermes.stdout || hermes.stderr).trim().slice(0, 200), scheduler: { required: true, unit, timer }, dashboardAutostart: { required: true, listen: args.dashboardListen, address: args.dashboardListen === 'localhost' ? 'http://127.0.0.1:4174/' : null, gateway: 'hermes-gateway.service' }, confirmationSummary, files: Object.fromEntries(Object.entries(files).map(([key, file]) => [key, path.relative(args.root, file)])), conflicts };
   if (conflicts.length && !args.force && args.confirmInstall) throw new Error(`Refusing to overwrite: ${conflicts.join(', ')}. Use --force after review.`);
   if (!args.json) console.log(formatConfirmationSummary(confirmationSummary, args.language));
   if (args.confirmInstall) {
@@ -168,6 +172,9 @@ async function main() {
     for (const [kind, content] of Object.entries(contents)) await writeFile(files[kind], content);
     const reload = await run(args.systemctlBin, ['--user', 'daemon-reload'], { cwd: args.root }); if (reload.code !== 0) throw new Error(`Cannot reload user systemd units: ${(reload.stderr || reload.stdout).trim()}`);
     const enable = await run(args.systemctlBin, ['--user', 'enable', '--now', timer], { cwd: args.root }); if (enable.code !== 0) throw new Error(`Cannot enable Hermes Loop scheduler ${timer}: ${(enable.stderr || enable.stdout).trim()}`);
+    const dashboardInstaller = new URL('./dashboard-autostart-install.mjs', import.meta.url).pathname;
+    const dashboardInstall = await run(process.execPath, [dashboardInstaller, '--root', args.root, '--listen', args.dashboardListen, '--tailscale-bin', args.tailscaleBin, '--systemctl-bin', args.systemctlBin, '--confirm-install', '--json'], { cwd: args.root });
+    if (dashboardInstall.code !== 0) throw new Error(`Cannot install Dashboard gateway autostart: ${(dashboardInstall.stderr || dashboardInstall.stdout).trim()}`);
     const marker = instructionsBlock({ queue: args.queue, language: args.language }); const current = await readFile(files.instructions, 'utf8').catch(() => ''); if (!current.includes('<!-- loop-engineering:hermes:start -->')) await appendFile(files.instructions, marker);
     await mkdir(path.dirname(files.manifest), { recursive: true }); await writeFile(files.manifest, `${JSON.stringify({ version: 2, platform: 'hermes', language: args.language, installedAt: new Date().toISOString(), root: args.root, queue: args.queue, hermesBin: args.hermesBin, files: Object.entries(contents).map(([kind, content]) => ({ kind, path: files[kind], sha256: sha256(content) })), scheduler: { unit, timer } }, null, 2)}\n`);
   }

package/scripts/openclaw-doctor.mjs

@@ -45,6 +45,11 @@ async function main() {
     'scripts/loops/openclaw-loop-notify.mjs',
     'AGENTS.md'
   ];
+  const systemdUserDir = path.join(process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || '', '.config'), 'systemd', 'user');
+  required.push(
+    path.relative(args.root, path.join(systemdUserDir, 'loop-engineering-dashboard.service')),
+    path.relative(args.root, path.join(systemdUserDir, 'openclaw-gateway.service.d', 'loop-engineering-dashboard.conf'))
+  );
   const checks = [];
   for (const relative of required) checks.push({ id: `file:${relative}`, ok: await present(path.join(args.root, relative)) });
   const cli = await run(args.openclawBin, ['--version'], { cwd: args.root });

package/scripts/openclaw-install-self-test.mjs

@@ -46,7 +46,7 @@ function run(args, env = process.env) {
 const installBase = ['--root', root, '--queue', 'test-tasks', '--openclaw-bin', mockOpenClaw, '--systemctl-bin', mockSystemctl];
 const plan = await run([...installBase, '--json']);
 const planReport = JSON.parse(plan.stdout);
-if (plan.code !== 0 || planReport.language !== 'en' || planReport.status !== 'plan_only' || planReport.platform !== 'openclaw' || planReport.workerAgent !== 'builder' || planReport.workerSelection !== 'only_available' || !planReport.workerValidated || planReport.createsWorkerAgent || planReport.confirmationSummary?.targetPlatform !== 'OpenClaw' || planReport.confirmationSummary?.writesEnabled !== false || !path.isAbsolute(planReport.confirmationSummary?.platformCli || '') || !planReport.confirmationSummary?.notificationTarget.includes('OpenClaw')) throw new Error(`plan failed: ${plan.stderr}`);
+if (plan.code !== 0 || planReport.language !== 'en' || planReport.status !== 'plan_only' || planReport.platform !== 'openclaw' || planReport.workerAgent !== 'builder' || planReport.workerSelection !== 'only_available' || !planReport.workerValidated || planReport.createsWorkerAgent || planReport.confirmationSummary?.targetPlatform !== 'OpenClaw' || planReport.confirmationSummary?.writesEnabled !== false || !path.isAbsolute(planReport.confirmationSummary?.platformCli || '') || !planReport.confirmationSummary?.notificationTarget.includes('OpenClaw') || planReport.dashboardAutostart?.gateway !== 'openclaw-gateway.service') throw new Error(`plan failed: ${plan.stderr}`);
 const zhPlan = await run([...installBase, '--language', 'zh']);
 if (zhPlan.code !== 0 || !zhPlan.stdout.includes('安装确认') || !zhPlan.stdout.includes('目标平台：OpenClaw') || !zhPlan.stdout.includes('允许写入：否（仅生成计划）')) throw new Error('explicit Chinese installation summary missing');
 const autoZhPlan = await run([...installBase, '--json'], { ...process.env, LC_ALL: 'zh_CN.UTF-8', LANG: 'C' });
@@ -79,9 +79,12 @@ const missingSourceRoute = await new Promise((resolve) => {
 if (missingSourceRoute.code !== 2 || !missingSourceRoute.stderr.includes('requires conversation metadata')) throw new Error('installed wrapper did not fail closed without source routing');
 const serviceFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/openclaw-loop-test-tasks-scheduler.service');
 const timerFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/openclaw-loop-test-tasks-scheduler.timer');
+const dashboardServiceFile = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/loop-engineering-dashboard.service');
+const dashboardDropIn = path.join(process.env.XDG_CONFIG_HOME, 'systemd/user/openclaw-gateway.service.d/loop-engineering-dashboard.conf');
 const service = await readFile(serviceFile, 'utf8');
 const timer = await readFile(timerFile, 'utf8');
 if (!service.includes('scheduler-tick') || !timer.includes('OnUnitActiveSec=1min')) throw new Error('scheduler systemd units were not installed');
+if (!(await readFile(dashboardServiceFile, 'utf8')).includes('dashboard-serve') || !(await readFile(dashboardDropIn, 'utf8')).includes('Wants=loop-engineering-dashboard.service')) throw new Error('OpenClaw installer did not install Dashboard gateway autostart');
 if (service.includes('WorkingDirectory="') || service.includes('ExecStart="') || !service.includes('\\x20') || !service.includes('\\xe5\\xae\\x89\\xe8\\xa3\\x85')) throw new Error('scheduler service paths were not encoded with systemd path escapes');
 const systemdVerify = await new Promise((resolve) => {
   const child = spawn('systemd-analyze', ['verify', serviceFile, timerFile], { stdio: ['ignore', 'pipe', 'pipe'] });

package/scripts/openclaw-install.mjs

@@ -5,7 +5,7 @@ import { spawn } from 'node:child_process';
 import path from 'node:path';
 
 function parseArgs(argv) {
-  const out = { root: process.cwd(), queue: 'agent-tasks', workerAgent: null, openclawBin: 'openclaw', systemctlBin: 'systemctl', language: 'auto', json: false, confirmInstall: false, force: false };
+  const out = { root: process.cwd(), queue: 'agent-tasks', workerAgent: null, openclawBin: 'openclaw', systemctlBin: 'systemctl', dashboardListen: 'localhost', tailscaleBin: 'tailscale', language: 'auto', json: false, confirmInstall: false, force: false };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === '--root') out.root = path.resolve(argv[++i]);
@@ -13,6 +13,8 @@ function parseArgs(argv) {
     else if (arg === '--worker-agent') out.workerAgent = argv[++i];
     else if (arg === '--openclaw-bin') out.openclawBin = argv[++i];
     else if (arg === '--systemctl-bin') out.systemctlBin = argv[++i];
+    else if (arg === '--dashboard-listen') out.dashboardListen = argv[++i];
+    else if (arg === '--tailscale-bin') out.tailscaleBin = argv[++i];
     else if (arg === '--language') out.language = argv[++i];
     else if (arg === '--confirm-install') out.confirmInstall = true;
     else if (arg === '--force') out.force = true;
@@ -20,6 +22,7 @@ function parseArgs(argv) {
     else if (arg === '--help' || arg === '-h') out.help = true;
     else throw new Error(`Unknown argument: ${arg}`);
   }
+  if (!['localhost', 'tailscale'].includes(out.dashboardListen)) throw new Error('--dashboard-listen must be localhost or tailscale.');
   return out;
 }
 
@@ -290,7 +293,7 @@ async function main() {
   const args = parseArgs(process.argv.slice(2));
   args.language = resolveLanguage(args.language);
   if (args.help) {
-    console.log('Usage: loop-engineering-openclaw-install [--root workspace] [--queue agent-tasks] [--worker-agent agent-id] [--language auto|en|zh] [--openclaw-bin openclaw] [--systemctl-bin systemctl] [--confirm-install] [--force] [--json]');
+    console.log('Usage: loop-engineering-openclaw-install [--root workspace] [--queue agent-tasks] [--worker-agent agent-id] [--dashboard-listen localhost|tailscale] [--tailscale-bin tailscale] [--language auto|en|zh] [--openclaw-bin openclaw] [--systemctl-bin systemctl] [--confirm-install] [--force] [--json]');
     return;
   }
   safeId(args.queue, 'queue');
@@ -315,8 +318,9 @@ async function main() {
   };
   const conflicts = [];
   for (const [kind, file] of Object.entries(files)) if (!['instructions', 'workspaceHealth', 'manifest'].includes(kind) && await exists(file)) conflicts.push(path.relative(args.root, file));
-  const confirmationSummary = { targetPlatform: 'OpenClaw', platformCli: args.openclawBin, workspace: args.root, queue: args.queue, scheduler: `systemd user timer ${schedulerTimer}`, notificationTarget: text(args.language, 'source-bound at runtime (original OpenClaw conversation)', '运行时绑定到原始 OpenClaw 会话'), writesEnabled: args.confirmInstall };
-  const report = { version: 1, platform: 'openclaw', language: args.language, status: args.confirmInstall ? 'installed' : 'plan_only', readOnly: !args.confirmInstall, root: args.root, queue: args.queue, workerAgent: args.workerAgent, workerSelection: worker.selection, availableAgents: worker.availableAgents, workerValidated: true, createsWorkerAgent: false, openclawBin: args.openclawBin, systemctlBin: args.systemctlBin, scheduler: { required: true, unit: schedulerUnit, timer: schedulerTimer }, confirmationSummary, files: Object.fromEntries(Object.entries(files).map(([key, file]) => [key, path.relative(args.root, file)])), conflicts };
+  const dashboardDescription = args.dashboardListen === 'tailscale' ? 'read-only Tailnet address on port 4174 coupled to openclaw-gateway.service' : 'read-only http://127.0.0.1:4174/ coupled to openclaw-gateway.service';
+  const confirmationSummary = { targetPlatform: 'OpenClaw', platformCli: args.openclawBin, workspace: args.root, queue: args.queue, scheduler: `systemd user timer ${schedulerTimer}`, dashboard: dashboardDescription, notificationTarget: text(args.language, 'source-bound at runtime (original OpenClaw conversation)', '运行时绑定到原始 OpenClaw 会话'), writesEnabled: args.confirmInstall };
+  const report = { version: 1, platform: 'openclaw', language: args.language, status: args.confirmInstall ? 'installed' : 'plan_only', readOnly: !args.confirmInstall, root: args.root, queue: args.queue, workerAgent: args.workerAgent, workerSelection: worker.selection, availableAgents: worker.availableAgents, workerValidated: true, createsWorkerAgent: false, openclawBin: args.openclawBin, systemctlBin: args.systemctlBin, scheduler: { required: true, unit: schedulerUnit, timer: schedulerTimer }, dashboardAutostart: { required: true, listen: args.dashboardListen, address: args.dashboardListen === 'localhost' ? 'http://127.0.0.1:4174/' : null, gateway: 'openclaw-gateway.service' }, confirmationSummary, files: Object.fromEntries(Object.entries(files).map(([key, file]) => [key, path.relative(args.root, file)])), conflicts };
   report.next = args.confirmInstall ? text(args.language, 'Run loop-engineering-openclaw-doctor, then route a harmless smoke task.', '运行 loop-engineering-openclaw-doctor，然后路由一个无害的冒烟任务。') : text(args.language, 'Review this plan, then rerun with --confirm-install.', '检查此计划，然后使用 --confirm-install 重新运行。');
   if (conflicts.length && !args.force && args.confirmInstall) throw new Error(`Refusing to overwrite: ${conflicts.join(', ')}. Use --force after review.`);
   if (!args.json) console.log(formatConfirmationSummary(confirmationSummary, args.language));
@@ -359,6 +363,9 @@ async function main() {
     if (daemonReload.code !== 0) throw new Error(`Cannot reload user systemd units: ${(daemonReload.stderr || daemonReload.stdout).trim() || `exit ${daemonReload.code}`}`);
     const enableTimer = await run(args.systemctlBin, ['--user', 'enable', '--now', schedulerTimer], { cwd: args.root });
     if (enableTimer.code !== 0) throw new Error(`Cannot enable Loop scheduler timer ${schedulerTimer}: ${(enableTimer.stderr || enableTimer.stdout).trim() || `exit ${enableTimer.code}`}`);
+    const dashboardInstaller = new URL('./dashboard-autostart-install.mjs', import.meta.url).pathname;
+    const dashboardInstall = await run(process.execPath, [dashboardInstaller, '--root', args.root, '--listen', args.dashboardListen, '--tailscale-bin', args.tailscaleBin, '--systemctl-bin', args.systemctlBin, '--confirm-install', '--json'], { cwd: args.root });
+    if (dashboardInstall.code !== 0) throw new Error(`Cannot install Dashboard gateway autostart: ${(dashboardInstall.stderr || dashboardInstall.stdout).trim()}`);
     const instructions = await exists(files.instructions) ? await readFile(files.instructions, 'utf8') : '';
     const managedInstructions = instructionsBlock(args);
     if (!instructions.includes('<!-- loop-engineering:openclaw:start -->')) await appendFile(files.instructions, managedInstructions);

package/scripts/operator-dashboard-self-test.mjs

@@ -12,6 +12,10 @@ await mkdir(path.join(loops, 'action-reservations'), { recursive: true });
 await mkdir(path.join(loops, 'legacy', 'waiting'), { recursive: true });
 await mkdir(path.join(loops, 'legacy', 'active'), { recursive: true });
 await mkdir(path.join(loops, 'projects', 'p3', 'intake'), { recursive: true });
+await mkdir(path.join(loops, 'projects', 'p3', 'backlog'), { recursive: true });
+await mkdir(path.join(loops, 'projects', 'p3', 'completion'), { recursive: true });
+await mkdir(path.join(loops, 'legacy', 'tasks', 'task-project', 'checkpoints'), { recursive: true });
+await mkdir(path.join(loops, 'legacy', 'tasks', 'task-project', 'reviews'), { recursive: true });
 await mkdir(path.join(root, '.production-evidence'), { recursive: true });
 const now = '2026-08-13T16:00:00.000Z';
 const control = {
@@ -27,6 +31,13 @@ await writeFile(path.join(loops, 'action-reservations', 'x.json'), JSON.stringif
 await writeFile(path.join(loops, 'legacy', 'waiting', 'vps.json'), JSON.stringify({ id: 'vps', title: 'VPS down', parked: { kind: 'external_condition', next_check_at: '2026-08-13T17:00:00.000Z' }, provider: 'hidden' }));
 await writeFile(path.join(loops, 'legacy', 'active', 'bad.json'), '{broken');
 await writeFile(path.join(loops, 'projects', 'p3', 'intake', 'latest.json'), JSON.stringify({ version: 1, goal: 'Operator dashboard', token: 'hidden' }));
+await writeFile(path.join(loops, 'projects', 'p3', 'backlog', 'initial.json'), JSON.stringify({ tasks: [{ id: 'm1', title: 'Projection foundation', status: 'completed' }, { id: 'm2', title: 'Interaction polish', status: 'pending' }] }));
+await writeFile(path.join(loops, 'projects', 'p3', 'terminal-contract.json'), JSON.stringify({ status: 'active', terminalState: { accepted: false, userVisibleOutcome: 'Daily browser workspace' }, milestoneRule: 'A milestone is not project completion.', completionRule: 'All requirements and final judge must pass.', requirements: [{ id: 'workspace', status: 'active' }] }));
+await writeFile(path.join(loops, 'projects', 'p3', 'completion', 'latest.json'), JSON.stringify({ status: 'active', terminalAccepted: false, unmet: ['interaction polish'] }));
+await writeFile(path.join(loops, 'legacy', 'tasks', 'task-project', 'task_contract.json'), JSON.stringify({ title: 'Project foundation', task_scope: 'project' }));
+await writeFile(path.join(loops, 'legacy', 'tasks', 'task-project', 'checkpoints', 'cp1.json'), JSON.stringify({ checkpoint_id: 'cp1', milestone_id: 'm1', project_id: 'p3', status: 'ready_for_acceptance', summary: 'Foundation ready', amendment_version: 2, created_at: now }));
+await writeFile(path.join(loops, 'legacy', 'tasks', 'task-project', 'reviews', 'cp1.json'), JSON.stringify({ checkpoint_id: 'cp1', status: 'accepted', passed: 'projection complete', created_at: now }));
+await writeFile(path.join(loops, 'legacy', 'tasks', 'task-project', 'final_judgement.json'), JSON.stringify({ outcome: 'project_in_progress', reasons: ['Milestone accepted; terminal contract remains open.'], created_at: now }));
 await writeFile(path.join(root, '.production-evidence', 'public-summary.json'), JSON.stringify({ schema: 'loop.production_trust_public_summary', schema_version: 1, passed: true, evidence_digest: 'fixture', metrics: { duplicate_settled_effects: 0 } }));
 await registerStep(root, { stepId: 'run:1:effect:send', kind: 'effect', effectKey: 'send:1', input: { api_key: 'hidden', body: 'hello' } });
 const ledgerClaim = await claimStep(root, { stepId: 'run:1:effect:send', owner: 'a' });
@@ -44,6 +55,11 @@ assert.equal(first.actions[0].state, 'reconciliation_required');
 assert.equal(first.execution_steps[0].state, 'reconciliation_required');
 assert.equal(first.overview.reconciliation_required_steps, 1);
 assert.equal(first.overview.production_trust, 'passed');
+assert.equal(first.overview.task_workspace_count, 1);
+assert.equal(first.projects[0].terminal_accepted, false);
+assert.equal(first.projects[0].project_summary.completed_milestones, 1);
+assert.equal(first.projects[0].tasks[0].timeline.at(-1).type, 'final_judge');
+assert.equal(first.projects[0].tasks[0].revision_lineage[0].milestone_id, 'm1');
 assert.equal(first.production_evidence.metrics.duplicate_settled_effects, 0);
 assert.equal(first.queues[0].tasks[0].state, 'waiting_for_external_condition');
 assert.equal(first.agents[0].provider_token, '[REDACTED]');
@@ -68,6 +84,15 @@ try {
   const detail = await fetch(`${base}/api/v1/todos/human`).then((response) => response.json());
   assert.match(detail.title, /onerror/);
   const page = await fetch(base).then((response) => response.text());
+  assert.match(page, /aria-live="polite"/);
+  assert.match(page, /aria-pressed/);
+  assert.match(page, /history\.replaceState/);
+  assert.match(page, /No matching operational work/);
+  assert.match(page, /Unable to load workspace/);
+  assert.match(page, /Gates & reservations/);
+  assert.doesNotMatch(page, /approve|confirm-send|settle reservation/i);
+  const project = await fetch(`${base}/api/v1/projects/p3`).then((response) => response.json());
+  assert.equal(project.terminal_contract.milestone_rule, 'A milestone is not project completion.');
   assert.doesNotMatch(page, /<img src=x/);
   assert.equal((await fetch(`${base}/api/v1/todos/%2e%2e%2fsecret`)).status, 400);
   assert.equal((await fetch(`${base}/api/v1/unknown`)).status, 404);
@@ -81,4 +106,4 @@ const started = performance.now(); const large = await buildOperatorProjection(r
 assert.equal(large.queues.find((queue) => queue.id === 'large').tasks.length, 500);
 assert.ok(performance.now() - started < 5000, '500 task projection should finish under 5 seconds');
 
-console.log(JSON.stringify({ status: 'ok', assertions: 'empty-compatible, legacy, malformed, deterministic, read-only, P0 gates, P1 reconciliation, P2 lease/handoff, redaction, XSS, traversal, bind safety, export, restart-safe server, large queue performance' }));
+console.log(JSON.stringify({ status: 'ok', assertions: 'empty-compatible, legacy, malformed, deterministic, read-only, project terminal/milestone split, revision and final-judge timeline, persistent URL state, keyboard and live-region accessibility, empty/error states, responsive UI, P0 gates, P1 reconciliation, P2 lease/handoff, redaction, XSS, traversal, bind safety, export, restart-safe server, large queue performance' }));

package/scripts/operator-workspace-final-judgement.mjs

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const files = {
+  implementation: await readFile(new URL('../lib/operator-dashboard.mjs', import.meta.url), 'utf8'),
+  tests: await readFile(new URL('./operator-dashboard-self-test.mjs', import.meta.url), 'utf8'),
+  docs: await readFile(new URL('../docs/operator-dashboard.md', import.meta.url), 'utf8'),
+  contract: await readFile(new URL('../docs/operator-workspace-project.md', import.meta.url), 'utf8'),
+  schema: await readFile(new URL('../templates/operator-projection.schema.json', import.meta.url), 'utf8')
+};
+
+const criteria = [
+  ['terminal contract', files.implementation, 'terminal_contract'],
+  ['milestone status', files.implementation, 'milestones'],
+  ['total project acceptance', files.implementation, 'terminal_accepted'],
+  ['revision lineage', files.implementation, 'revision_lineage'],
+  ['human gates', files.implementation, 'human_input_context.json'],
+  ['reservations', files.implementation, 'action-reservations'],
+  ['acceptance review', files.implementation, 'acceptance_review'],
+  ['independent final judge', files.implementation, 'final_judge'],
+  ['project detail endpoint', files.implementation, '/api/v1/projects/'],
+  ['read-only HTTP methods', files.implementation, "request.method !== 'GET'"],
+  ['loopback safety', files.implementation, 'allowNonLoopback'],
+  ['redaction', files.implementation, '[REDACTED]'],
+  ['persistent URL state', files.implementation, 'history.replaceState'],
+  ['keyboard controls', files.implementation, "n.type='button'"],
+  ['live status', files.implementation, 'aria-live'],
+  ['responsive viewport', files.implementation, '@media(max-width:640px)'],
+  ['empty state', files.implementation, 'No matching operational work'],
+  ['error state', files.implementation, 'Unable to load workspace'],
+  ['static export', files.implementation, "html('./projection.json')"],
+  ['schema task workspaces', files.schema, 'task_workspaces'],
+  ['security tests', files.tests, '%2e%2e%2fsecret'],
+  ['large workspace test', files.tests, '500 task projection'],
+  ['operator docs', files.docs, 'responsive'],
+  ['terminal completion rule', files.contract, 'No single page, milestone, checkpoint'],
+  ['three milestones', files.contract, 'Release hardening']
+];
+
+for (const [name, body, token] of criteria) assert.ok(body.includes(token), `${name} criterion missing: ${token}`);
+console.log(JSON.stringify({ outcome: 'accept', checks: criteria.length, accepted: criteria.map(([name]) => name) }, null, 2));

package/skills/taskforce-loop-engineering/SKILL.md

@@ -72,6 +72,8 @@ loop-engineering-openclaw-install \
   --confirm-install
 ```
 
+The confirmed install also creates `loop-engineering-dashboard.service` on port `4174` and couples it to `openclaw-gateway.service`. Dashboard listening defaults to local-only `127.0.0.1`. To permit Tailnet clients, pass `--dashboard-listen tailscale`; the installer resolves `tailscale ip -4`, binds only that `100.x` address, and fails closed rather than binding all interfaces. Tailnet mode relies on Tailscale ACLs/Grants and does not add application-level login. The plan must declare the selected mode before writes, and the doctor must verify the Dashboard service and gateway drop-in. Use `loop-engineering-dashboard-autostart-install --listen localhost|tailscale` only for standalone install or repair.
+
 The installer never creates the worker agent. After installation, verify wiring before using a real task:
 
 ```bash
@@ -111,6 +113,8 @@ loop-engineering-hermes-smoke \
   --queue agent-tasks
 ```
 
+The confirmed Hermes install creates the same Dashboard service and couples it to `hermes-gateway.service`. It accepts `--dashboard-listen localhost|tailscale` with the same default-local, Tailnet-only binding, fail-closed resolution, and ACL/Grant boundary as OpenClaw. The plan and doctor must expose and verify this coupling.
+
 The generated worker uses `hermes -z` (`--oneshot`); the notifier uses `hermes send` without
 an LLM call. Preserve source metadata and pass `--source-target` in Hermes
 `platform:chat_id[:thread_id]` format. The managed systemd scheduler owns wakeups

package/templates/operator-projection.schema.json

@@ -1 +1 @@
-{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://loop-engineering.local/schema/operator-projection-v1.json","title":"Loop Engineering read-only operator projection v1","type":"object","required":["schema_version","generated_at","source","health","overview","projects","queues","todos","agents","handoffs","gates","actions","cost"],"properties":{"schema_version":{"const":"1.0.0"},"generated_at":{"type":"string","format":"date-time"},"source":{"type":"object"},"health":{"type":"object"},"overview":{"type":"object"},"projects":{"type":"array"},"queues":{"type":"array"},"todos":{"type":"array"},"agents":{"type":"array"},"handoffs":{"type":"array"},"gates":{"type":"array"},"actions":{"type":"array"},"cost":{"type":"object"}},"additionalProperties":false}
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://loop-engineering.local/schema/operator-projection-v1.json","title":"Loop Engineering read-only operator projection v1","type":"object","required":["schema_version","generated_at","source","health","overview","projects","task_workspaces","queues","todos","agents","handoffs","gates","actions","cost"],"properties":{"schema_version":{"const":"1.0.0"},"generated_at":{"type":"string","format":"date-time"},"source":{"type":"object"},"health":{"type":"object"},"overview":{"type":"object"},"projects":{"type":"array"},"task_workspaces":{"type":"array"},"queues":{"type":"array"},"todos":{"type":"array"},"agents":{"type":"array"},"handoffs":{"type":"array"},"gates":{"type":"array"},"actions":{"type":"array"},"execution_steps":{"type":"array"},"production_evidence":{},"cost":{"type":"object"}},"additionalProperties":false}