@tea-agent/loop-agent 0.38.2 → 0.38.4

package/dist/cli/program.js

@@ -33,6 +33,7 @@ import { runHarvest } from "../commands/harvest.js";
 import { runInit } from "../commands/init.js";
 import { readInitRuntimeActivity } from "./update/runtime-activity.js";
 import { runInspect } from "../commands/inspect.js";
+import { runInspectNext } from "../commands/inspect-next.js";
 import { runInstructions } from "../commands/instructions.js";
 import { runKnowledge } from "../commands/knowledge.js";
 import { runLoop } from "../commands/loop.js";
@@ -97,6 +98,9 @@ async function dispatchRegisteredCommand(commandObject, defaultRepoRoot, rawArgs
         [...rest, ...rawArgs].some((token) => token === "--json")) ||
         (command === "stats" &&
             subcommand === "context" &&
+            [...rest, ...rawArgs].some((token) => token === "--json")) ||
+        (command === "inspect" &&
+            subcommand === "next" &&
             [...rest, ...rawArgs].some((token) => token === "--json"));
     const repoRoot = resolveRepoRootOnly(commandObject, defaultRepoRoot, {
         quiet,
@@ -125,8 +129,15 @@ async function runTaskCommand(repoRoot, subcommand, rest) {
 async function runCommanderAction(ctx, command, subcommand, rest) {
     switch (command) {
         case "inspect":
-            await runInspect(ctx.adapter, ctx.repoRoot);
-            return;
+            if (subcommand === "next") {
+                await runInspectNext(ctx.repoRoot, rest);
+                return;
+            }
+            if (subcommand === undefined || subcommand.startsWith("-")) {
+                await runInspect(ctx.adapter, ctx.repoRoot);
+                return;
+            }
+            throw new Error("usage: inspect | inspect next [--json]");
         case "doctor":
             await runDoctor(ctx.adapter, ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -595,6 +606,9 @@ export function buildLoopAgentProgram(options) {
                 .option("--no-merge", "skip existing files")
                 .option("--provider <provider>", "provider paired with a bare --model (otherwise use provider/model)")
                 .option("--model <model>", "qualified provider/model, or a bare model paired with --provider")
+                .option("--low-model <provider/model>", "credential-ready Pi model for LOW")
+                .option("--med-model <provider/model>", "credential-ready Pi model for MED")
+                .option("--high-model <provider/model>", "credential-ready Pi model for HIGH")
                 .option("--json", "print JSON")
                 .option("--markdown", "print Markdown")
                 .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")

package/dist/cli/update/notifier.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { evaluateLatestVersion, shouldCheckForUpdates } from "./policy.js";
-import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "./state.js";
+import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "../../shared/update/state.js";
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const FAILURE_COOLDOWN_MS = 10 * 60 * 1000;
 export async function runSelfUpdateNotifier(options) {
@@ -69,7 +69,7 @@ export async function runSelfUpdateNotifier(options) {
             }
             writeStderr(`loop-agent 已更新到 ${decision.targetVersion}；新版本将在下一次调用时生效。\n`);
             await safeWriteState(statePath, {
-                schemaVersion: 1,
+                ...state,
                 lastCheckedAt: now().toISOString(),
                 latestVersion: decision.targetVersion,
             });

package/dist/cli.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildLoopAgentProgram } from "./cli/program.js";
-import { createNpmUpdateClient } from "./cli/update/npm-client.js";
+import { createNpmUpdateClient } from "./shared/update/npm-client.js";
 import { runSelfUpdateNotifier } from "./cli/update/notifier.js";
 import { resolveInitSurfaceRepoRoot, runInitSurfaceNotifier, } from "./cli/update/init-surface-notifier.js";
 async function main() {
@@ -29,6 +29,7 @@ async function main() {
         client: createNpmUpdateClient({
             currentVersion,
             packageRoot,
+            cwd: defaultRepoRoot,
             env: process.env,
         }),
     });

package/dist/commands/dag-rerun.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import { isDagRerunPromptOverrideEnabled } from "../shared/dag-prompt-override.js";
 import { executeDagRerun, planDagRerun, } from "../workflows/dag/rerun-run.js";
 export function parseDagRerunArgs(args) {
     if (args.length === 0) {
@@ -9,6 +11,8 @@ export function parseDagRerunArgs(args) {
     let planHash;
     let requestId;
     let reason;
+    const promptOverrideSpecs = [];
+    const promptOverrideAppendSpecs = [];
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--run-id")
@@ -33,6 +37,14 @@ export function parseDagRerunArgs(args) {
             reason = args[++index];
         else if (arg.startsWith("--reason="))
             reason = arg.slice("--reason=".length);
+        else if (arg === "--prompt-override")
+            promptOverrideSpecs.push(args[++index] ?? "");
+        else if (arg.startsWith("--prompt-override="))
+            promptOverrideSpecs.push(arg.slice("--prompt-override=".length));
+        else if (arg === "--prompt-override-append")
+            promptOverrideAppendSpecs.push(args[++index] ?? "");
+        else if (arg.startsWith("--prompt-override-append="))
+            promptOverrideAppendSpecs.push(arg.slice("--prompt-override-append=".length));
         else if (arg === "--json")
             continue;
         else if (arg.startsWith("-"))
@@ -50,7 +62,13 @@ export function parseDagRerunArgs(args) {
         if (planHash || requestId || reason) {
             throw new Error("dag rerun --plan cannot be combined with execute flags");
         }
-        return { parentRunId, selectedNodeId, planOnly: true };
+        return {
+            parentRunId,
+            selectedNodeId,
+            planOnly: true,
+            promptOverrideSpecs,
+            promptOverrideAppendSpecs,
+        };
     }
     if (!planHash?.trim()) {
         throw new Error("dag rerun execute requires --plan-hash <hash>");
@@ -68,15 +86,50 @@ export function parseDagRerunArgs(args) {
         planHash: planHash.trim(),
         requestId: requestId.trim(),
         reason: reason.trim(),
+        promptOverrideSpecs,
+        promptOverrideAppendSpecs,
     };
 }
+async function loadPromptOverrides(specs, mode) {
+    const overrides = [];
+    for (const spec of specs) {
+        const separator = spec.indexOf("@");
+        if (separator <= 0 || separator >= spec.length - 1) {
+            throw new Error(`dag rerun --prompt-override${mode === "append" ? "-append" : ""} expects <nodeId>@<filePath>, got: ${spec}`);
+        }
+        const nodeId = spec.slice(0, separator);
+        const filePath = spec.slice(separator + 1);
+        let prompt;
+        try {
+            prompt = await readFile(filePath, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`cannot read prompt override file for node ${nodeId} (${filePath}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+        overrides.push(mode === "append" ? { nodeId, prompt, mode } : { nodeId, prompt });
+    }
+    return overrides;
+}
 export async function runDagRerun(repoRoot, rawArgs) {
     const parsed = parseDagRerunArgs(rawArgs);
+    let promptOverrides;
+    const hasOverrides = parsed.promptOverrideSpecs.length > 0 ||
+        parsed.promptOverrideAppendSpecs.length > 0;
+    if (hasOverrides) {
+        if (!isDagRerunPromptOverrideEnabled()) {
+            throw new Error("prompt override rerun is disabled; set HARNESS_DAG_RERUN_PROMPT_OVERRIDE=1 to enable this experimental capability");
+        }
+        promptOverrides = [
+            ...(await loadPromptOverrides(parsed.promptOverrideSpecs, "replace")),
+            ...(await loadPromptOverrides(parsed.promptOverrideAppendSpecs, "append")),
+        ];
+    }
     if (parsed.planOnly) {
         const plan = await planDagRerun({
             cwd: repoRoot,
             parentRunId: parsed.parentRunId,
             selectedNodeId: parsed.selectedNodeId,
+            promptOverrides,
         });
         const result = {
             ok: plan.eligible,
@@ -95,6 +148,7 @@ export async function runDagRerun(repoRoot, rawArgs) {
         planHash: parsed.planHash,
         requestId: parsed.requestId,
         reason: parsed.reason,
+        promptOverrides,
     });
     console.log(JSON.stringify(result, null, 2));
     if (!result.ok) {

package/dist/commands/init-model-catalog.js

@@ -0,0 +1,464 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function compactRecord(value) {
+    return Object.values(value).some((entry) => entry !== undefined) ? value : undefined;
+}
+function sanitizeInputKinds(value) {
+    if (Array.isArray(value)) {
+        const entries = value.filter((entry) => typeof entry === "string");
+        return entries.length > 0 ? [...new Set(entries)].sort() : undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value)
+        .filter(([, enabled]) => enabled === true)
+        .map(([kind]) => kind)
+        .sort();
+    return entries.length > 0 ? entries : undefined;
+}
+function createCatalogEntry(input) {
+    const piCompatible = input.source === "pi";
+    return {
+        reference: `${input.provider}/${input.modelId}`,
+        provider: input.provider,
+        modelId: input.modelId,
+        ...(input.name ? { name: input.name } : {}),
+        sources: [input.source],
+        credentialReady: input.credentialReady,
+        piCompatible,
+        eligibleForHarness: piCompatible && input.credentialReady === true && input.tools !== false,
+        ...(compactRecord({
+            reasoning: input.reasoning,
+            tools: input.tools,
+            attachments: input.attachments,
+            input: input.inputKinds,
+        })
+            ? {
+                capabilities: compactRecord({
+                    reasoning: input.reasoning,
+                    tools: input.tools,
+                    attachments: input.attachments,
+                    input: input.inputKinds,
+                }),
+            }
+            : {}),
+        ...(compactRecord({
+            contextWindow: input.contextWindow,
+            maxOutputTokens: input.maxOutputTokens,
+        })
+            ? {
+                limits: compactRecord({
+                    contextWindow: input.contextWindow,
+                    maxOutputTokens: input.maxOutputTokens,
+                }),
+            }
+            : {}),
+        ...(compactRecord({ input: input.inputCost, output: input.outputCost })
+            ? {
+                cost: compactRecord({
+                    input: input.inputCost,
+                    output: input.outputCost,
+                }),
+            }
+            : {}),
+    };
+}
+function sourceFailure(code) {
+    return {
+        report: {
+            status: code === "not-installed" || code === "sdk-unavailable" ? "unavailable" : "failed",
+            modelCount: 0,
+            code,
+        },
+        models: [],
+    };
+}
+async function readConfiguredPiModelReferences(modelsPath) {
+    try {
+        const parsed = JSON.parse(await readFile(modelsPath, "utf-8"));
+        if (!isRecord(parsed) || !isRecord(parsed.providers))
+            return [];
+        const references = [];
+        for (const [provider, rawProvider] of Object.entries(parsed.providers)) {
+            if (!isRecord(rawProvider) || !Array.isArray(rawProvider.models))
+                continue;
+            for (const rawModel of rawProvider.models) {
+                if (!isRecord(rawModel))
+                    continue;
+                const modelId = stringField(rawModel.id);
+                if (modelId)
+                    references.push(`${provider}/${modelId}`);
+            }
+        }
+        return [...new Set(references)];
+    }
+    catch {
+        return [];
+    }
+}
+export async function discoverPiInitModels(options) {
+    let sdk;
+    try {
+        sdk = options?.loadSdk
+            ? await options.loadSdk()
+            : (await import("@earendil-works/pi-coding-agent"));
+    }
+    catch {
+        return sourceFailure("sdk-unavailable");
+    }
+    if (typeof sdk.getAgentDir !== "function" ||
+        typeof sdk.ModelRuntime?.create !== "function") {
+        return sourceFailure("sdk-unavailable");
+    }
+    try {
+        const agentDir = sdk.getAgentDir();
+        const modelsPath = path.join(agentDir, "models.json");
+        const runtime = await sdk.ModelRuntime.create({
+            authPath: path.join(agentDir, "auth.json"),
+            modelsPath,
+        });
+        const snapshot = runtime.snapshot ?? {};
+        const available = Array.isArray(snapshot.available) ? snapshot.available : [];
+        const all = Array.isArray(snapshot.all) ? snapshot.all : available;
+        const availableReferences = new Set(available.flatMap((raw) => {
+            if (!isRecord(raw))
+                return [];
+            const provider = stringField(raw.provider);
+            const modelId = stringField(raw.id);
+            return provider && modelId ? [`${provider}/${modelId}`] : [];
+        }));
+        const configuredReferences = await readConfiguredPiModelReferences(modelsPath);
+        const includedReferences = new Set([
+            ...configuredReferences,
+            ...(options?.includeReferences ?? []),
+        ]);
+        const selected = new Map();
+        for (const raw of available) {
+            if (!isRecord(raw))
+                continue;
+            const provider = stringField(raw.provider);
+            const modelId = stringField(raw.id);
+            if (provider && modelId)
+                selected.set(`${provider}/${modelId}`, raw);
+        }
+        for (const raw of all) {
+            if (!isRecord(raw))
+                continue;
+            const provider = stringField(raw.provider);
+            const modelId = stringField(raw.id);
+            const reference = provider && modelId ? `${provider}/${modelId}` : undefined;
+            if (reference && includedReferences.has(reference) && !selected.has(reference)) {
+                selected.set(reference, raw);
+            }
+        }
+        const models = [...selected.values()].flatMap((raw) => {
+            if (!isRecord(raw))
+                return [];
+            const provider = stringField(raw.provider);
+            const modelId = stringField(raw.id);
+            if (!provider || !modelId)
+                return [];
+            const cost = isRecord(raw.cost) ? raw.cost : {};
+            return [
+                createCatalogEntry({
+                    source: "pi",
+                    provider,
+                    modelId,
+                    name: stringField(raw.name),
+                    credentialReady: availableReferences.has(`${provider}/${modelId}`),
+                    reasoning: booleanField(raw.reasoning),
+                    inputKinds: sanitizeInputKinds(raw.input),
+                    contextWindow: numberField(raw.contextWindow),
+                    maxOutputTokens: numberField(raw.maxTokens),
+                    inputCost: numberField(cost.input),
+                    outputCost: numberField(cost.output),
+                }),
+            ];
+        });
+        return {
+            report: {
+                status: "available",
+                modelCount: models.length,
+                knownModelCount: all.length,
+                availableModelCount: availableReferences.size,
+                configuredModelCount: configuredReferences.length,
+                credentialReadyModelCount: models.filter((model) => model.credentialReady).length,
+            },
+            models,
+        };
+    }
+    catch {
+        return sourceFailure("runtime-failed");
+    }
+}
+const ANSI_PATTERN = /[\u001b\u009b][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function stripAnsi(value) {
+    return value.replace(ANSI_PATTERN, "");
+}
+function normalizeProviderLabel(value) {
+    return value.toLocaleLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+/** Parse provider labels only; credential values and paths never leave this parser. */
+export function parseOpenCodeCredentialProviders(value) {
+    const providers = new Set();
+    for (const line of stripAnsi(value).split(/\r?\n/)) {
+        const match = line.match(/^\s*[•*]\s+(.+?)\s+(?:api|oauth|[A-Z][A-Z0-9_]+)\s*$/);
+        if (match?.[1])
+            providers.add(normalizeProviderLabel(match[1]));
+    }
+    return providers;
+}
+export function parseOpenCodeModelReferences(value, credentialProviders = new Set()) {
+    const models = new Map();
+    for (const rawLine of stripAnsi(value).split(/\r?\n/)) {
+        const line = rawLine.trim();
+        const match = line.match(/^([A-Za-z0-9._-]+)\/(\S+)$/);
+        if (!match)
+            continue;
+        const [, provider, modelId] = match;
+        const model = createCatalogEntry({
+            source: "opencode",
+            provider,
+            modelId,
+            credentialReady: credentialProviders.has(normalizeProviderLabel(provider))
+                ? true
+                : null,
+        });
+        models.set(model.reference, model);
+    }
+    return [...models.values()];
+}
+export async function discoverOpenCodeInitModels(options) {
+    const runCommand = options.runCommand ??
+        (async (command, args, commandOptions) => (await execFileAsync(command, args, {
+            cwd: commandOptions.cwd,
+            timeout: commandOptions.timeout,
+            maxBuffer: commandOptions.maxBuffer,
+            encoding: "utf8",
+            windowsHide: true,
+        })));
+    const commandOptions = {
+        cwd: options.repoRoot,
+        timeout: 15_000,
+        maxBuffer: 16 * 1024 * 1024,
+    };
+    const executable = process.platform === "win32" ? (process.env.ComSpec ?? "cmd.exe") : "opencode";
+    const commandArgs = (args) => process.platform === "win32"
+        ? ["/d", "/s", "/c", "opencode.cmd", ...args]
+        : args;
+    try {
+        const [modelsResult, authResult] = await Promise.all([
+            runCommand(executable, commandArgs(["models", "--pure"]), commandOptions),
+            runCommand(executable, commandArgs(["auth", "list", "--pure"]), commandOptions).catch(() => ({ stdout: "" })),
+        ]);
+        const models = parseOpenCodeModelReferences(modelsResult.stdout, parseOpenCodeCredentialProviders(authResult.stdout));
+        if (models.length === 0)
+            return sourceFailure("invalid-output");
+        return {
+            report: { status: "available", modelCount: models.length },
+            models,
+        };
+    }
+    catch (error) {
+        const code = isRecord(error) ? error.code : undefined;
+        return sourceFailure(code === "ENOENT" ? "not-installed" : "command-failed");
+    }
+}
+function mergeCatalogModels(models) {
+    const merged = new Map();
+    for (const model of models) {
+        const current = merged.get(model.reference);
+        if (!current) {
+            merged.set(model.reference, model);
+            continue;
+        }
+        const sources = [...new Set([...current.sources, ...model.sources])].sort();
+        const piModel = model.sources.includes("pi") ? model : current;
+        merged.set(model.reference, {
+            ...current,
+            ...model,
+            name: piModel.name ?? model.name ?? current.name,
+            sources,
+            credentialReady: piModel.credentialReady,
+            piCompatible: true,
+            eligibleForHarness: piModel.eligibleForHarness,
+            capabilities: { ...current.capabilities, ...model.capabilities, ...piModel.capabilities },
+            limits: { ...current.limits, ...model.limits, ...piModel.limits },
+            cost: { ...current.cost, ...model.cost, ...piModel.cost },
+        });
+    }
+    return [...merged.values()].sort((left, right) => left.reference.localeCompare(right.reference));
+}
+function buildPiSetupGuidance(report) {
+    if (report.status !== "available") {
+        return {
+            status: "discovery-failed",
+            reason: `Pi model discovery is ${report.status}${report.code ? ` (${report.code})` : ""}.`,
+            nextSteps: [
+                "Repair or install the Pi runtime, then rerun init model-catalog before changing harness model routing.",
+            ],
+        };
+    }
+    if ((report.availableModelCount ?? report.modelCount) === 0 &&
+        (report.configuredModelCount ?? 0) === 0) {
+        return {
+            status: "model-definition-required",
+            reason: "Pi exposes no model definitions, so harness model routing cannot be selected safely.",
+            configPath: "~/.pi/agent/models.json",
+            requiredUserInput: [
+                "provider id and model id",
+                "provider API type and base URL when using a custom endpoint",
+                "context window and maximum output tokens",
+                "supported input types and whether reasoning is supported",
+                "cost constraints when they affect LOW/MED/HIGH selection",
+                "credential method or environment-variable name, never the credential value in chat or catalog output",
+            ],
+            rules: [
+                "Ask the user only for facts that cannot be inferred from their provider documentation or existing agent configuration.",
+                "Merge a model definition into Pi models.json without replacing unrelated providers or models.",
+                "Do not copy secrets into harness.json, reports, prompts, or model-catalog output; prefer Pi login/auth storage or an environment-variable reference.",
+            ],
+            nextSteps: [
+                "After the user supplies the missing facts, help configure Pi models.json and authentication using Pi's native schema.",
+                "Rerun init model-catalog and select harness tiers only after Pi reports credential-ready models.",
+            ],
+        };
+    }
+    if ((report.credentialReadyModelCount ?? 0) === 0) {
+        return {
+            status: "credentials-required",
+            reason: "Pi knows model definitions but none are credential-ready.",
+            nextSteps: [
+                "Ask the user which existing Pi provider should be enabled and which credential method is allowed; if the intended model is not defined in Pi, also ask for its provider/model id, API/base URL, context window, maximum output tokens, inputs, reasoning support, and cost constraints.",
+                "Configure authentication through Pi login/auth storage or an environment-variable reference without exposing the credential to loop-agent.",
+                "Rerun init model-catalog before selecting or changing harness tiers.",
+            ],
+        };
+    }
+    return { status: "ready" };
+}
+function configuredTierReference(value) {
+    const model = typeof value === "string"
+        ? value
+        : isRecord(value) && typeof value.model === "string"
+            ? value.model
+            : undefined;
+    if (!model)
+        return undefined;
+    const trimmed = model.trim();
+    return trimmed.length > 0 && trimmed !== "default" ? trimmed : undefined;
+}
+export function assessInitPiModelReadiness(pi, catalog) {
+    const tiers = {};
+    const preserveTiers = [];
+    const reselectTiers = [];
+    const piModels = catalog.models.filter((model) => model.sources.includes("pi"));
+    for (const tier of ["LOW", "MED", "HIGH"]) {
+        const configured = configuredTierReference(pi?.[tier]);
+        const matches = configured
+            ? configured.includes("/")
+                ? piModels.filter((model) => model.reference === configured)
+                : piModels.filter((model) => model.modelId === configured)
+            : [];
+        const resolved = matches.length === 1 ? matches[0] : undefined;
+        const credentialReady = resolved?.eligibleForHarness === true;
+        tiers[tier] = {
+            ...(configured ? { configured } : {}),
+            ...(resolved ? { resolvedReference: resolved.reference } : {}),
+            inCatalog: resolved !== undefined,
+            credentialReady,
+        };
+        if (resolved)
+            preserveTiers.push(tier);
+        else
+            reselectTiers.push(tier);
+    }
+    let status;
+    if (catalog.piSetup.status === "model-definition-required") {
+        status = "model-definition-required";
+    }
+    else if (catalog.piSetup.status === "credentials-required") {
+        status = "credentials-required";
+    }
+    else if (catalog.piSetup.status === "discovery-failed") {
+        status = "discovery-failed";
+    }
+    else if (preserveTiers.some((tier) => tiers[tier].credentialReady === false)) {
+        status = "credentials-required";
+    }
+    else if (reselectTiers.length === 0) {
+        status = "ready";
+    }
+    else if (preserveTiers.length === 0) {
+        status = "selection-required";
+    }
+    else {
+        status = "reselection-required";
+    }
+    return {
+        status,
+        source: catalog.sources.pi,
+        eligibleReferences: catalog.eligibleReferences,
+        tiers,
+        preserveTiers,
+        reselectTiers,
+    };
+}
+export async function discoverInitModelCatalog(options) {
+    const [pi, opencode] = await Promise.all([
+        options.discoverPi?.() ??
+            discoverPiInitModels({ includeReferences: options.includePiReferences }),
+        options.discoverOpenCode?.() ??
+            discoverOpenCodeInitModels({ repoRoot: options.repoRoot }),
+    ]);
+    const models = mergeCatalogModels([...pi.models, ...opencode.models]);
+    const piSetup = buildPiSetupGuidance(pi.report);
+    return {
+        schemaVersion: 1,
+        privacy: {
+            rawConfigurationExposed: false,
+            credentialMaterialExposed: false,
+            note: "Collectors use Pi runtime metadata and OpenCode's non-verbose model/provider listings, then emit only allowlisted model metadata and credential readiness; raw config, tokens, headers, URLs, options, stderr, and auth paths are excluded.",
+        },
+        sources: { pi: pi.report, opencode: opencode.report },
+        models,
+        eligibleReferences: models
+            .filter((model) => model.eligibleForHarness)
+            .map((model) => model.reference),
+        piSetup,
+        selectionGuidance: {
+            LOW: "Prefer low latency and low cost for classification, scouting, and routine lightweight work.",
+            MED: "Prefer balanced coding, planning, and review quality for ordinary repository work.",
+            HIGH: "Prefer the strongest reasoning and coding capability for architecture, critical review, and difficult repair.",
+            rules: [
+                "Choose only models with eligibleForHarness=true; OpenCode-only entries are context, not proof of Pi executor compatibility.",
+                "Use target-project evidence plus model capabilities, cost, context window, and credential readiness; tiers may intentionally share a model.",
+                "Preserve an existing complete usable matrix unless it is unavailable or the user asked to reselect it.",
+                "Ask the user only for a material unresolved credential, cost, compliance, or availability decision.",
+            ],
+        },
+    };
+}
+export function validateInitModelMatrixAgainstCatalog(matrix, catalog) {
+    const eligible = new Set(catalog.eligibleReferences);
+    for (const [tier, reference] of Object.entries(matrix)) {
+        if (!eligible.has(reference)) {
+            throw new Error(`init --${tier.toLocaleLowerCase()}-model is not a credential-ready Pi model from init model-catalog: ${reference}`);
+        }
+    }
+}