taskforce-loop-engineering 0.15.12 → 0.15.14

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/distribution-skill-self-test.mjs

@@ -1,14 +1,24 @@
 import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 
-const skill = await readFile(new URL('../skills/taskforce-loop-engineering/SKILL.md', import.meta.url), 'utf8');
+const distributedSkillUrl = new URL('../skills/taskforce-loop-engineering/SKILL.md', import.meta.url);
+const workspaceSkillUrl = new URL('../../../skills/taskforce-loop-engineering/SKILL.md', import.meta.url);
+const skill = await readFile(distributedSkillUrl, 'utf8');
 
 for (const forbidden of ['ironman-task-runner', 'ironman-task-runner.mjs']) {
   assert.equal(skill.includes(forbidden), false, `distributed skill contains local dispatcher reference: ${forbidden}`);
 }
 
-for (const required of ['agent-tasks', 'scripts/loops/openclaw-loop.mjs', 'configs/loops/queues/']) {
+for (const required of ['agent-tasks', 'scripts/loops/openclaw-loop.mjs', 'scripts/loops/openclaw-loop-gate.mjs', 'configs/loops/queues/', 'feishu_signature_unverified', 'ignored_untrusted_chat', 'Dashboard and chat']) {
   assert.equal(skill.includes(required), true, `distributed skill is missing generic integration guidance: ${required}`);
 }
 
+try {
+  await access(workspaceSkillUrl);
+  const workspaceSkill = await readFile(workspaceSkillUrl, 'utf8');
+  assert.equal(workspaceSkill, skill, 'workspace taskforce-loop-engineering skill drifted from the distributed skill');
+} catch (error) {
+  if (error?.code !== 'ENOENT') throw error;
+}
+
 console.log('distribution skill 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/human-gate-command-self-test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createHumanGate, executeGateCommand, getHumanGate, parseBoundReply } from '../lib/human-gate-command.mjs';
+import { handleChannelGateEvent, normalizeFeishuGateEvent, renderGateForChannel } from '../lib/human-gate-channel-adapter.mjs';
+import { createDashboardServer } from '../lib/operator-dashboard.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-gate-command-'));
+const base = { project: 'p', task: 't', action: 'deploy', reason: 'release', impact: 'production', risk: { level: 'high' }, cost: { amount: 10, currency: 'CNY', budget: 100 }, evidence: ['test'], dashboard_url: 'http://127.0.0.1:4174/', expiry: '2030-01-01T00:00:00.000Z', allowed_actors: ['owner'], source_bindings: [{ channel: 'feishu', message_id: 'card-1', reply_to: 'card-1', adapter: 'feishu' }, { channel: 'dashboard', message_id: 'gate-panel', reply_to: 'gate-panel', adapter: 'dashboard' }] };
+const command = { gate_id: 'gate_high', decision: 'approve', expected_generation: 1, actor_id: 'owner', source_channel: 'feishu', source_message_id: 'card-1', event_type: 'card_button', idempotency_key: 'event-1' };
+try {
+  await createHumanGate(root, { ...base, gate_id: 'gate_high' });
+  const card = await renderGateForChannel(root, 'gate_high');
+  assert.deepEqual(card.buttons.map((x) => x.decision).sort(), ['approve', 'reject', 'request_revision']); assert.equal(card.fields.cost.budget, 100);
+  const first = await executeGateCommand(root, command, { now: '2029-01-01T00:00:00.000Z' }); assert.equal(first.outcome, 'confirmation_required'); assert.equal(first.resulting_generation, 2);
+  const replay = await executeGateCommand(root, command); assert.equal(replay.replayed, true); assert.equal(replay.receipt_id, first.receipt_id);
+  await assert.rejects(executeGateCommand(root, { ...command, idempotency_key: 'event-stale' }, { now: '2029-01-01T00:00:02.000Z' }), /stale_generation/);
+  assert.equal((await executeGateCommand(root, { ...command, expected_generation: 2, idempotency_key: 'event-2' }, { now: '2029-01-01T00:00:03.000Z' })).outcome, 'approved');
+  await assert.rejects(executeGateCommand(root, { ...command, expected_generation: 2, idempotency_key: 'event-after' }), /gate_already_processed/);
+  await createHumanGate(root, { ...base, gate_id: 'gate_low', action: 'local edit', risk: { level: 'low' }, confirmation_required: false });
+  for (const bad of [{ actor_id: 'intruder' }, { source_channel: 'other' }, { source_message_id: 'forward' }, { event_type: 'natural_language' }]) await assert.rejects(executeGateCommand(root, { ...command, gate_id: 'gate_low', idempotency_key: `bad-${Object.keys(bad)[0]}`, ...bad }, { now: '2029-01-01T00:00:00.000Z' }), /(unauthorized|mismatch|untrusted)/);
+  assert.equal((await handleChannelGateEvent(root, { kind: 'ordinary_message', text: '好的，同意第一个' })).outcome, 'ignored_untrusted_chat'); assert.equal(parseBoundReply('同意'), null); assert.equal(parseBoundReply('/approve gate_low').gate_id, 'gate_low');
+  assert.equal((await handleChannelGateEvent(root, { kind: 'ordinary_message', text: '/show_gate gate_low' })).outcome, 'display_only');
+  const revision = await handleChannelGateEvent(root, { kind: 'message_reply', event_id: 'rev-1', actor_id: 'owner', channel: 'feishu', card_message_id: 'card-1', reply_to: 'card-1', text: '/request_revision gate_low fix evidence', expected_generation: 1 }, { now: '2029-01-01T00:00:00.000Z' });
+  assert.equal(revision.outcome, 'revision_created'); assert.equal((await getHumanGate(root, 'gate_low')).generation, 2);
+  assert.equal(revision.synchronized_card.buttons.every((button) => button.expected_generation === 2), true);
+  await createHumanGate(root, { ...base, gate_id: 'gate_expired', expiry: '2028-01-01T00:00:00.000Z', confirmation_required: false });
+  await assert.rejects(executeGateCommand(root, { ...command, gate_id: 'gate_expired', idempotency_key: 'expired' }, { now: '2029-01-01T00:00:00.000Z' }), /gate_expired/);
+  const feishuPayload = { header: { event_id: 'fs-1' }, event: { operator: { operator_id: { open_id: 'owner' } }, context: { open_message_id: 'card-1' }, action: { value: { gate_id: 'gate_high', decision: 'approve', expected_generation: 2 } } } };
+  assert.throws(() => normalizeFeishuGateEvent(feishuPayload), /feishu_signature_unverified/);
+  const feishu = normalizeFeishuGateEvent(feishuPayload, { signatureVerified: true }); assert.equal(feishu.kind, 'card_button');
+  await createHumanGate(root, { ...base, gate_id: 'gate_race', confirmation_required: false });
+  const raceBase = { ...command, gate_id: 'gate_race', decision: 'reject', expected_generation: 1 };
+  const race = await Promise.allSettled([executeGateCommand(root, { ...raceBase, idempotency_key: 'race-a' }), executeGateCommand(root, { ...raceBase, idempotency_key: 'race-b' })]);
+  assert.equal(race.filter((x) => x.status === 'fulfilled').length, 1); assert.equal(race.filter((x) => x.status === 'rejected').length, 1);
+  await createHumanGate(root, { ...base, gate_id: 'gate_cross', confirmation_required: false });
+  const cross = await Promise.allSettled([
+    executeGateCommand(root, { ...command, gate_id: 'gate_cross', idempotency_key: 'cross-feishu' }),
+    executeGateCommand(root, { ...command, gate_id: 'gate_cross', source_channel: 'dashboard', source_message_id: 'gate-panel', idempotency_key: 'cross-dashboard' })
+  ]);
+  assert.equal(cross.filter((x) => x.status === 'fulfilled').length, 1);
+  await createHumanGate(root, { ...base, gate_id: 'gate_http', confirmation_required: false });
+  const server = await createDashboardServer(root, { host: '127.0.0.1', port: 0 });
+  try {
+    const address = server.address();
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/v1/gate-commands`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ gate_id: 'gate_http', decision: 'approve', expected_generation: 1, actor_id: 'owner', source_message_id: 'gate-panel', idempotency_key: 'http-1' }) });
+    assert.equal(response.status, 200); assert.equal((await response.json()).outcome, 'approved');
+    const gatesResponse = await fetch(`http://127.0.0.1:${address.port}/api/v1/gates`); assert.equal(gatesResponse.status, 200); assert.ok((await gatesResponse.json()).some((g) => g.gate_id === 'gate_http'));
+  } finally { await new Promise((resolve) => server.close(resolve)); }
+  console.log('human-gate-command self-test: ok (unit, integration, replay, expiry, authorization, misrecognition, Feishu mapping, concurrency)');
+} finally { await rm(root, { recursive: true, force: true }); }

