taskforce-loop-engineering 0.15.13 → 0.15.15

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

@@ -104,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'], {
@@ -129,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.')
@@ -151,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) => {

package/scripts/openclaw-install.mjs

@@ -181,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;
@@ -229,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`;
 }
@@ -270,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}\`。
@@ -283,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}\`.
@@ -302,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`;
@@ -311,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),
@@ -319,7 +351,7 @@ 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 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 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.`);
@@ -350,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);
@@ -371,12 +405,13 @@ async function main() {
     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

@@ -90,7 +90,8 @@ try {
   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);
+  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/);

package/scripts/project-gate-reconciliation-self-test.mjs

@@ -40,7 +40,7 @@ assert(authorizedContract.constraints.allowed_actions.includes('paid_provider_ac
 assert(authorizedContract.constraints.blocked_actions.includes('credential_change_without_explicit_confirmation'));
 await writeFile(projectFile, `${JSON.stringify(spec, null, 2)}\n`);
 
-const b = await enqueueTask(root, { queue, title: 'OpenReel B-01', task: 'Project openreel requirement B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const b = await enqueueTask(root, { queue, title: 'OpenReel B-01', task: 'Project openreel requirement B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const checkpointDir = path.join(taskRuntimeDirFor(root, queue, b.task.id), 'checkpoints');
 await mkdir(checkpointDir, { recursive: true });
 await writeFile(path.join(checkpointDir, 'cp1.json'), `${JSON.stringify({ version: 1, task_id: b.task.id, checkpoint_id: 'cp1', milestone_id: 'B-01', requirement_ids: ['B-01'], status: 'needs_human_input', blockers: ['Authorize B-01'] }, null, 2)}\n`);
@@ -132,7 +132,7 @@ await writeFile(projectFile, `${JSON.stringify({
 
 // A ready milestone with project in progress and a deferred authorization is
 // converted into a structured waiting gate, not left as prose on a done task.
-const deferred = await enqueueTask(root, { queue, title: 'OpenReel deferred S-01', task: 'Project openreel S-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const deferred = await enqueueTask(root, { queue, title: 'OpenReel deferred S-01', task: 'Project openreel S-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const deferredDir = path.join(taskRuntimeDirFor(root, queue, deferred.task.id), 'checkpoints');
 await mkdir(deferredDir, { recursive: true });
 await writeFile(path.join(deferredDir, 'cp-ready.json'), `${JSON.stringify({
@@ -164,7 +164,7 @@ await writeFile(authoritativeBacklog, `${JSON.stringify({
     { id: 'LOCAL-02', status: 'pending', dependsOn: ['LOCAL-01'] }
   ]
 }, null, 2)}\n`);
-const futureGateTask = await enqueueTask(root, { queue, title: 'OpenReel future production gate', task: 'Continue safe local backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const futureGateTask = await enqueueTask(root, { queue, title: 'OpenReel future production gate', task: 'Continue safe local backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const futureGateDir = path.join(taskRuntimeDirFor(root, queue, futureGateTask.task.id), 'checkpoints');
 await mkdir(futureGateDir, { recursive: true });
 await writeFile(path.join(futureGateDir, 'cp1.json'), `${JSON.stringify({
@@ -180,7 +180,7 @@ assert.equal((await queueStatus(root, queue)).waiting, 0);
 // deferred_gates must not materialize a gate without a concrete action and
 // authority requirement.
 await reconcileProjectGates(root, { queue });
-const conditional = await enqueueTask(root, { queue, title: 'OpenReel conditional policy boundary', task: 'Continue safe OpenReel backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const conditional = await enqueueTask(root, { queue, title: 'OpenReel conditional policy boundary', task: 'Continue safe OpenReel backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const conditionalDir = path.join(taskRuntimeDirFor(root, queue, conditional.task.id), 'checkpoints');
 await mkdir(conditionalDir, { recursive: true });
 await writeFile(path.join(conditionalDir, 'cp1.json'), `${JSON.stringify({
@@ -194,7 +194,7 @@ assert.equal(conditionalNotice.results.some((item) => item.taskId === conditiona
 // A conditional formal blocker becomes current when the producer explicitly
 // marks it needed now and materialize=true. It must stop once, rather than be
 // filtered into a needs_revision/project_in_progress polling loop.
-const conditionalNow = await enqueueTask(root, { queue, title: 'OpenReel conditional blocker now', task: 'Wait for a real external precondition', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const conditionalNow = await enqueueTask(root, { queue, title: 'OpenReel conditional blocker now', task: 'Wait for a real external precondition', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const conditionalNowDir = path.join(taskRuntimeDirFor(root, queue, conditionalNow.task.id), 'checkpoints');
 await mkdir(conditionalNowDir, { recursive: true });
 await writeFile(path.join(conditionalNowDir, 'cp1.json'), `${JSON.stringify({
@@ -213,7 +213,7 @@ await reconcileProjectGates(root, { queue });
 // Authorization already granted or already consumed is audit context, not a
 // new human-input request. A future boundary is likewise dormant.
 for (const authorizationState of ['authorized', 'consumed', 'future']) {
-  const stateTask = await enqueueTask(root, { queue, title: `OpenReel ${authorizationState} authority`, task: 'Continue within recorded authority', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+  const stateTask = await enqueueTask(root, { queue, title: `OpenReel ${authorizationState} authority`, task: 'Continue within recorded authority', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
   const stateDir = path.join(taskRuntimeDirFor(root, queue, stateTask.task.id), 'checkpoints');
   await mkdir(stateDir, { recursive: true });
   await writeFile(path.join(stateDir, 'cp1.json'), `${JSON.stringify({
@@ -239,7 +239,7 @@ await writeFile(subprojectBacklog, `${JSON.stringify({
     { id: 'CDQI2-11', status: 'in_progress', dependsOn: ['CDQI2-10'] }
   ]
 }, null, 2)}\n`);
-const subprojectTask = await enqueueTask(root, { queue, title: 'OpenReel CDQI2 actionable backlog', task: 'Continue CDQI2-11', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const subprojectTask = await enqueueTask(root, { queue, title: 'OpenReel CDQI2 actionable backlog', task: 'Continue CDQI2-11', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const subprojectDir = path.join(taskRuntimeDirFor(root, queue, subprojectTask.task.id), 'checkpoints');
 await mkdir(subprojectDir, { recursive: true });
 await writeFile(path.join(subprojectDir, 'cp1.json'), `${JSON.stringify({
@@ -254,7 +254,7 @@ assert.equal(subprojectNotice.results.some((item) => item.taskId === subprojectT
 // A genuinely missing current authorization becomes a waiting gate once no
 // safe project work remains.
 await writeFile(authoritativeBacklog, `${JSON.stringify({ status: 'ongoing', items: [{ id: 'GLOBAL-01', status: 'accepted', dependsOn: [] }] }, null, 2)}\n`);
-const missing = await enqueueTask(root, { queue, title: 'OpenReel missing current authority', task: 'Perform currently gated action', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const missing = await enqueueTask(root, { queue, title: 'OpenReel missing current authority', task: 'Perform currently gated action', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const missingDir = path.join(taskRuntimeDirFor(root, queue, missing.task.id), 'checkpoints');
 await mkdir(missingDir, { recursive: true });
 await writeFile(path.join(missingDir, 'cp1.json'), `${JSON.stringify({
@@ -279,7 +279,7 @@ await writeFile(projectFile, `${JSON.stringify({
     backupRestoreRollbackRehearsal: 'standing_authorization_openreel_2026-08-19'
   }
 }, null, 2)}\n`);
-const coveredBlocker = await enqueueTask(root, { queue, title: 'OpenReel covered production blocker', task: 'Deploy accepted candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const coveredBlocker = await enqueueTask(root, { queue, title: 'OpenReel covered production blocker', task: 'Deploy accepted candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const coveredContract = await writeTaskContract(root, queue, coveredBlocker.task);
 assert.equal(coveredContract.contract.constraints.project_authorization.production_authorized, true);
 const coveredDir = path.join(taskRuntimeDirFor(root, queue, coveredBlocker.task.id), 'checkpoints');
@@ -294,7 +294,7 @@ assert.equal(coveredNotice.results.some((item) => item.taskId === coveredBlocker
 
 // Explicitly authorized blocker metadata is also non-materializable, while a
 // genuinely missing publication permission remains a human gate.
-const publication = await enqueueTask(root, { queue, title: 'OpenReel publication blocker', task: 'Publish candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const publication = await enqueueTask(root, { queue, title: 'OpenReel publication blocker', task: 'Publish candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 await writeTaskContract(root, queue, publication.task);
 const publicationDir = path.join(taskRuntimeDirFor(root, queue, publication.task.id), 'checkpoints');
 await mkdir(publicationDir, { recursive: true });
@@ -332,7 +332,7 @@ await rename(legacyInbox, `${legacyInbox}.moved`);
 await reconcileProjectGates(root, { queue });
 assert.equal((await queueStatus(root, queue)).done >= 1, true, 'accepted project task must close in done, not canceled');
 assert.equal(JSON.parse(await readFile(legacyGateFile, 'utf8')).status, 'superseded');
-const acceptedOptional = await enqueueTask(root, { queue, title: 'OpenReel optional operations transfer', task: 'Project openreel optional post-completion transfer', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const acceptedOptional = await enqueueTask(root, { queue, title: 'OpenReel optional operations transfer', task: 'Project openreel optional post-completion transfer', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const acceptedOptionalDir = path.join(taskRuntimeDirFor(root, queue, acceptedOptional.task.id), 'checkpoints');
 await mkdir(acceptedOptionalDir, { recursive: true });
 await writeFile(path.join(acceptedOptionalDir, 'cp1.json'), `${JSON.stringify({
@@ -344,4 +344,19 @@ const acceptedNotice = await notifyHumanInputRequests(root, { queue, notifyComma
 assert.equal(acceptedNotice.results.some((item) => item.taskId === acceptedOptional.task.id), false);
 assert.equal((await queueStatus(root, queue)).waiting, 0);
 
-console.log(JSON.stringify({ status: 'ok', assertions: ['standing project authorization reaches task contract', 'structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred gate', 'future gate does not stop safe actionable backlog', 'conditional policy prose does not create a gate', 'authorized and consumed authority do not create gates', 'checkpoint-bound subproject backlog remains actionable', 'missing current authority creates a gate', 'standing-authorized production blocker does not create a gate', 'missing publication blocker creates a gate', 'accepted project optional deferred gate stays out of queue'] }));
+// Missing source/actor/generation binding must fail closed: no waiting move,
+// no gate command text, and no notification invocation.
+const unbound = await enqueueTask(root, { queue, title: 'Unbound human request', task: 'Project openreel B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const unboundDir = path.join(taskRuntimeDirFor(root, queue, unbound.task.id), 'checkpoints');
+await mkdir(unboundDir, { recursive: true });
+await writeFile(path.join(unboundDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: unbound.task.id, checkpoint_id: 'cp1', milestone_id: 'B-01',
+  status: 'needs_human_input', blockers: [{ action: 'approve', required_authority: 'owner', authorization_state: 'missing', needed_when: 'now' }]
+}, null, 2)}\n`);
+const unboundNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+const unboundResult = unboundNotice.results.find((item) => item.taskId === unbound.task.id);
+assert.equal(unboundResult.outcome, 'fail_closed');
+assert.equal(unboundResult.message, undefined);
+assert.equal((await queueStatus(root, queue)).waiting, 0);
+
+console.log(JSON.stringify({ status: 'ok', assertions: ['standing project authorization reaches task contract', 'structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred gate', 'future gate does not stop safe actionable backlog', 'conditional policy prose does not create a gate', 'authorized and consumed authority do not create gates', 'checkpoint-bound subproject backlog remains actionable', 'missing current authority creates a gate', 'standing-authorized production blocker does not create a gate', 'missing publication blocker creates a gate', 'accepted project optional deferred gate stays out of queue', 'unbound gate fails closed without actionable text'] }));

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/route-notify-self-test.mjs

@@ -423,8 +423,8 @@ await writeJson(path.join(root, 'configs', 'loops', 'queues', `${queue}.json`),
 
 const gateDryRun = await notifyHumanInputRequests(root, { queue, dryRun: true });
 assert.equal(gateDryRun.results[0].outcome, 'dry_run');
-assert.match(gateDryRun.results[0].message, /Provide the SMS code/);
-assert.match(gateDryRun.results[0].message, /正在等待你的输入/);
+assert.equal(gateDryRun.results[0].preview, 'authoritative_gate_would_be_materialized');
+assert.equal(gateDryRun.results[0].message, undefined, 'dry-run must not emit an actionable reply command before gate materialization');
 const gateSent = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(gateSent.sent, 1);
 const gateId = gateSent.results[0].gateId;
@@ -544,7 +544,7 @@ await writeJson(path.join(regressionRoot, 'configs', 'loops', 'projects', 'demo.
 for (const [id, enqueuedAt] of [['history-done', '2026-01-01T00:00:00Z'], ['latest-done', '2026-01-02T00:00:00Z']]) {
   await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'done'), `${id}.json`), {
     id, title: `demo ${id}`, body: 'demo R-1', projectId: 'demo', status: 'completed', enqueuedAt,
-    source: { channel: 'test', target: 'owner' }
+    source: { channel: 'test', target: 'owner', account: 'main' }
   });
   await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, id), 'checkpoints', 'cp1.json'), {
     version: 1, task_id: id, checkpoint_id: 'cp1', milestone_id: 'R-1', sequence: 1,
@@ -577,7 +577,7 @@ await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'faile
   projectId: 'demo',
   status: 'blocked',
   enqueuedAt: '2026-01-03T00:00:00Z',
-  source: { channel: 'feishu', target: 'owner' }
+  source: { channel: 'feishu', target: 'owner', account: 'main' }
 });
 await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'checkpoints', 'cp2.json'), {
   version: 1,

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

@@ -120,6 +120,14 @@ 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/skills/taskforce-loop-engineering/references/npm-package.md

@@ -1,7 +1,7 @@
 # npm Package
 
 Package name: `taskforce-loop-engineering`
-Version: `0.9.0`
+Version: `0.15.15`
 
 Install from npm: