taskforce-loop-engineering 0.15.12 → 0.15.14

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;
 }
 
@@ -178,6 +181,7 @@ function run(args) {
     child.on('close', (code, signal) => resolve(code ?? (signal ? 128 : 1)));
   });
 }
+
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function runWhenUnlocked(args, waitMs = 300000) {
   const deadline = Date.now() + waitMs;
@@ -226,6 +230,31 @@ if (command === 'route') {
 `;
 }
 
+function gateBridgeSource({ humanGateAdapter }) {
+  return `#!/usr/bin/env node
+import { handleChannelGateEvent, normalizeFeishuGateEvent } from ${JSON.stringify(humanGateAdapter)};
+if (process.argv.includes('--self-test')) {
+  let rejected = false;
+  try { normalizeFeishuGateEvent({ event: {} }); } catch (error) { rejected = error?.message === 'feishu_signature_unverified'; }
+  if (!rejected) throw new Error('feishu_signature_boundary_not_fail_closed');
+  const ignored = await handleChannelGateEvent(process.env.LOOP_WORKSPACE_ROOT || process.cwd(), { kind: 'ordinary_message', text: 'approve the first one' });
+  if (ignored.outcome !== 'ignored_untrusted_chat') throw new Error('ordinary_chat_not_fail_closed');
+  process.stdout.write(JSON.stringify({ status: 'ok', externalWrite: false, signatureBoundary: 'fail_closed', ordinaryChat: 'ignored' }) + '\\n');
+  process.exit(0);
+}
+const chunks = [];
+for await (const chunk of process.stdin) chunks.push(chunk);
+if (!chunks.length) throw new Error('gate_event_required_on_stdin');
+const payload = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+const channel = String(process.env.LOOP_GATE_CHANNEL || payload.channel || '').toLowerCase();
+const event = channel === 'feishu'
+  ? normalizeFeishuGateEvent(payload, { signatureVerified: process.env.LOOP_FEISHU_SIGNATURE_VERIFIED === '1' })
+  : payload;
+const result = await handleChannelGateEvent(process.env.LOOP_WORKSPACE_ROOT || process.cwd(), event);
+process.stdout.write(JSON.stringify(result) + '\\n');
+`;
+}
+
 function schedulerServiceSource({ root, queue, language }) {
   return `[Unit]\nDescription=${text(language, `Taskforce Loop Engineering scheduler for ${queue}`, `${queue} 的 Taskforce Loop Engineering 调度器`)}\nAfter=default.target\n\n[Service]\nType=oneshot\nWorkingDirectory=${systemdEscapePath(root)}\nExecStart=${systemdEscapePath(process.execPath)} ${systemdEscapePath(path.join(root, 'scripts', 'loops', 'openclaw-loop.mjs'))} scheduler-tick --json\n`;
 }
@@ -267,6 +296,8 @@ function instructionsBlock({ queue, language }) {
 - 从当前工作区运行 \`node scripts/loops/openclaw-loop.mjs route --message "<完整用户消息>"\`，并保留来源元数据。
 - 会话来源任务必须使用标准包装器。缺少来源元数据时必须失败关闭，不能退回手工入队或直接运行队列。
 - 人工门禁或终态只有在通知命令成功并写入通知记录后才算已送达。
+- Dashboard 与聊天审批必须共用 Gate Command 和同一份门禁状态；聊天接入使用 \`scripts/loops/openclaw-loop-gate.mjs\`。
+- 飞书回调必须先由可信传输层验签，再设置 \`LOOP_FEISHU_SIGNATURE_VERIFIED=1\` 调用 Gate bridge；未验签失败关闭。普通聊天、引用、转发和截图不能审批。
 - 已由 Loop 管理的任务必须直接执行，不能再次路由。
 - 状态查询只读。高风险外部动作、破坏性操作、生产变更、凭据操作和记忆迁移仍需单独确认。
 - 队列：\`${queue}\`。
@@ -280,6 +311,8 @@ function instructionsBlock({ queue, language }) {
 - Run \`node scripts/loops/openclaw-loop.mjs route --message "<full user message>"\` from this workspace and preserve source metadata when available.
 - For conversation-originated work, the standard wrapper is mandatory. Missing source metadata must fail closed; never fall back to manual enqueue or direct run-queue.
 - A human-gated or terminal state is not delivered until its notification command succeeds and writes a notification record.
+- Dashboard and chat approvals must share the Gate Command core and one gate state; chat transports use \`scripts/loops/openclaw-loop-gate.mjs\`.
+- A trusted transport must verify Feishu callbacks before setting \`LOOP_FEISHU_SIGNATURE_VERIFIED=1\`; unverified callbacks fail closed. Ordinary chat, quotes, forwards, and screenshots cannot approve.
 - An already loop-managed task must be executed directly and never routed again.
 - Status questions are read-only. High-risk external, destructive, production, credential, or memory migration actions remain separately gated.
 - Queue: \`${queue}\`.
@@ -290,7 +323,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');
@@ -299,6 +332,7 @@ async function main() {
   const worker = await resolveWorkerAgent(args);
   args.workerAgent = worker.workerAgent;
   args.loopBin = new URL('../bin/loop-engineering.mjs', import.meta.url).pathname;
+  args.humanGateAdapter = new URL('../lib/human-gate-channel-adapter.mjs', import.meta.url).href;
   const systemdUserDir = path.join(process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || '', '.config'), 'systemd', 'user');
   const schedulerUnit = `openclaw-loop-${args.queue}-scheduler.service`;
   const schedulerTimer = `openclaw-loop-${args.queue}-scheduler.timer`;
@@ -308,6 +342,7 @@ async function main() {
     dispatcher: path.join(args.root, 'scripts', 'loops', 'openclaw-loop-dispatch.mjs'),
     wrapper: path.join(args.root, 'scripts', 'loops', 'openclaw-loop.mjs'),
     notifier: path.join(args.root, 'scripts', 'loops', 'openclaw-loop-notify.mjs'),
+    gateBridge: path.join(args.root, 'scripts', 'loops', 'openclaw-loop-gate.mjs'),
     manifest: path.join(args.root, 'runtime', 'loop-engineering-openclaw-install.json'),
     instructions: path.join(args.root, 'AGENTS.md'),
     schedulerService: path.join(systemdUserDir, schedulerUnit),
@@ -315,8 +350,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, humanGate: 'Dashboard + source-bound chat Gate Command bridge', 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));
@@ -346,12 +382,14 @@ async function main() {
     const dispatcherContent = dispatcherSource(args);
     const wrapperContent = wrapperSource(args);
     const notifierContent = notifierSource(args);
+    const gateBridgeContent = gateBridgeSource(args);
     const schedulerServiceContent = schedulerServiceSource(args);
     const schedulerTimerContent = schedulerTimerSource(args);
     await writeFile(files.queueConfig, queueContent);
     await writeFile(files.dispatcher, dispatcherContent);
     await writeFile(files.wrapper, wrapperContent);
     await writeFile(files.notifier, notifierContent);
+    await writeFile(files.gateBridge, gateBridgeContent);
     await mkdir(systemdUserDir, { recursive: true });
     await writeFile(files.schedulerService, schedulerServiceContent);
     await writeFile(files.schedulerTimer, schedulerTimerContent);
@@ -359,17 +397,21 @@ 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);
     await mkdir(path.dirname(files.manifest), { recursive: true });
     await writeFile(files.manifest, `${JSON.stringify({
-      version: 3, queue: args.queue, language: args.language, workerAgent: args.workerAgent, openclawBin: args.openclawBin, systemctlBin: args.systemctlBin, installedAt: new Date().toISOString(),
+      version: 4, queue: args.queue, language: args.language, workerAgent: args.workerAgent, openclawBin: args.openclawBin, systemctlBin: args.systemctlBin, installedAt: new Date().toISOString(),
       managedFiles: [
         { path: path.relative(args.root, files.queueConfig), sha256: sha256(queueContent) },
         { path: path.relative(args.root, files.dispatcher), sha256: sha256(dispatcherContent) },
         { path: path.relative(args.root, files.wrapper), sha256: sha256(wrapperContent) },
-        { path: path.relative(args.root, files.notifier), sha256: sha256(notifierContent) }
+        { path: path.relative(args.root, files.notifier), sha256: sha256(notifierContent) },
+        { path: path.relative(args.root, files.gateBridge), sha256: sha256(gateBridgeContent) }
       ],
       managedUnits: [
         { path: files.schedulerService, unit: schedulerUnit, sha256: sha256(schedulerServiceContent) },

package/scripts/openclaw-smoke.mjs

@@ -53,6 +53,10 @@ async function main() {
     const doctor = await run(process.execPath, [doctorScript, '--root', args.root, '--queue', args.queue, '--worker-agent', args.workerAgent, '--openclaw-bin', args.openclawBin, '--json'], { cwd: args.root });
     steps.push({ id: 'doctor', ok: doctor.code === 0 });
     if (doctor.code !== 0) throw new Error(`doctor failed: ${doctor.stderr || doctor.stdout}`);
+    const doctorReport = JSON.parse(doctor.stdout);
+    const gateSelfTestOk = doctorReport.checks?.some((check) => check.id === 'human_gate_bridge_self_test' && check.ok);
+    steps.push({ id: 'human_gate_bridge_self_test', ok: gateSelfTestOk === true });
+    if (!gateSelfTestOk) throw new Error('doctor did not verify the installed Human Gate bridge');
     const config = JSON.parse(await readFile(baseConfig, 'utf8'));
     config.queue = smokeQueue;
     config.description = 'Temporary read-only OpenClaw integration smoke queue.';

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,16 @@ 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.match(page, /approve/);
+  assert.doesNotMatch(page, /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 +107,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/scripts/quota-runtime-decision-self-test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { decideQuota, readQuotaLedger, recordVerifiedSliceSpend } from '../lib/quota-runtime-decision.mjs';
+
+const budget = { tokens: 100, time_ms: 1_000, money_minor: 50, rounds: 3 };
+const request = { tokens: 10, time_ms: 100, money_minor: 5, rounds: 1 };
+assert.equal(decideQuota({ has_work: true, limits: budget, request }).decision, 'execute');
+assert.equal(decideQuota({ has_work: false, limits: budget }).decision, 'silent');
+assert.equal(decideQuota({ has_work: true, repairable_error: true, limits: budget }).decision, 'self-repair');
+assert.equal(decideQuota({ has_work: true, external_condition_pending: true, limits: budget }).decision, 'wait');
+assert.equal(decideQuota({ has_work: true, limits: budget, spend: { tokens: 95 }, request }).decision, 'wait');
+assert.equal(decideQuota({ has_work: true, limits: budget, spend: { tokens: 95 }, request, can_wait_for_reset: false }).decision, 'ask');
+
+const fallback = decideQuota({ has_work: true, limits: budget, request, lane_id: 'paid', lanes: [
+  { id: 'paid', state: 'waiting_for_human' },
+  { id: 'local', state: 'runnable', safe_fallback: true, audited: true }
+] });
+assert.equal(fallback.decision, 'execute'); assert.equal(fallback.lane_id, 'local'); assert.equal(fallback.reason, 'audited_safe_fallback');
+assert.equal(decideQuota({ has_work: true, limits: budget, request, lane_id: 'paid', lanes: [{ id: 'paid', state: 'waiting_for_human' }, { id: 'unsafe', state: 'runnable', safe_fallback: true, audited: false }] }).decision, 'ask');
+
+const root = await mkdtemp(path.join(tmpdir(), 'quota-runtime-'));
+assert.equal((await recordVerifiedSliceSpend(root, { slice_id: 'idle', status: 'idle', verified: false, spend: request })).recorded, false);
+assert.deepEqual((await readQuotaLedger(root)).spend, { tokens: 0, time_ms: 0, money_minor: 0, rounds: 0 });
+assert.equal((await recordVerifiedSliceSpend(root, { slice_id: 's1', status: 'completed', verified: true, spend: request, evidence: 'test:pass' })).recorded, true);
+assert.equal((await recordVerifiedSliceSpend(root, { slice_id: 's1', status: 'completed', verified: true, spend: request })).recorded, false);
+assert.deepEqual((await readQuotaLedger(root)).spend, request);
+console.log(JSON.stringify({ ok: true, assertions: ['five decisions', 'scheduler hint', 'four budget dimensions', 'verified-only spend', 'idle free', 'idempotent spend', 'audited fallback'] }));

package/scripts/todo-control-plane-self-test.mjs

@@ -23,7 +23,10 @@ await assert.rejects(() => renewTodo(root, { todoId: 'race', agentId: loser ===
 await todo('capability');
 assert.equal((await claimTodo(root, { todoId: 'capability', agentId: 'observer' })).reason, 'capability_mismatch');
 await todo('quota');
-assert.equal((await claimTodo(root, { todoId: 'quota', agentId: 'poor' })).reason, 'quota_exhausted');
+const quotaRejected = await claimTodo(root, { todoId: 'quota', agentId: 'poor' });
+assert.equal(quotaRejected.reason, 'quota_exhausted');
+assert.equal(quotaRejected.decision, 'wait');
+assert.equal(quotaRejected.scheduler_hint.action, 'wait');
 
 await todo('dependency');
 await todo('dependent', { dependencies: ['dependency'], priority: 100 });

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,11 +113,21 @@ 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
 so durable queue continuity does not depend on resuming a Hermes Cron session.
 
+## Cross-interface Human Gates
+
+Dashboard and chat approvals use one Gate Command core and one authoritative gate artifact. Cards must show project/task, Gate ID, action, reason, impact, risk, cost/budget, evidence, Dashboard URL, expiry and generation; processed cards are refreshed disabled. Only card buttons or exact card-bound `/approve gate_<id>`, `/reject gate_<id>` and `/request_revision gate_<id> <reason>` replies may mutate a gate. Ordinary chat, quotes, forwards, screenshots and ordinal phrases fail closed as `ignored_untrusted_chat`; `/show_gate gate_<id>` is display-only.
+
+The OpenClaw installer generates `scripts/loops/openclaw-loop-gate.mjs`. A trusted Feishu callback/plugin transport must verify the official signature or encrypted-event envelope, timestamp/nonce and secret before invoking it with `LOOP_GATE_CHANNEL=feishu` and `LOOP_FEISHU_SIGNATURE_VERIFIED=1`; missing verification fails with `feishu_signature_unverified`. The bridge itself performs no delivery. Other channel transports pass normalized, source-bound events. Dashboard and chat commands share actor/source binding, generation fencing, idempotency receipts, confirmation escalation and synchronized card state.
+
+After installation, run `loop-engineering-openclaw-doctor` and `loop-engineering-openclaw-smoke`. Doctor syntax-checks and locally self-tests the Gate bridge; smoke remains disposable and uses dry-run notifications. Neither command sends an online test message.
+
 ## Conversation Contract
 
 Interpret explicit loop language as follows:

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}