taskforce-loop-engineering 0.9.1 → 0.12.0

package/scripts/openclaw-manage.mjs

@@ -73,7 +73,7 @@ async function main() {
     if (!plan.ready) throw new Error(`Refusing upgrade because managed content changed: ${[...modified, ...(!instructionsClean ? ['AGENTS.md managed block'] : [])].join(', ')}`);
     const installer = new URL('./openclaw-install.mjs', import.meta.url).pathname;
     const result = await new Promise((resolve) => {
-      const child = spawn(process.execPath, [installer, '--root', args.root, '--queue', manifest.queue, '--worker-agent', manifest.workerAgent, '--openclaw-bin', manifest.openclawBin || 'openclaw', '--systemctl-bin', manifest.systemctlBin || 'systemctl', '--confirm-install', '--force', '--json'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      const child = spawn(process.execPath, [installer, '--root', args.root, '--queue', manifest.queue, '--worker-agent', manifest.workerAgent, '--language', manifest.language || 'en', '--openclaw-bin', manifest.openclawBin || 'openclaw', '--systemctl-bin', manifest.systemctlBin || 'systemctl', '--confirm-install', '--force', '--json'], { stdio: ['ignore', 'pipe', 'pipe'] });
       let stdout = ''; let stderr = ''; child.stdout.on('data', (c) => { stdout += c; }); child.stderr.on('data', (c) => { stderr += c; });
       child.on('close', (code) => resolve({ code, stdout, stderr }));
     });

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

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { buildOperatorProjection, createDashboardServer, dashboardHealth, exportDashboard, filterProjection } from '../lib/operator-dashboard.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-dashboard-'));
+const loops = path.join(root, 'runtime', 'loops');
+await mkdir(path.join(loops, 'control-plane'), { recursive: true });
+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 });
+const now = '2026-08-13T16:00:00.000Z';
+const control = {
+  version: 2, updated_at: now, quotas: { credits: 9 }, agents: { a: { id: 'a', capabilities: ['code'], authority_grants: ['local'], provider_token: 'never-show' } },
+  handoffs: { h: { id: 'h', todo_id: 'leased', from_agent_id: 'a', to_agent_id: 'b', state: 'pending', created_at: now } },
+  todos: {
+    human: { version: 2, id: 'human', title: '<img src=x onerror=alert(1)>', state: 'runnable', priority: 2, risk: 'medium', authority_class: 'local', required_capabilities: [], acceptance_contract: { checks: ['ok'] }, evidence_requirements: ['test'], cost_envelope: { quota: 'credits', amount: 2 }, parked: { state: 'waiting_for_human', gate_id: 'g1', secret_input: 'hide' }, blocked_reasons: [], claim: null, lineage: { root_todo_id: 'human' }, evidence: [], idempotency_keys: [], created_at: now, updated_at: now },
+    leased: { version: 2, id: 'leased', title: 'Lease expired', state: 'claimed', priority: 1, authority_class: 'local', required_capabilities: [], acceptance_contract: {}, evidence_requirements: ['lease'], cost_envelope: { quota: 'credits', amount: 3 }, claim: { owner: 'a', fencing_token: 7, claimed_at: '2026-08-13T15:00:00.000Z', lease_expires_at: '2026-08-13T15:01:00.000Z' }, blocked_reasons: [], lineage: {}, evidence: [], idempotency_keys: ['paid:x'], created_at: now, updated_at: now }
+  }
+};
+await writeFile(path.join(loops, 'control-plane', 'state.json'), JSON.stringify(control));
+await writeFile(path.join(loops, 'action-reservations', 'x.json'), JSON.stringify({ version: 1, idempotency_key: 'paid:x', kind: 'paid_api', state: 'unknown', request: { api_key: 'hide', prompt: '<script>x</script>' }, request_fingerprint: 'abc', authorization: { scope: 'paid', credential: 'hide' }, claim: null, reconciliation: { required: true, reason: 'stale_lease' }, created_at: now, updated_at: now }));
+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' }));
+
+const before = await stat(path.join(loops, 'control-plane', 'state.json'));
+const first = await buildOperatorProjection(root, { now });
+const second = await buildOperatorProjection(root, { now });
+const after = await stat(path.join(loops, 'control-plane', 'state.json'));
+assert.deepEqual(first, second, 'fixed-time projections are deterministic');
+assert.equal(before.mtimeMs, after.mtimeMs, 'projection does not mutate source state');
+assert.equal(first.todos.find((item) => item.id === 'human').state, 'waiting_for_human');
+assert.equal(first.todos.find((item) => item.id === 'leased').state, 'reconciliation_required');
+assert.equal(first.actions[0].state, 'reconciliation_required');
+assert.equal(first.queues[0].tasks[0].state, 'waiting_for_external_condition');
+assert.equal(first.agents[0].provider_token, '[REDACTED]');
+assert.equal(first.todos[0].gate.secret_input, '[REDACTED]');
+assert.equal(JSON.stringify(first).includes('never-show'), false);
+assert.equal(JSON.stringify(first).includes('hidden'), false);
+assert.equal(first.health.status, 'degraded');
+assert.equal(filterProjection(first, { state: 'waiting_for_human', query: 'img' }).todos.length, 1);
+assert.equal(dashboardHealth(first, { maxAgeSeconds: 1 }).stale, false);
+
+const output = path.join(root, 'export');
+await exportDashboard(root, output, { now });
+assert.match(await readFile(path.join(output, 'index.html'), 'utf8'), /projection\.json/);
+assert.equal(JSON.parse(await readFile(path.join(output, 'projection.json'), 'utf8')).schema_version, '1.0.0');
+await assert.rejects(() => createDashboardServer(root, { host: '0.0.0.0' }), /requires --allow-non-loopback/);
+
+const server = await createDashboardServer(root, { host: '127.0.0.1', port: 0 });
+const address = server.address(); const base = `http://127.0.0.1:${address.port}`;
+try {
+  const overview = await fetch(`${base}/api/v1/overview?state=waiting_for_human`).then((response) => response.json());
+  assert.equal(overview.todos.length, 1);
+  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.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);
+  assert.equal((await fetch(`${base}/api/v1/overview`, { method: 'POST' })).status, 405);
+} finally { await new Promise((resolve) => server.close(resolve)); }
+
+// Large queue stays dependency-light and completes within a generous local budget.
+await mkdir(path.join(loops, 'large', 'inbox'), { recursive: true });
+await Promise.all(Array.from({ length: 500 }, (_, i) => writeFile(path.join(loops, 'large', 'inbox', `${i}.json`), JSON.stringify({ id: `bulk-${i}`, title: `Task ${i}`, state: 'runnable' }))));
+const started = performance.now(); const large = await buildOperatorProjection(root, { now });
+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' }));