package/scripts/human-gate-final-judgement.mjs

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const files = {
+  core: new URL('../lib/human-gate-command.mjs', import.meta.url),
+  adapter: new URL('../lib/human-gate-channel-adapter.mjs', import.meta.url),
+  dashboard: new URL('../lib/operator-dashboard.mjs', import.meta.url),
+  tests: new URL('./human-gate-command-self-test.mjs', import.meta.url),
+  docs: new URL('../docs/human-gate-command.md', import.meta.url)
+};
+const source = Object.fromEntries(await Promise.all(Object.entries(files).map(async ([key, file]) => [key, await readFile(file, 'utf8')])));
+const checks = {
+  single_command_core: /executeGateCommand/.test(source.core) && /executeGateCommand/.test(source.adapter) && /executeGateCommand/.test(source.dashboard),
+  decisions: ['approve', 'reject', 'request_revision'].every((value) => source.core.includes(value)),
+  strict_binding: ['expected_generation', 'actor_unauthorized', 'source_channel_mismatch', 'source_message_mismatch', 'reply_binding_mismatch', 'gate_expired'].every((value) => source.core.includes(value)),
+  receipt_and_idempotency: /receipt_id/.test(source.core) && /idempotency_key_reused/.test(source.core),
+  cas_generation_fence: /gate_conflict_retry/.test(source.core) && /stale_generation/.test(source.core),
+  confirmation: /awaiting_confirmation/.test(source.core) && /confirmation_required/.test(source.core),
+  revision_artifact: /revisions/.test(source.core) && /supersedes_generation/.test(source.core),
+  fail_closed_chat: /ignored_untrusted_chat/.test(source.adapter) && /\/show_gate/.test(source.adapter),
+  synchronized_card: /synchronized_card/.test(source.adapter) && /disabled/.test(source.core),
+  complete_card: ['project', 'task', 'gate_id', 'action', 'reason', 'impact', 'risk', 'cost', 'evidence', 'dashboard_url', 'expiry', 'generation'].every((value) => source.core.includes(value)),
+  dashboard_buttons: /gate-commands/.test(source.dashboard) && ['approve', 'reject', 'request_revision'].every((value) => source.dashboard.includes(value)),
+  feishu_feasibility_no_send: /normalizeFeishuGateEvent/.test(source.adapter) && !/fetch\(|spawn\(|message.send/.test(source.adapter),
+  feishu_signature_boundary: /feishu_signature_unverified/.test(source.adapter) && /signatureVerified/.test(source.adapter),
+  fault_injection: ['race', 'replay', 'expired', 'intruder', 'forward', 'ordinary_message'].every((value) => source.tests.includes(value)),
+  documented_trust_boundary: /sole mutation boundary/.test(source.docs) && /no external calls/.test(source.docs) && /Ordinary chat is fail-closed/.test(source.docs)
+};
+for (const [name, passed] of Object.entries(checks)) assert.equal(passed, true, `terminal acceptance failed: ${name}`);
+console.log(JSON.stringify({ outcome: 'accept', independent: true, checks: Object.keys(checks).length, accepted: Object.keys(checks), external_messages_sent: 0, online_test_residue: 0 }, null, 2));

package/scripts/live-agent-team-conformance.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const specs = [
+  { runtime: 'openclaw', executable: process.env.LOOP_OPENCLAW_BIN ?? 'openclaw' },
+  { runtime: 'codex-cli', executable: process.env.LOOP_CODEX_BIN ?? 'codex' },
+  { runtime: 'claude-code', executable: process.env.LOOP_CLAUDE_BIN ?? 'claude' }
+];
+const runTasks = process.argv.includes('--run-tasks');
+const taskToken = `LOOP_AGENT_TEAM_CONFORMANCE_${randomUUID()}`;
+const prompt = `Return exactly this token and nothing else: ${taskToken}`;
+const taskArgs = {
+  openclaw: ['agent', '--agent', process.env.LOOP_OPENCLAW_AGENT ?? 'main', '--session-key', `agent:${process.env.LOOP_OPENCLAW_AGENT ?? 'main'}:loop-conformance-${randomUUID()}`, '--message', prompt, '--thinking', 'off', '--timeout', '120', '--json'],
+  'codex-cli': ['exec', '--ephemeral', '--skip-git-repo-check', '--sandbox', 'read-only', '--color', 'never', prompt],
+  'claude-code': ['--print', '--no-session-persistence', '--permission-mode', 'plan', '--tools', '', '--model', process.env.LOOP_CLAUDE_MODEL ?? 'haiku', '--max-budget-usd', process.env.LOOP_CLAUDE_MAX_BUDGET_USD ?? '0.10', prompt]
+};
+
+function taskOutputMatches(runtime, stdout) {
+  if (runtime === 'openclaw') {
+    try {
+      const parsed = JSON.parse(stdout);
+      const texts = parsed?.result?.payloads?.map((item) => item.text).filter(Boolean) ?? [];
+      return texts.length === 1 && texts[0].trim() === taskToken;
+    } catch { return false; }
+  }
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  return lines.at(-1) === taskToken;
+}
+
+const results = specs.map((spec) => {
+  const probe = spawnSync(spec.executable, ['--version'], { encoding: 'utf8', timeout: 15_000 });
+  const available = !probe.error && probe.status === 0;
+  const result = { runtime: spec.runtime, executable: spec.executable, available, version: available ? (probe.stdout || probe.stderr).trim() : null, error: available ? null : (probe.error?.code ?? `exit_${probe.status}`), task_probe: null };
+  if (available && runTasks) {
+    const task = spawnSync(spec.executable, taskArgs[spec.runtime], { encoding: 'utf8', timeout: 180_000, maxBuffer: 4 * 1024 * 1024 });
+    const output = `${task.stdout ?? ''}\n${task.stderr ?? ''}`;
+    const tokenMatches = output.split(taskToken).length - 1;
+    const semanticMatch = taskOutputMatches(spec.runtime, task.stdout ?? '');
+    result.task_probe = {
+      attempted: true,
+      passed: !task.error && task.status === 0 && semanticMatch,
+      exit_status: task.status,
+      signal: task.signal,
+      token_match_count: tokenMatches,
+      semantic_output_match: semanticMatch,
+      error: task.error?.code ?? null,
+      output_bytes: Buffer.byteLength(output)
+    };
+  }
+  return result;
+});
+const unavailable = results.filter((item) => !item.available);
+const failedTasks = runTasks ? results.filter((item) => !item.task_probe?.passed) : [];
+const evidence = { version: 2, kind: runTasks ? 'live_agent_team_task_conformance' : 'live_agent_team_conformance_preflight', generated_at: new Date().toISOString(), passed: unavailable.length === 0 && failedTasks.length === 0, simulated: false, task_probe_requested: runTasks, task_contract: runTasks ? { operation: 'exact-token-response', external_delivery: false, filesystem_write_requested: false, unique_token: true } : null, results, next_action: unavailable.length ? 'install_or_bind_missing_runtime_executables_then_run_runtime_specific_task_probes' : failedTasks.length ? 'inspect_failed_runtime_task_probe' : runTasks ? 'run_full_regression_packaged_install_and_terminal_judgement' : 'rerun_with_--run-tasks' };
+const outputIndex = process.argv.indexOf('--output');
+if (outputIndex >= 0) await writeFile(path.resolve(process.argv[outputIndex + 1]), `${JSON.stringify(evidence, null, 2)}\n`);
+console.log(JSON.stringify(evidence, null, 2));
+if (!evidence.passed) process.exitCode = 2;

package/scripts/openclaw-doctor.mjs

@@ -43,8 +43,14 @@ async function main() {
     'scripts/loops/openclaw-loop-dispatch.mjs',
     'scripts/loops/openclaw-loop.mjs',
     'scripts/loops/openclaw-loop-notify.mjs',
+    'scripts/loops/openclaw-loop-gate.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 });
@@ -68,6 +74,13 @@ async function main() {
     });
     checks.push({ id: 'notification_dry_run', ok: smoke.code === 0, detail: (smoke.stdout || smoke.stderr).trim().slice(0, 500) });
   }
+  const gateBridge = path.join(args.root, 'scripts/loops/openclaw-loop-gate.mjs');
+  if (await present(gateBridge)) {
+    const syntax = await run(process.execPath, ['--check', gateBridge], { cwd: args.root });
+    checks.push({ id: 'human_gate_bridge_syntax', ok: syntax.code === 0, detail: (syntax.stderr || syntax.stdout).trim().slice(0, 500) });
+    const selfTest = await run(process.execPath, [gateBridge, '--self-test'], { cwd: args.root, env: { ...process.env, LOOP_WORKSPACE_ROOT: args.root } });
+    checks.push({ id: 'human_gate_bridge_self_test', ok: selfTest.code === 0 && /"externalWrite":false/.test(selfTest.stdout), detail: (selfTest.stdout || selfTest.stderr).trim().slice(0, 500) });
+  }
   const failed = checks.filter((check) => !check.ok);
   const report = { version: 1, status: failed.length ? 'fail' : 'ok', readOnly: true, externalWrite: false, root: args.root, queue: args.queue, workerAgent: args.workerAgent, checks, failed: failed.map((check) => check.id) };
   console.log(args.json ? JSON.stringify(report, null, 2) : `OpenClaw Loop doctor: ${report.status}\nchecks: ${checks.length - failed.length}/${checks.length}\nfailed: ${report.failed.join(', ') || 'none'}`);

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'] });
@@ -101,6 +104,8 @@ if (schedulerTick.code !== 0) throw new Error(`installed scheduler tick failed:
 const schedulerState = JSON.parse(await readFile(path.join(root, 'runtime/loops/test-tasks/scheduler/state.json'), 'utf8'));
 if (!schedulerState.generatedAt || !schedulerState.nextRunAt) throw new Error('installed scheduler tick did not persist its heartbeat and cadence');
 const notifier = await readFile(path.join(root, 'scripts/loops/openclaw-loop-notify.mjs'), 'utf8');
+const gateBridge = await readFile(path.join(root, 'scripts/loops/openclaw-loop-gate.mjs'), 'utf8');
+if (!gateBridge.includes('feishu_signature_unverified') || !gateBridge.includes('ignored_untrusted_chat') || !gateBridge.includes('handleChannelGateEvent')) throw new Error('installed Human Gate bridge is incomplete');
 if (!notifier.includes("'message', 'send'") || !notifier.includes('source.channel') || !notifier.includes('source.target')) throw new Error('channel-neutral notifier missing');
 const delivery = await new Promise((resolve) => {
   const child = spawn(process.execPath, [path.join(root, 'scripts/loops/openclaw-loop-notify.mjs'), 'async result'], {
@@ -126,7 +131,7 @@ const doctorResult = await new Promise((resolve) => {
 });
 if (doctorResult.code !== 0) throw new Error(`doctor failed: ${doctorResult.stderr}`);
 const doctorReport = JSON.parse(doctorResult.stdout);
-if (doctorReport.status !== 'ok' || doctorReport.externalWrite !== false || !doctorReport.checks.some((check) => check.id === 'notification_dry_run' && check.ok)) throw new Error('doctor did not complete a safe notification dry-run');
+if (doctorReport.status !== 'ok' || doctorReport.externalWrite !== false || !doctorReport.checks.some((check) => check.id === 'notification_dry_run' && check.ok) || !doctorReport.checks.some((check) => check.id === 'human_gate_bridge_self_test' && check.ok)) throw new Error('doctor did not complete safe notification and Human Gate self-tests');
 const smoke = new URL('./openclaw-smoke.mjs', import.meta.url).pathname;
 const smokeSource = await readFile(smoke, 'utf8');
 if (!smokeSource.includes('Do not change user or project files, configuration, credentials, or external state.')
@@ -148,7 +153,7 @@ const smokeReport = JSON.parse(smokeResult.stdout);
 if (smokeReport.status !== 'ok' || smokeReport.externalWrite !== false || !smokeReport.steps.every((step) => step.ok)) throw new Error('end-to-end smoke did not pass safely');
 try { await readFile(path.join(root, `configs/loops/queues/${smokeReport.smokeQueue}.json`)); throw new Error('smoke config was not cleaned'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
 try { await readFile(path.join(root, `runtime/loops/${smokeReport.smokeQueue}/state.json`)); throw new Error('smoke runtime was not cleaned'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-for (const generated of ['scripts/loops/openclaw-loop-dispatch.mjs', 'scripts/loops/openclaw-loop.mjs', 'scripts/loops/openclaw-loop-notify.mjs']) {
+for (const generated of ['scripts/loops/openclaw-loop-dispatch.mjs', 'scripts/loops/openclaw-loop.mjs', 'scripts/loops/openclaw-loop-notify.mjs', 'scripts/loops/openclaw-loop-gate.mjs']) {
   const syntax = await run(['--help']);
   if (syntax.code !== 0) throw new Error(`installer help failed while checking ${generated}`);
   const check = await new Promise((resolve) => {