taskforce-loop-engineering 0.13.0 → 0.15.0

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

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { doctorReport, enqueueTask, notifyHumanInputRequests, projectStatus, queueStatus, reconcileProjectGates, routeLoopMessage, taskRuntimeDirFor } from '../lib/core.mjs';
+
+const root = await mkdtemp(path.join(os.tmpdir(), 'loop-project-gates-'));
+const queue = 'shared';
+const projectFile = path.join(root, 'configs', 'loops', 'projects', 'openreel.json');
+const spec = { schemaVersion: 1, project: 'openreel', type: 'code_project', queues: [{ queue, kind: 'standard' }], backlog: [
+  { id: 'B-01', required: true, status: 'human_gated', dependsOn: [] },
+  { id: 'S-01', required: true, status: 'human_gated', dependsOn: [] }
+] };
+await mkdir(path.dirname(projectFile), { recursive: true });
+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 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`);
+const notified = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(notified.sent, 1);
+assert.equal((await queueStatus(root, queue)).waiting, 1);
+const gateFile = path.join(root, notified.results[0].ledger);
+const gate = JSON.parse(await readFile(gateFile, 'utf8'));
+assert.equal(gate.project_id, 'openreel');
+assert.equal(gate.milestone_id, 'B-01');
+assert.deepEqual(gate.requirement_ids, ['B-01']);
+assert.equal(typeof gate.contract_hash, 'string');
+
+spec.backlog[0] = { ...spec.backlog[0], required: false, status: 'out_of_scope', disposition: 'canceled_by_owner' };
+await writeFile(projectFile, `${JSON.stringify(spec, null, 2)}\n`);
+const status = await queueStatus(root, queue);
+assert.equal(status.waiting, 0, 'B-01 waiting gate must disappear after B-01 leaves project scope');
+assert.equal(status.canceled, 1);
+assert.equal(JSON.parse(await readFile(gateFile, 'utf8')).status, 'canceled');
+
+const other = await enqueueTask(root, { queue, title: 'Other project task', task: 'Project other', projectId: 'other' });
+const openreel = await enqueueTask(root, { queue, title: 'OpenReel target', task: 'Project openreel', projectId: 'openreel' });
+await rename(path.join(root, other.file), path.join(root, 'runtime', 'loops', queue, 'active', path.basename(other.file)));
+await rename(path.join(root, openreel.file), path.join(root, 'runtime', 'loops', queue, 'active', path.basename(openreel.file)));
+const replacement = await routeLoopMessage(root, { route: true, confirmExecute: true, supersedeActive: true, queue, message: '走 loop：继续 openreel 项目' });
+assert.equal(replacement.supersededTaskId, openreel.task.id);
+assert.equal(await readFile(path.join(taskRuntimeDirFor(root, queue, other.task.id), 'supersede_request.json'), 'utf8').then(() => true, () => false), false);
+
+const invalidGate = { ...gate, gate_id: `${openreel.task.id}:bad`, task_id: openreel.task.id, checkpoint_id: 'bad', status: 'waiting_for_human', requirement_ids: ['MISSING'] };
+const invalidFile = path.join(root, 'runtime', 'loops', queue, 'human-input', 'gates', `${openreel.task.id}.bad.json`);
+await writeFile(invalidFile, `${JSON.stringify(invalidGate, null, 2)}\n`);
+const doctor = await doctorReport(root);
+assert.equal(doctor.ok, false);
+assert(doctor.checks.some((check) => check.id === `human-gate:${invalidGate.gate_id}` && !check.ok));
+await reconcileProjectGates(root, { queue });
+
+// project-status treats the configured ledger/backlog as authoritative and
+// exposes registry drift instead of silently reporting stale completion data.
+const authoritativeBacklog = path.join(root, 'project', 'backlog.json');
+const authoritativeLedger = path.join(root, 'project', 'acceptance-ledger.json');
+await mkdir(path.dirname(authoritativeBacklog), { recursive: true });
+await writeFile(authoritativeBacklog, `${JSON.stringify({ status: 'ongoing', items: [{ id: 'S-01', required: true, status: 'accepted' }] }, null, 2)}\n`);
+await writeFile(authoritativeLedger, `${JSON.stringify({ status: 'ongoing', unmet: ['S-01'], blockers: [{ id: 'S-01' }] }, null, 2)}\n`);
+await writeFile(projectFile, `${JSON.stringify({ ...spec, backlogSource: 'project/backlog.json', acceptanceLedger: 'project/acceptance-ledger.json', terminalContract: 'project/terminal.md' }, null, 2)}\n`);
+const drifted = await projectStatus(root, { project: 'openreel' });
+assert.equal(drifted.projectCompletion, 'in_progress');
+assert.equal(drifted.authority.acceptanceLedger, 'project/acceptance-ledger.json');
+assert.equal(drifted.consistency.ok, false);
+assert(drifted.needsAttention.includes('authoritative_source_drift'));
+
+// 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 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({
+  version: 1, task_id: deferred.task.id, checkpoint_id: 'cp-ready', milestone_id: 'S-01', requirement_ids: ['S-01'],
+  status: 'ready_for_acceptance', blockers: [], verification: ['local phase passed'], risks: [],
+  project_completion: { status: 'in_progress' },
+  deferred_gates: [{ id: 'S-01-production', action: 'production_rollback_drill', required_authority: 'Owner authorization for the exact production rollback drill scope.' }]
+}, null, 2)}\n`);
+const deferredNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+const deferredResult = deferredNotice.results.find((item) => item.taskId === deferred.task.id);
+assert.equal(deferredResult.outcome, 'sent');
+const deferredGate = JSON.parse(await readFile(path.join(root, deferredResult.ledger), 'utf8'));
+assert.equal(deferredGate.gate_kind, 'deferred_authorization');
+assert.equal(deferredGate.authorization_requirements[0].action, 'production_rollback_drill');
+assert.match(deferredGate.authorization_requirements[0].required_authority, /Owner authorization/);
+assert.equal((await queueStatus(root, queue)).waiting >= 1, true);
+
+// Once the authoritative project ledger accepts the terminal contract, an
+// optional post-completion deferred action stays in operations backlog and
+// neither creates nor retains a project-queue waiting gate.
+await writeFile(authoritativeLedger, `${JSON.stringify({ status: 'accepted', unmet: [], blockers: [] }, null, 2)}\n`);
+await reconcileProjectGates(root, { queue });
+assert.equal((await queueStatus(root, queue)).waiting, 0);
+assert.equal(JSON.parse(await readFile(path.join(root, deferredResult.ledger), '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 acceptedOptionalDir = path.join(taskRuntimeDirFor(root, queue, acceptedOptional.task.id), 'checkpoints');
+await mkdir(acceptedOptionalDir, { recursive: true });
+await writeFile(path.join(acceptedOptionalDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: acceptedOptional.task.id, checkpoint_id: 'cp1', milestone_id: 'cp1',
+  status: 'ready_for_acceptance', blockers: [], project_completion: { status: 'accepted' },
+  deferred_gates: [{ id: 'optional-transfer', required_authority: 'Separate authorization for optional production transfer.' }]
+}, null, 2)}\n`);
+const acceptedNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+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: ['structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred gate', 'accepted project optional deferred gate stays out of queue'] }));

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

@@ -89,6 +89,27 @@ const contract = await readJson(path.join(taskRuntimeDirFor(root, queue, routed.
 assert.equal(contract.risk_level, 'model_assessed');
 assert.equal(contract.requires_human_gate, false);
 
+const largeBodyQueue = 'large-body-smoke';
+const largeBody = `走 loop 验证超长任务正文\n${'checkpoint evidence '.repeat(10_000)}`;
+const largeBodyRouted = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  queue: largeBodyQueue,
+  message: largeBody,
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-1'
+});
+const largeBodyRun = await runQueueOnce(root, {
+  queue: largeBodyQueue,
+  dispatcher: `node -e "const fs=require('fs');const t=JSON.parse(fs.readFileSync(process.env.LOOP_TASK_FILE,'utf8'));if(process.env.LOOP_TASK_BODY!==undefined||process.env.LOOP_TASK_BODY_MODE!=='task_file'||t.body.length<100000)process.exit(7)"`,
+  progressNotifyCommand: '/bin/true',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000
+});
+assert.equal(largeBodyRun.processed, true);
+assert.equal(largeBodyRun.run.dispatch.exitCode, 0);
+
 const orphanQueue = 'orphan-recovery-smoke';
 const orphanRouted = await routeLoopMessage(root, {
   route: true,
@@ -483,5 +504,35 @@ assert.equal(sent.sent, 1);
 const repeated = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(repeated.results[0].outcome, 'already_notified');
 
+// Real directory-level regression: terminal history plus the newest project
+// carrier yields exactly one durable gate, one waiting task, and zero replay.
+const regressionRoot = await mkdtemp(path.join(tmpdir(), 'loop-gate-regression-'));
+const regressionQueue = 'project-regression';
+await writeJson(path.join(regressionRoot, 'configs', 'loops', 'projects', 'demo.json'), {
+  schemaVersion: 1, project: 'demo', queues: [{ queue: regressionQueue }],
+  backlog: [{ id: 'R-1', status: 'human_gated', required: true }]
+});
+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' }
+  });
+  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,
+    status: 'ready_for_acceptance', blockers: [], deferred_gates: [{ id: 'R-1', required_authority: 'Approve R-1.' }],
+    verification: [], risks: [], project_completion: 'in_progress', next_action: 'wait'
+  });
+  await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, id), 'final_judgement.json'), {
+    version: 1, task_id: id, outcome: 'project_in_progress', coverage: { effective_review_ids: ['cp1'] }
+  });
+}
+const regressionFirst = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
+assert.equal(regressionFirst.sent, 1);
+assert.equal((await queueStatus(regressionRoot, regressionQueue)).waiting, 1);
+assert.equal((await readdir(path.join(queueDirFor(regressionRoot, regressionQueue), 'human-input', 'gates'))).length, 1);
+assert.equal((await readdir(queueSubdirFor(regressionRoot, regressionQueue, 'done'))).length, 1);
+const regressionRepeated = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
+assert.equal(regressionRepeated.sent, 0);
+
 console.log('route/notify self-test passed');
 await import('./config-drift-self-test.mjs');

package/scripts/runtime-adapter-conformance.mjs

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { AdapterError, createClaudeCodeAdapter, createCodexCliAdapter, createHermesAdapter, createMemoryTransport, createOpenClawAdapter, validateAdapter } from '../lib/runtime-adapter-sdk.mjs';
+
+export async function conform(factory) {
+  const transport = createMemoryTransport(); const adapter = validateAdapter(factory(transport));
+  const session = await adapter.createSession({ key: 'offline-demo', metadata: { apiKey: 'must-not-leak' } });
+  const run = await adapter.startRun({ sessionId: session.sessionId, requestId: 'request-1', input: { prompt: 'local only' } });
+  await adapter.recordStep({ runId: run.runId, stepId: 'step-1', evidence: [{ local: true, token: 'hidden' }] });
+  await assert.rejects(adapter.prepareEffect({ runId: run.runId, effectId: 'send', idempotencyKey: 'send:1' }), (error) => error instanceof AdapterError && error.code === 'EFFECT_NOT_AUTHORIZED');
+  const effect = await adapter.prepareEffect({ runId: run.runId, effectId: 'write-local', idempotencyKey: 'write:1', authorized: true, payload: { password: 'hidden' } });
+  assert.equal(effect.state, 'authorized'); assert.equal(effect.payload.password, '[REDACTED]');
+  await adapter.resolveGate({ gateId: 'gate-1', decision: 'approved', responseRef: 'local-ref' });
+  const beat = await adapter.heartbeat({ runId: run.runId });
+  assert.equal((await adapter.continueRun({ runId: run.runId, continuationToken: beat.continuationToken })).status, 'running');
+  assert.equal(JSON.stringify(adapter.telemetry).includes('must-not-leak'), false);
+  return { runtime: adapter.runtime, version: adapter.version, capabilities: adapter.capabilities, assertions: 11 };
+}
+
+const results = [];
+for (const factory of [createOpenClawAdapter, createHermesAdapter, createCodexCliAdapter, createClaudeCodeAdapter]) results.push(await conform(factory));
+console.log(JSON.stringify({ status: 'passed', boundary: 'credential-free simulated transport', results }));

package/templates/github-production-trust.yml

@@ -0,0 +1,20 @@
+name: production-trust
+on:
+  pull_request:
+  workflow_dispatch:
+jobs:
+  deterministic-canary:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm install --ignore-scripts --no-audit --no-fund
+        working-directory: packages/loop-engineering
+      - run: npm run check:production-trust
+        working-directory: packages/loop-engineering
+      - uses: actions/upload-artifact@v4
+        with:
+          name: production-trust-evidence
+          path: packages/loop-engineering/.production-evidence/

package/templates/production-evidence.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/ambitioncn/taskforce-loop-engineering/schemas/production-evidence-v1.json",
+  "title": "Loop Engineering production trust evidence",
+  "type": "object",
+  "required": ["schema", "schema_version", "generated_at", "scenarios", "compatibility", "metrics", "thresholds", "evaluation", "integrity", "passed"],
+  "properties": {
+    "schema": { "const": "loop.production_trust_evidence" },
+    "schema_version": { "const": 1 },
+    "generated_at": { "type": "string", "format": "date-time" },
+    "scenarios": { "type": "array", "minItems": 8 },
+    "compatibility": { "type": "array", "minItems": 3 },
+    "metrics": { "type": "object" },
+    "thresholds": { "type": "object" },
+    "evaluation": { "type": "object", "required": ["checks", "trend", "passed"] },
+    "integrity": { "type": "object", "required": ["algorithm", "digest"] },
+    "passed": { "type": "boolean" }
+  },
+  "additionalProperties": true
+}