package/scripts/route-notify-self-test.mjs

@@ -54,6 +54,10 @@ assert.deepEqual(classifyLoopMessage('用 loop engineering 把现有的 growth o
   enqueue: true,
   readOnly: false
 });
+assert.equal(classifyLoopMessage('Use Loop Engineering to fix this issue.').intent, 'execute');
+assert.equal(classifyLoopMessage('Run this through Loop Engineering.').intent, 'execute');
+assert.equal(classifyLoopMessage('Continue the current loop with this amendment: add English examples.').intent, 'execute');
+assert.equal(classifyLoopMessage('我们继续开发我们的loop engineering').intent, 'execute');
 
 const routed = await routeLoopMessage(root, {
   route: true,
@@ -380,10 +384,12 @@ await writeJson(checkpointFile, {
 const failedFile = path.join(queueSubdirFor(root, queue, 'failed'), path.basename(terminalFile));
 await writeJson(failedFile, terminalTask);
 if (failedFile !== terminalFile) await rm(terminalFile, { force: true });
+await writeJson(path.join(root, 'configs', 'loops', 'queues', `${queue}.json`), { queue, language: 'zh' });
 
 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, /正在等待你的输入/);
 const gateSent = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(gateSent.sent, 1);
 const gateId = gateSent.results[0].gateId;
@@ -470,6 +476,7 @@ await writeJson(failedFile, { ...requeuedTask, status: 'needs_human_input' });
 await rm(inboxRequeued, { force: true });
 
 const dryRun = await notifyTerminalTasks(root, { queue, dryRun: true });
+assert.match(dryRun.results[0].message, /Loop 任务/);
 assert.equal(dryRun.results[0].outcome, 'dry_run');
 const sent = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(sent.sent, 1);

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

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { claimAction, markActionUnknown, reserveAction } from '../lib/action-reservations.mjs';
+import { claimTodo, createTodo, decideHandoff, handoffTodo, inspectTodo, recoverTodos, registerAgent, releaseTodo, renewTodo } from '../lib/todo-control-plane.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-p2-'));
+const agent = (id, capabilities = ['code'], authority_grants = ['local'], quota = 10) => registerAgent(root, { id, capabilities, authority_grants, quota_grants: { default: quota } });
+const todo = (id, extra = {}) => createTodo(root, { id, title: `Todo ${id}`, required_capabilities: ['code'], authority_class: 'local', acceptance_contract: { checks: ['test'] }, evidence_requirements: ['test-output'], cost: 1, ...extra });
+
+await Promise.all([agent('alpha'), agent('beta'), agent('observer', []), agent('poor', ['code'], ['local'], 0)]);
+await todo('race');
+const race = await Promise.all([claimTodo(root, { todoId: 'race', agentId: 'alpha', leaseMs: 1000 }), claimTodo(root, { todoId: 'race', agentId: 'beta', leaseMs: 1000 })]);
+assert.equal(race.filter((item) => item.claimed).length, 1, 'exactly one agent wins an atomic claim');
+const winner = race.find((item) => item.claimed);
+const loser = race.find((item) => !item.claimed);
+assert.match(loser.reason, /state:claimed/);
+await assert.rejects(() => renewTodo(root, { todoId: 'race', agentId: loser === race[0] ? 'alpha' : 'beta', fencingToken: winner.fencing_token }), /Stale or invalid/);
+
+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');
+
+await todo('dependency');
+await todo('dependent', { dependencies: ['dependency'], priority: 100 });
+const blocked = await claimTodo(root, { todoId: 'dependent', agentId: 'alpha' });
+assert.match(blocked.reason, /dependencies/);
+const dependencyClaim = await claimTodo(root, { todoId: 'dependency', agentId: 'alpha' });
+await releaseTodo(root, { todoId: 'dependency', agentId: 'alpha', fencingToken: dependencyClaim.fencing_token, completed: true, evidence: 'passed' });
+assert.equal((await claimTodo(root, { todoId: 'dependent', agentId: 'alpha' })).claimed, true, 'completion unlocks dependencies');
+
+await todo('stale');
+const stale = await claimTodo(root, { todoId: 'stale', agentId: 'alpha', leaseMs: 1 });
+await new Promise((resolve) => setTimeout(resolve, 5));
+await assert.rejects(() => renewTodo(root, { todoId: 'stale', agentId: 'alpha', fencingToken: stale.fencing_token }), /expired/);
+assert.equal((await recoverTodos(root)).results.find((item) => item.todo_id === 'stale').outcome, 'runnable');
+const reclaimed = await claimTodo(root, { todoId: 'stale', agentId: 'beta' });
+assert.ok(reclaimed.fencing_token > stale.fencing_token, 'recovered work gets a higher fencing token');
+
+await todo('handoff');
+const owned = await claimTodo(root, { todoId: 'handoff', agentId: 'alpha' });
+const packet = await handoffTodo(root, { todoId: 'handoff', agentId: 'alpha', targetAgentId: 'beta', fencingToken: owned.fencing_token });
+assert.deepEqual(packet.idempotency_keys, []);
+const cli = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../bin/loop-engineering.mjs');
+const restarted = spawnSync(process.execPath, [cli, 'todo-inspect', '--todo-id', 'handoff', '--root', root], { encoding: 'utf8' });
+assert.equal(restarted.status, 0);
+assert.equal(JSON.parse(restarted.stdout).state, 'handoff_pending', 'handoff survives a fresh CLI process');
+const accepted = await decideHandoff(root, { handoffId: packet.id, agentId: 'beta', accept: true });
+assert.equal(accepted.todo.claim.owner, 'beta');
+assert.ok(accepted.todo.claim.fencing_token > owned.fencing_token);
+await todo('handoff-reject');
+const rejectOwned = await claimTodo(root, { todoId: 'handoff-reject', agentId: 'alpha' });
+const rejectPacket = await handoffTodo(root, { todoId: 'handoff-reject', agentId: 'alpha', targetAgentId: 'beta', fencingToken: rejectOwned.fencing_token });
+const rejected = await decideHandoff(root, { handoffId: rejectPacket.id, agentId: 'beta', accept: false, reason: 'busy' });
+assert.equal(rejected.todo.claim.owner, 'alpha');
+
+await todo('parked', { parked: { state: 'waiting_for_human' } });
+assert.equal((await claimTodo(root, { todoId: 'parked', agentId: 'alpha' })).reason, 'parked_human_gate');
+
+await reserveAction(root, { idempotencyKey: 'side-effect', kind: 'external_message', authorizationScope: 'todo:external', request: { body: 'once' } });
+const action = await claimAction(root, { idempotencyKey: 'side-effect', owner: 'alpha', leaseMs: 1000 });
+await markActionUnknown(root, { idempotencyKey: 'side-effect', fencingToken: action.fencingToken, reason: 'worker_crash' });
+await todo('unknown-action', { idempotency_keys: ['side-effect'], authorization: { scope: 'todo:external', grant: 'preserved' } });
+assert.match((await claimTodo(root, { todoId: 'unknown-action', agentId: 'beta' })).reason, /action_reconciliation/);
+assert.equal((await inspectTodo(root, 'unknown-action')).authorization.grant, 'preserved');
+
+const audit = await readFile(path.join(root, 'runtime', 'loops', 'control-plane', 'audit.jsonl'), 'utf8');
+assert.match(audit, /todo_claimed/);
+assert.match(audit, /handoff_accepted/);
+console.log(JSON.stringify({ ok: true, root, assertions: ['atomic claim', 'capability', 'dependency', 'quota', 'lease fencing', 'orphan recovery', 'handoff accept/reject', 'parked gate', 'unknown action reconciliation', 'audit'] }));

package/templates/operator-projection.schema.json

@@ -0,0 +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}

package/templates/todo.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://loop-engineering.local/schema/todo-v2.json",
+  "title": "Loop Engineering typed todo v2",
+  "type": "object",
+  "required": ["id", "title", "priority", "risk", "authority_class", "required_capabilities", "acceptance_contract", "evidence_requirements", "cost_envelope", "state"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$" },
+    "title": { "type": "string", "minLength": 1 },
+    "project_id": { "type": ["string", "null"] },
+    "dependencies": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "priority": { "type": "number" },
+    "risk": { "enum": ["low", "medium", "high", "critical"] },
+    "authority_class": { "type": "string", "minLength": 1 },
+    "required_capabilities": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "acceptance_contract": { "type": "object" },
+    "evidence_requirements": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string" } },
+    "cost_envelope": { "type": "object", "required": ["quota", "amount"], "properties": { "quota": { "type": "string" }, "amount": { "type": "number", "minimum": 0 } } },
+    "state": { "enum": ["runnable", "blocked", "claimed", "handoff_pending", "completed"] },
+    "authorization": {},
+    "idempotency_keys": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "lineage": { "type": "object" },
+    "context": { "type": "object" },
+    "evidence": { "type": "array" },
+    "claim": { "type": ["object", "null"] }
+  },
+  "additionalProperties": true
+}