@tea-agent/loop-agent 0.12.0 → 0.13.0-beta.0

package/dist/commands/knowledge.js

@@ -1,41 +1,104 @@
 import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
 import { curateKnowledgePatterns } from "../workflows/dag/knowledge-curator.js";
+export const KNOWLEDGE_CLI_SUBCOMMANDS = [
+    "curate",
+    "query",
+    "graph-init",
+    "graph-materialize",
+    "graph-promote",
+    "graph-incremental-prepare",
+];
+const USAGE = "usage: knowledge <curate|query|graph-init|graph-materialize|graph-promote|graph-incremental-prepare> ...";
+function packageRoot() {
+    // dist/commands/knowledge.js or src/commands/knowledge.ts → package/repo root
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+function resolveScript(repoRoot, fileName) {
+    const candidates = [
+        path.join(repoRoot, "scripts", fileName),
+        path.join(packageRoot(), "scripts", fileName),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error(`knowledge script not found: ${fileName} (looked under repo scripts/ and package scripts/)`);
+}
+function runProcess(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0 && result.status !== null) {
+        process.exitCode = result.status;
+    }
+}
+function runNodeScript(repoRoot, scriptFile, forwardArgs) {
+    const scriptPath = resolveScript(repoRoot, scriptFile);
+    runProcess(process.execPath, [scriptPath, ...forwardArgs], repoRoot);
+}
+function runBashScript(repoRoot, scriptFile, forwardArgs) {
+    const scriptPath = resolveScript(repoRoot, scriptFile);
+    runProcess("bash", [scriptPath, ...forwardArgs], repoRoot);
+}
+function ensureRootFlag(repoRoot, rest) {
+    if (rest.includes("--root"))
+        return rest;
+    return ["--root", repoRoot, ...rest];
+}
 export function parseKnowledgeArgs(args) {
     const [command, ...rest] = args;
-    if (command !== "curate") {
-        throw new Error("usage: knowledge curate [--json|--markdown] [--output <path>]");
+    if (!command ||
+        !KNOWLEDGE_CLI_SUBCOMMANDS.includes(command)) {
+        throw new Error(USAGE);
     }
-    let outputPath;
-    let json = false;
-    let markdown = false;
-    for (let i = 0; i < rest.length; i += 1) {
-        const arg = rest[i];
-        if (arg === "--json") {
-            json = true;
-            continue;
-        }
-        if (arg === "--markdown") {
-            markdown = true;
-            continue;
+    if (command === "curate") {
+        let outputPath;
+        let json = false;
+        let markdown = false;
+        for (let i = 0; i < rest.length; i += 1) {
+            const arg = rest[i];
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--markdown") {
+                markdown = true;
+                continue;
+            }
+            if (arg === "--output") {
+                outputPath = rest[++i];
+                if (!outputPath) {
+                    throw new Error("knowledge curate --output requires a path");
+                }
+                continue;
+            }
+            if (arg.startsWith("--output=")) {
+                outputPath = arg.slice("--output=".length);
+                continue;
+            }
+            throw new Error(`unknown knowledge curate argument: ${arg}`);
         }
-        if (arg === "--output") {
-            outputPath = rest[++i];
-            if (!outputPath)
-                throw new Error("knowledge curate --output requires a path");
-            continue;
-        }
-        if (arg.startsWith("--output=")) {
-            outputPath = arg.slice("--output=".length);
-            continue;
-        }
-        throw new Error(`unknown knowledge curate argument: ${arg}`);
+        if (!json && !markdown)
+            json = true;
+        return { command: "curate", outputPath, json, markdown };
     }
-    if (!json && !markdown)
-        json = true;
-    return { command, outputPath, json, markdown };
+    return {
+        command: command,
+        forward: rest,
+    };
 }
-export async function runKnowledge(repoRoot, args) {
-    const parsed = parseKnowledgeArgs(args);
+async function runCurate(repoRoot, parsed) {
     const result = await curateKnowledgePatterns({
         repoRoot,
         outputPath: parsed.outputPath,
@@ -50,7 +113,9 @@ export async function runKnowledge(repoRoot, args) {
         console.log(JSON.stringify({
             ok: result.ok,
             patternsPath: path.relative(repoRoot, result.patternsPath),
-            outputPath: result.outputPath ? path.relative(repoRoot, result.outputPath) : undefined,
+            outputPath: result.outputPath
+                ? path.relative(repoRoot, result.outputPath)
+                : undefined,
             patternCount: result.patternCount,
             safetyFindings: result.safetyFindings,
             message: result.message,
@@ -62,3 +127,36 @@ export async function runKnowledge(repoRoot, args) {
         process.stdout.write(result.proposalMarkdown);
     }
 }
+/**
+ * knowledge CLI:
+ * - curate: repair/learned guidance proposals (existing)
+ * - query / graph-*: thin wrappers over scripts/kb-*.{mjs,sh} for graph KB ops
+ */
+export async function runKnowledge(repoRoot, args) {
+    const parsed = parseKnowledgeArgs(args);
+    if (parsed.command === "curate") {
+        await runCurate(repoRoot, parsed);
+        return;
+    }
+    const forward = ensureRootFlag(repoRoot, parsed.forward);
+    switch (parsed.command) {
+        case "query":
+            runNodeScript(repoRoot, "kb-query.mjs", forward);
+            return;
+        case "graph-init":
+            // B1 skeleton is a bash script (no LLM)
+            runBashScript(repoRoot, "kb-bootstrap-init-skeleton.sh", forward);
+            return;
+        case "graph-materialize":
+            runNodeScript(repoRoot, "kb-graph-materialize.mjs", forward);
+            return;
+        case "graph-promote":
+            runNodeScript(repoRoot, "kb-graph-promote.mjs", forward);
+            return;
+        case "graph-incremental-prepare":
+            runNodeScript(repoRoot, "kb-graph-incremental-prepare.mjs", forward);
+            return;
+        default:
+            throw new Error(USAGE);
+    }
+}

package/dist/commands/loop-benchmark.js

@@ -37,17 +37,17 @@ export function parseLoopBenchmarkArgs(args) {
     return { json, markdown, outputPath };
 }
 export function printLoopBenchmarkUsage() {
-    console.log(`usage: loop-benchmark [options]
-
-Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
-
-Options:
-  --json              Emit JSON (default when no format flag is set)
-  --markdown          Emit Markdown report
-  --output <path>     Write Markdown report to a repo-relative or absolute path
-  -h, --help          Show this help
-
-Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
+    console.log(`usage: loop-benchmark [options]
+
+Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
+
+Options:
+  --json              Emit JSON (default when no format flag is set)
+  --markdown          Emit Markdown report
+  --output <path>     Write Markdown report to a repo-relative or absolute path
+  -h, --help          Show this help
+
+Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
 Recommendation never changes convergence.enabled default.`);
 }
 export async function runLoopBenchmark(repoRoot, rawArgs) {

package/dist/commands/pi-reuse-benchmark.js

@@ -106,22 +106,22 @@ export function parsePiReuseBenchmarkArgs(args) {
     };
 }
 export function printPiReuseBenchmarkUsage() {
-    console.log(`usage: pi-reuse-benchmark [options]
-
-Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
-
-Options:
-  --report <path>         Benchmark report markdown (approval status)
-  --approval <path>       Explicit approval JSON artifact
-  --off-executor <path>   Baseline executor.jsonl (reuse off)
-  --on-executor <path>    Treatment executor.jsonl (reuse on)
-  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
-  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
-  --json                  Emit JSON (default when no format flag is set)
-  --markdown              Emit Markdown summary
-  -h, --help              Show this help
-
-Recommendations: defer | maintain-opt-in | eligible-for-human-review
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
 Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
 }
 function resolveRepoRelative(repoRoot, filePath) {

package/dist/executors/pi-sdk-executor.js

@@ -51,31 +51,38 @@ export function setPiSdkImportOverrideForTests(fn) {
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK optional dependency is importable. */
+/** Check whether the Pi SDK optional dependency satisfies the 0.80.10 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: 'pi SDK session factory override active' };
     }
     try {
-        if (sdkImportOverrideForTests) {
-            await sdkImportOverrideForTests();
+        const imported = sdkImportOverrideForTests
+            ? await sdkImportOverrideForTests()
+            : await loadPiSdkModule();
+        const sdk = imported;
+        const ModelRuntime = sdk.ModelRuntime;
+        if (typeof sdk.createAgentSession !== 'function'
+            || typeof sdk.getAgentDir !== 'function'
+            || typeof ModelRuntime?.create !== 'function') {
+            return {
+                ok: false,
+                detail: 'pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10 contract)',
+            };
         }
-        else {
-            await import('@earendil-works/pi-coding-agent');
-        }
-        return { ok: true, detail: 'pi SDK available' };
+        return { ok: true, detail: 'pi SDK 0.80.10 contract available' };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return { ok: false, detail: `pi SDK not available: ${message}` };
     }
 }
-async function resolveModelViaRegistry(modelRegistry, provider, modelId) {
-    const fromRegistry = modelRegistry.find(provider, modelId);
-    if (fromRegistry)
-        return fromRegistry;
+async function resolveModel(modelRuntime, provider, modelId) {
+    const fromRuntime = modelRuntime.getModel(provider, modelId);
+    if (fromRuntime)
+        return fromRuntime;
     try {
-        const piAi = await import('@earendil-works/pi-ai');
+        const piAi = await import('@earendil-works/pi-ai/compat');
         return piAi.getModel?.(provider, modelId);
     }
     catch {
@@ -93,12 +100,16 @@ async function getOrCreateSharedResources(state) {
         return state.resources;
     const sdk = await loadPiSdkModule();
     const getAgentDir = sdk.getAgentDir;
-    const AuthStorage = sdk.AuthStorage;
-    const ModelRegistry = sdk.ModelRegistry;
+    const ModelRuntime = sdk.ModelRuntime;
+    if (typeof ModelRuntime?.create !== 'function') {
+        throw new Error('incompatible pi SDK: ModelRuntime.create is unavailable');
+    }
     const agentDir = getAgentDir();
-    const authStorage = AuthStorage.create();
-    const modelRegistry = ModelRegistry.create(authStorage);
-    state.resources = { agentDir, authStorage, modelRegistry };
+    const modelRuntime = await ModelRuntime.create({
+        authPath: path.join(agentDir, 'auth.json'),
+        modelsPath: path.join(agentDir, 'models.json'),
+    });
+    state.resources = { agentDir, modelRuntime };
     return state.resources;
 }
 async function createSdkSession(sdk, input, shared) {
@@ -106,13 +117,17 @@ async function createSdkSession(sdk, input, shared) {
     const SessionManager = sdk.SessionManager;
     const DefaultResourceLoader = sdk.DefaultResourceLoader;
     const getAgentDir = sdk.getAgentDir;
-    const AuthStorage = sdk.AuthStorage;
-    const ModelRegistry = sdk.ModelRegistry;
+    const ModelRuntime = sdk.ModelRuntime;
     const agentDir = shared?.agentDir ?? getAgentDir();
-    const authStorage = shared?.authStorage ?? AuthStorage.create();
-    const modelRegistry = shared?.modelRegistry ?? ModelRegistry.create(authStorage);
+    if (!shared && typeof ModelRuntime?.create !== 'function') {
+        throw new Error('incompatible pi SDK: ModelRuntime.create is unavailable');
+    }
+    const modelRuntime = shared?.modelRuntime ?? await ModelRuntime.create({
+        authPath: path.join(agentDir, 'auth.json'),
+        modelsPath: path.join(agentDir, 'models.json'),
+    });
     const model = input.provider && input.model
-        ? await resolveModelViaRegistry(modelRegistry, input.provider, input.model)
+        ? await resolveModel(modelRuntime, input.provider, input.model)
         : undefined;
     const loader = new DefaultResourceLoader({
         cwd: input.cwd,
@@ -127,8 +142,7 @@ async function createSdkSession(sdk, input, shared) {
         sessionManager: SessionManager.inMemory(input.cwd),
         resourceLoader: loader,
         tools: input.toolNames,
-        authStorage,
-        modelRegistry,
+        modelRuntime,
         ...(model ? { model } : {}),
         ...(input.thinking ? { thinkingLevel: input.thinking } : {}),
     });

package/dist/executors/shell-executor.js

@@ -3,7 +3,8 @@ import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-store.js";
 import { truncateOutput } from "../shared/output-truncation.js";
-import { expandShellPreset, buildVerdictGateShellCommand } from "./shell-presets.js";
+import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand } from "./shell-presets.js";
+import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { pathsChangedDuringRun, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
@@ -44,7 +45,10 @@ export function resolveShellCommands(shell) {
     const fromVerdictGate = shell.verdictGate
         ? [buildVerdictGateShellCommand(shell.verdictGate)]
         : [];
-    return [...fromPreset, ...explicit, ...fromVerdictGate];
+    const fromRequirementCoverageGate = shell.requirementCoverageGate
+        ? [buildRequirementCoverageGateShellCommand(shell.requirementCoverageGate)]
+        : [];
+    return [...fromPreset, ...explicit, ...fromVerdictGate, ...fromRequirementCoverageGate];
 }
 async function readGitStatusPorcelain(cwd) {
     return new Promise((resolve, reject) => {
@@ -279,6 +283,34 @@ async function runShellWriteGuard(input) {
 }
 export async function executeDagShellNode(input, meta) {
     const shell = input.task.shell;
+    if (shell?.jsonArtifactGate) {
+        const started = Date.now();
+        try {
+            const artifact = await materializeBackendTestAnalysisContract({
+                runDir: meta.runDir,
+                fromNodeId: shell.jsonArtifactGate.fromNodeId,
+                artifactName: shell.jsonArtifactGate.artifactName,
+                outputDir: shell.jsonArtifactGate.outputDir,
+                sourceBinding: meta.spec.sourceBinding,
+            });
+            return {
+                ok: true,
+                stdout: `Structured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
     const commands = shell ? resolveShellCommands(shell) : [];
     if (!shell || commands.length === 0) {
         throw new Error(`shell task ${input.task.id} requires shell.preset, shell.verdictGate, and/or non-empty shell.commands`);

package/dist/executors/shell-presets.js

@@ -45,3 +45,23 @@ export function buildVerdictGateShellCommand(gate) {
         .join("|");
     return `${preamble}; case "\${FIRST}" in ${acceptPattern}) exit 0 ;; *) echo "${blockedMessage}" >&2; exit 1 ;; esac`;
 }
+/** Build a deterministic current-run gate over exact REQ-/BR-/AC- ids in node facts. */
+export function buildRequirementCoverageGateShellCommand(gate) {
+    const label = gate.label ?? "requirement coverage";
+    const requiredJson = escapeShellSingleQuoted(JSON.stringify(gate.requiredIds.map((id) => id.toUpperCase())));
+    const fileArgs = gate.fromNodeIds.map((nodeId) => `"\${HARNESS_DAG_RUN_DIR}/${nodeId}.json"`).join(" ");
+    const program = [
+        'const fs=require("fs");',
+        "const required=JSON.parse(process.argv[1]);",
+        "let text='';",
+        "for(const file of process.argv.slice(2)){",
+        " if(!fs.existsSync(file)){console.error('missing requirement coverage node output: '+file);process.exit(1);}",
+        " const raw=JSON.parse(fs.readFileSync(file,'utf8')); text+='\\n'+String(raw.assistantText ?? raw.stdout ?? '');",
+        "}",
+        "const found=new Set((text.toUpperCase().match(/\\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\\b/g)||[]));",
+        "const missing=required.filter((id)=>!found.has(id));",
+        `if(missing.length){console.error(${JSON.stringify(`${label} gate blocked: missing `)}+missing.join(', '));process.exit(1);}`,
+        `console.log(${JSON.stringify(`${label} gate passed: `)}+required.join(', '));`,
+    ].join("");
+    return `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${label} gate" >&2; exit 1; }; node -e '${escapeShellSingleQuoted(program)}' '${requiredJson}' ${fileArgs}`;
+}

package/dist/executors/shell-verification.js

@@ -20,6 +20,13 @@ const VERIFY_ENV_ALLOWLIST = [
     "COREPACK_ENABLE",
     "COREPACK_ENABLE_AUTO_PIN",
     "COREPACK_HOME",
+    // Windows DLL 加载必需
+    "SystemRoot",
+    "SYSTEMROOT",
+    "windir",
+    "WINDIR",
+    "ComSpec",
+    "PATHEXT",
 ];
 export function buildVerifyProcessEnv(mode = "clean") {
     if (mode === "inherit") {

package/dist/governance/manifest-types.js

@@ -43,6 +43,10 @@ export const workflowPolicyDagTemplateSchema = z.enum([
     "review-gated-dag",
     "supervised-implementation",
     "frontend-implementation",
+    "frontend-test-dag",
+    "backend-test-dag",
+    "knowledge-sync-dag",
+    "knowledge-graph-bootstrap-dag",
 ]);
 export const workflowPolicyOutputLanguageSchema = z.enum(["zh-CN", "en"]);
 export const workflowPolicySchema = z