@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/actions/schemas.d.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+export declare const ActionValueIdPattern: RegExp;
+export declare const ActionValueIdSchema: z.ZodString;
+export declare const OptionalActionValueIdSchema: z.ZodString;
+export declare const BenchmarkCheckActionValueSchema: z.ZodObject<{
+    question: z.ZodString;
+    answer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RequestedArtifactActionValueSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strict>]>>>;
+    output: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                source_manifest_valid: "source_manifest_valid";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                source_summary_folders: "source_summary_folders";
+                source_page_coverage: "source_page_coverage";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+                source_refs_required: "source_refs_required";
+                summary_backlinks_present: "summary_backlinks_present";
+                knowledge_web_connectivity: "knowledge_web_connectivity";
+                graph_notes_connected: "graph_notes_connected";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        stage_hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const SourceContextActionValueSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        page_count: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ProjectSetupActionValuesSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    intent: z.ZodString;
+    build_plan: z.ZodOptional<z.ZodString>;
+    build_after_setup: z.ZodOptional<z.ZodBoolean>;
+    setup_mode: z.ZodOptional<z.ZodEnum<{
+        create: "create";
+        "select-build-plan": "select-build-plan";
+    }>>;
+}, z.core.$strict>;
+export declare const BuildPlanAuthoringActionValuesSchema: z.ZodObject<{
+    build_plan_id: z.ZodOptional<z.ZodString>;
+    base_build_plan_id: z.ZodOptional<z.ZodString>;
+    reference_build_plan_id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+    intent: z.ZodString;
+    requested_artifacts_description: z.ZodOptional<z.ZodString>;
+    requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        purpose: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strict>]>>>;
+        output: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            shape: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"path">;
+                path: z.ZodString;
+                artifact_kind: z.ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+            }, z.core.$strict>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    file_exists: "file_exists";
+                    source_manifest_valid: "source_manifest_valid";
+                    min_file_count: "min_file_count";
+                    min_file_count_matches_source: "min_file_count_matches_source";
+                    source_summary_folders: "source_summary_folders";
+                    source_page_coverage: "source_page_coverage";
+                    frontmatter_valid: "frontmatter_valid";
+                    frontmatter_required_keys: "frontmatter_required_keys";
+                    frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
+                    source_refs_required: "source_refs_required";
+                    summary_backlinks_present: "summary_backlinks_present";
+                    knowledge_web_connectivity: "knowledge_web_connectivity";
+                    graph_notes_connected: "graph_notes_connected";
+                    wikilinks_valid: "wikilinks_valid";
+                    must_not_contain: "must_not_contain";
+                    must_contain: "must_contain";
+                    qa_match: "qa_match";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            stage_hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodString>;
+        evidence_expectation: z.ZodOptional<z.ZodString>;
+        backed_by_artifact_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    user_prep_instructions: z.ZodOptional<z.ZodString>;
+    source_context: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        summary: z.ZodOptional<z.ZodString>;
+        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            page_count: z.ZodOptional<z.ZodNumber>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ProjectSetupActionValues = z.infer<typeof ProjectSetupActionValuesSchema>;
+export type BuildPlanAuthoringActionValues = z.infer<typeof BuildPlanAuthoringActionValuesSchema>;
+export type BenchmarkCheckActionValue = z.infer<typeof BenchmarkCheckActionValueSchema>;
+export declare const requiredActionText: (field: string) => z.ZodString;
+export declare const optionalActionText: z.ZodString;
+export declare const actionIdField: (field: string) => z.ZodString;
+export declare const optionalActionIdField: (field: string) => z.ZodString;

package/dist/packages/runtime/actions/schemas.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { BuildPlanContextCheckDraftSchema, RequestedArtifactSchema, SourceContextSchema, } from "../../build-plans/authoring/brief.js";
+export const ActionValueIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const ActionValueIdSchema = z.string().trim().regex(ActionValueIdPattern, "Use lowercase letters, numbers, and dashes.");
+export const OptionalActionValueIdSchema = z.string().trim().refine((value) => value === "" || ActionValueIdPattern.test(value), "Use lowercase letters, numbers, and dashes.");
+export const BenchmarkCheckActionValueSchema = z.object({
+    question: z.string().trim().min(1),
+    answer: z.string().trim().optional(),
+}).strict();
+export const RequestedArtifactActionValueSchema = RequestedArtifactSchema;
+export const SourceContextActionValueSchema = SourceContextSchema;
+export const ProjectSetupActionValuesSchema = z.object({
+    name: ActionValueIdSchema,
+    path: z.string().trim().min(1, "Source is required."),
+    intent: z.string().trim().min(1, "Agent task is required."),
+    build_plan: OptionalActionValueIdSchema.optional(),
+    build_after_setup: z.boolean().optional(),
+    setup_mode: z.enum(["create", "select-build-plan"]).optional(),
+}).strict();
+export const BuildPlanAuthoringActionValuesSchema = z.object({
+    build_plan_id: ActionValueIdSchema.optional(),
+    base_build_plan_id: ActionValueIdSchema.optional(),
+    reference_build_plan_id: ActionValueIdSchema.optional(),
+    label: z.string().trim().optional(),
+    hint: z.string().trim().optional(),
+    intent: z.string().trim().min(1, "Intent is required."),
+    requested_artifacts_description: z.string().trim().optional(),
+    requested_artifacts: z.array(RequestedArtifactActionValueSchema).optional(),
+    checks: z.array(BuildPlanContextCheckDraftSchema).optional(),
+    user_prep_instructions: z.string().trim().optional(),
+    source_context: SourceContextActionValueSchema.nullable().optional(),
+}).strict();
+// ── Internal zod helpers used to compose form input validation schemas ──
+export const requiredActionText = (field) => z.string().trim().min(1, `${field} is required.`);
+export const optionalActionText = z.string().trim();
+export const actionIdField = (field) => requiredActionText(field).regex(ActionValueIdPattern, `${field} must use lowercase letters, numbers, and dashes.`);
+export const optionalActionIdField = (field) => optionalActionText.refine((value) => value === "" || ActionValueIdPattern.test(value), `${field} must use lowercase letters, numbers, and dashes.`);

package/dist/packages/runtime/agent-handoff.d.ts

@@ -0,0 +1,11 @@
+import type { InterfMcpHandoff, InterfMcpServer } from "./schemas/index.js";
+export interface InterfMcpHandoffInput {
+    serviceUrl: string;
+    authToken: string | null;
+    skillPath: string;
+    mcpCommand?: string;
+    mcpArgs?: string[];
+}
+export declare function buildInterfMcpServers(input: InterfMcpHandoffInput): InterfMcpServer[];
+export declare function buildInterfMcpInstructions(input: InterfMcpHandoffInput): string;
+export declare function buildInterfMcpHandoff(input: InterfMcpHandoffInput): InterfMcpHandoff;

package/dist/packages/runtime/agent-handoff.js

@@ -0,0 +1,102 @@
+export function buildInterfMcpServers(input) {
+    const httpConfig = {
+        url: input.serviceUrl,
+        auth_token: input.authToken,
+    };
+    const mcpServers = [];
+    if (input.mcpCommand) {
+        mcpServers.push({
+            kind: "mcp-stdio",
+            label: "Interf MCP",
+            command: input.mcpCommand,
+            args: input.mcpArgs ?? [],
+            instructions: "Use this with Claude Desktop, Cursor, or another local MCP host while the local Interf service is running.",
+        });
+    }
+    mcpServers.push({
+        kind: "skill",
+        label: "Interf Skill",
+        path: input.skillPath,
+        instructions: "Fallback only when the agent host cannot use local MCP.",
+    }, {
+        kind: "http",
+        label: "Developer HTTP fallback",
+        config: httpConfig,
+        instructions: "Developer fallback for local tools that can call the app-owned service with a bearer token.",
+    });
+    return mcpServers;
+}
+export function buildInterfMcpInstructions(input) {
+    const connection = {
+        url: input.serviceUrl,
+        auth_token: input.authToken,
+    };
+    const mcpConfig = input.mcpCommand
+        ? {
+            mcpServers: {
+                interf: {
+                    command: input.mcpCommand,
+                    args: input.mcpArgs ?? [],
+                },
+            },
+        }
+        : null;
+    return [
+        "Use Interf when this user's agent needs to prepare local files before answering. Source files stay local and read-only.",
+        "Interf is not a search engine and not a general RAG index. MCP is for creating or inspecting task-specific Context Graphs for the user's current Source.",
+        "Interf MCP lets a host such as Claude Desktop or Cursor talk to Interf. Agents listed inside Interf are executors that run Build Plan stages. Do not mix these concepts.",
+        "",
+        "MCP setup:",
+        "Interf MCP. Keep the local Interf service running; the MCP process talks to that authorized service and must not start a separate Interf runtime.",
+        ...(mcpConfig
+            ? [
+                "",
+                "Claude Desktop / local MCP config:",
+                "```json",
+                JSON.stringify(mcpConfig, null, 2),
+                "```",
+            ]
+            : []),
+        "",
+        "Fallbacks:",
+        `- Skill fallback, only when local MCP is unavailable: ${input.skillPath}`,
+        "- Developer HTTP fallback, only for local tools that can call the app-owned service:",
+        "```json",
+        JSON.stringify(connection, null, 2),
+        "```",
+        "",
+        "Rules:",
+        "- Default flow: identify the current Source, create a fresh Project for this session unless the user explicitly names an existing Project id, prepare a Build Plan from the Project intent and requested outputs, stop for Build Plan approval, build only after that approval, then read home.md, GraphManifest primary metrics, knowledge/summaries, and source-backed traces.",
+        "- Source scope default: when Interf, MCP, or the user context provides a Source locator or file set, use the whole Source. Do not ask the user to choose individual files or a subset unless they explicitly ask to narrow scope.",
+        "- Do not browse existing Projects as a corpus. Reuse an existing Context Graph only when it clearly matches the same Source and task.",
+        "- If no Project matches the current Source, create a new Project for this session.",
+        "- If no usable Source locator is available, ask for one Source locator instead of answering from unrelated Projects. In the local path this may be a folder path. Do not present a file-selection menu.",
+        `- Probe only discovery resources before authorization: ${input.serviceUrl}/health, ${input.serviceUrl}/v1, ${input.serviceUrl}/v1/instance, or ${input.serviceUrl}/v1/openapi.json`,
+        "- Do not scan ports.",
+        "- Send `Authorization: Bearer <auth_token>` on every protected `/v1` request. `/health`, `/v1`, `/v1/instance`, and `/v1/openapi.json` are discovery routes.",
+        "- Do not install npm or npx packages for an already-configured local MCP handoff.",
+        "- Do not use a global `interf` CLI when an app-backed MCP launcher is available.",
+        "- Project creation is allowed when the user asks Interf to use a Source. Project ids are generated internally. Do not ask for existing Project ids.",
+        "- Ask before drafting Build Plans or starting Build runs unless the user grants autonomy.",
+        "- After a Build succeeds, start from home.md. Use GraphManifest primary metrics for coverage, summaries/ for Source coverage proof, knowledge/ for drilldown, and artifacts/ only for focused task entrypoint notes.",
+        "- No automatic retries: if a Build Plan draft, Build Plan improvement, Build run, or status poll reaches failed/cancelled, report what failed and ask the user before starting another run.",
+    ].join("\n");
+}
+export function buildInterfMcpHandoff(input) {
+    const connection = {
+        url: input.serviceUrl,
+        auth_token: input.authToken,
+    };
+    return {
+        kind: "interf-mcp-handoff",
+        version: 1,
+        service_url: input.serviceUrl,
+        discovery_url: `${input.serviceUrl}/health`,
+        auth_required: Boolean(input.authToken),
+        auth_token: input.authToken,
+        skill_path: input.skillPath,
+        connection_json: connection,
+        mcp_servers: buildInterfMcpServers(input),
+        instructions: buildInterfMcpInstructions(input),
+    };
+}

package/dist/packages/{engine → runtime}/agents/index.d.ts

@@ -11,9 +11,8 @@ export * as types from "./lib/types.js";
 export * as agents from "./lib/agents.js";
 export * as executionProfile from "./lib/execution-profile.js";
 export * as executors from "./lib/executors.js";
-export * as schema from "./lib/schema.js";
 export * as userConfig from "./lib/user-config.js";
-export * as verifiableContextBootstrap from "./lib/verifiable-context-bootstrap.js";
+export * as contextGraphBootstrap from "./lib/context-graph-bootstrap.js";
 export * as registry from "./registry.js";
 export * as roleRouter from "./role-router.js";
 export * as roleExecutors from "./role-executors.js";

package/dist/packages/{engine → runtime}/agents/index.js

@@ -11,9 +11,8 @@ export * as types from "./lib/types.js";
 export * as agents from "./lib/agents.js";
 export * as executionProfile from "./lib/execution-profile.js";
 export * as executors from "./lib/executors.js";
-export * as schema from "./lib/schema.js";
 export * as userConfig from "./lib/user-config.js";
-export * as verifiableContextBootstrap from "./lib/verifiable-context-bootstrap.js";
+export * as contextGraphBootstrap from "./lib/context-graph-bootstrap.js";
 export * as registry from "./registry.js";
 export * as roleRouter from "./role-router.js";
 export * as roleExecutors from "./role-executors.js";

package/dist/packages/runtime/agents/lib/args.d.ts

@@ -0,0 +1,14 @@
+import type { AgentExecutionProfile } from "./executors.js";
+import type { Agent } from "./types.js";
+/**
+ * Build the spawn env for an agent. Delegates to the provider's
+ * `buildEnv` so per-agent quirks (e.g. Codex stripping `SHELL`) live
+ * with the provider, not here.
+ */
+export declare function buildAgentEnv(agent: Agent, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * Build the spawn args for an agent. Delegates to the provider's
+ * `buildArgs`. Throws when the agent is not driveable for automated
+ * Build runs (e.g. Cursor today, or any unknown user-registered name).
+ */
+export declare function buildAgentArgs(agent: Agent, prompt: string, executionProfile?: AgentExecutionProfile): string[];

package/dist/packages/runtime/agents/lib/args.js

@@ -0,0 +1,24 @@
+import { getBuiltInProvider } from "../providers/index.js";
+/**
+ * Build the spawn env for an agent. Delegates to the provider's
+ * `buildEnv` so per-agent quirks (e.g. Codex stripping `SHELL`) live
+ * with the provider, not here.
+ */
+export function buildAgentEnv(agent, baseEnv = process.env) {
+    const provider = getBuiltInProvider(agent.name);
+    if (provider)
+        return provider.buildEnv(baseEnv);
+    return { ...baseEnv };
+}
+/**
+ * Build the spawn args for an agent. Delegates to the provider's
+ * `buildArgs`. Throws when the agent is not driveable for automated
+ * Build runs (e.g. Cursor today, or any unknown user-registered name).
+ */
+export function buildAgentArgs(agent, prompt, executionProfile = {}) {
+    const provider = getBuiltInProvider(agent.name);
+    if (!provider) {
+        throw new Error(`Agent "${agent.displayName}" is not yet supported for automated Build runs.`);
+    }
+    return provider.buildArgs(prompt, executionProfile);
+}

package/dist/packages/{engine → runtime}/agents/lib/constants.d.ts

@@ -1,5 +1,8 @@
 import type { Agent } from "./types.js";
 export declare const SHOW_AGENT_TOOL_EVENTS: boolean;
+/**
+ * Built-in agents Interf knows about. Derived from the provider registry —
+ * keep new entries in `../providers/index.ts`, not here.
+ */
 export declare const AGENTS: Agent[];
-export declare const CODEX_NOISE_PATTERNS: RegExp[];
 export declare const VISIBLE_STATUS_PREFIXES: string[];

package/dist/packages/runtime/agents/lib/constants.js

@@ -0,0 +1,13 @@
+import { BUILT_IN_PROVIDERS } from "../providers/index.js";
+export const SHOW_AGENT_TOOL_EVENTS = process.env.INTERF_DEBUG_AGENT_TOOLS === "1";
+/**
+ * Built-in agents Interf knows about. Derived from the provider registry —
+ * keep new entries in `../providers/index.ts`, not here.
+ */
+export const AGENTS = BUILT_IN_PROVIDERS.map((provider) => ({
+    name: provider.name,
+    displayName: provider.displayName,
+    skillsDir: provider.skillsDir,
+    command: provider.command,
+}));
+export const VISIBLE_STATUS_PREFIXES = ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"];

package/dist/packages/runtime/agents/lib/context-graph-bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { renderClaudeBootstrap } from "./shells.js";
+export { renderClaudeBootstrap };
+export declare function refreshContextGraphBootstrapGuidance(dirPath: string): boolean;

package/dist/packages/{engine/agents/lib/verifiable-context-bootstrap.js → runtime/agents/lib/context-graph-bootstrap.js}

@@ -1,18 +1,17 @@
 import { basename } from "node:path";
-import { readInterfConfig } from "../../../project/interf-detect.js";
+import { readInterfConfig } from "../../../projects/interf-detect.js";
 import { resolveBuildPlanId } from "../../../build-plans/build-plan-resolution.js";
-import { projectVerifiableContextQueryShell, renderClaudeBootstrap } from "./shells.js";
+import { projectContextGraphQueryShell, renderClaudeBootstrap } from "./shells.js";
 export { renderClaudeBootstrap };
-export function refreshVerifiableContextBootstrapGuidance(dirPath) {
+export function refreshContextGraphBootstrapGuidance(dirPath) {
     const config = readInterfConfig(dirPath);
     if (!config)
         return false;
-    const verifiableContextName = config.name ?? basename(dirPath);
+    const contextGraphName = config.name ?? basename(dirPath);
     const buildPlanId = resolveBuildPlanId(config);
     const buildPlanOriginSelected = config.build_plan_origin?.selected ?? buildPlanId;
     const buildPlanLocalDraft = config.build_plan_origin?.local_draft === true;
-    const about = typeof config.about === "string" && config.about.length > 0 ? config.about : undefined;
-    return projectVerifiableContextQueryShell(dirPath, verifiableContextName, buildPlanId, about, {
+    return projectContextGraphQueryShell(dirPath, contextGraphName, buildPlanId, {
         buildPlanOriginSelected,
         buildPlanLocalDraft,
     });

package/dist/packages/{engine → runtime}/agents/lib/detection.d.ts

@@ -1,4 +1,9 @@
 import type { Agent } from "./types.js";
+/**
+ * Detect built-in agents present on this machine. An agent is "detected"
+ * when its provider's home dir exists. Command-on-PATH is a runtime
+ * concern checked separately.
+ */
 export declare function detectAgents(): Agent[];
 /**
  * Whether the executable named in an agent's `command` field resolves on

package/dist/packages/{engine → runtime}/agents/lib/detection.js

@@ -1,14 +1,22 @@
 import { existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { loadUserConfig } from "./user-config.js";
 import { AGENTS } from "./constants.js";
+import { BUILT_IN_PROVIDERS, getBuiltInProvider } from "../providers/index.js";
+/**
+ * Detect built-in agents present on this machine. An agent is "detected"
+ * when its provider's home dir exists. Command-on-PATH is a runtime
+ * concern checked separately.
+ */
 export function detectAgents() {
-    return AGENTS.filter((agent) => {
-        const dir = join(homedir(), `.${agent.name === "claude-code" ? "claude" : agent.name}`);
-        return existsSync(dir);
-    });
+    return BUILT_IN_PROVIDERS
+        .filter((provider) => existsSync(provider.homeDir))
+        .map((provider) => ({
+        name: provider.name,
+        displayName: provider.displayName,
+        skillsDir: provider.skillsDir,
+        command: provider.command,
+    }));
 }
 function commandExists(command) {
     try {
@@ -31,7 +39,8 @@ export function agentCommandAvailable(command) {
     return commandExists(firstToken);
 }
 export function supportsAutomatedRuns(agent) {
-    return agent.name === "claude-code" || agent.name === "codex";
+    const provider = getBuiltInProvider(agent.name);
+    return Boolean(provider?.supportsAutomatedRuns);
 }
 export function resolveAgent() {
     const config = loadUserConfig();

package/dist/packages/{engine → runtime}/agents/lib/execution-profile.d.ts

@@ -11,6 +11,20 @@ type ExecutionProfileArgSource = Record<string, unknown> & {
     "timeout-ms"?: unknown;
 };
 export declare function executionProfileFromArgv(argv: ExecutionProfileArgSource): AgentExecutionProfile;
+/**
+ * Resolve the EFFECTIVE execution profile for an agent: the per-run override
+ * (`executionProfile`) wins, and any field it leaves unset falls back to the
+ * agent's saved prefs (`~/.interf/agents.json` `agent_prefs[name]`). This is
+ * the single merge that used to live inline in `spawnAgent`. It is resolved
+ * ONCE at executor construction so the model the executor REPORTS
+ * (`buildRuntimeExecutorInfo`) is the exact model the executor RUNS
+ * (`buildAgentArgs`) — a session can no longer record `model: null` for a run
+ * whose model came from saved prefs (the common path).
+ *
+ * `profile` / `timeoutMs` are not pref-backed today (prefs only carry
+ * `model` / `effort` / `env_vars`), so they pass through unchanged.
+ */
+export declare function resolveEffectiveAgentExecutionProfile(agent: AgentLike, executionProfile?: AgentExecutionProfile): AgentExecutionProfile;
 export declare function applyInternalAcceptanceExecutionProfileDefaults(agent: AgentLike, overrides?: AgentExecutionProfile): AgentExecutionProfile;
 export declare function hasAgentExecutionProfile(profile: AgentExecutionProfile | null | undefined): boolean;
 export declare function formatAgentExecutionProfile(profile: AgentExecutionProfile | null | undefined): string | null;

package/dist/packages/{engine → runtime}/agents/lib/execution-profile.js

@@ -1,14 +1,6 @@
+import { getBuiltInProvider } from "../providers/index.js";
+import { loadAgentPrefs } from "../registry.js";
 const INTERNAL_ACCEPTANCE_TIMEOUT_MS = 480000;
-const INTERNAL_ACCEPTANCE_DEFAULTS = {
-    "claude-code": {
-        model: "claude-sonnet-4-6",
-        effort: "low",
-    },
-    codex: {
-        model: "gpt-5.3-codex",
-        effort: "high",
-    },
-};
 function readAgentName(agent) {
     if (!agent)
         return null;
@@ -56,15 +48,40 @@ export function executionProfileFromArgv(argv) {
         timeoutMs: normalizeOptionalTimeout(argv.timeoutMs ?? argv["timeout-ms"]),
     };
 }
+/**
+ * Resolve the EFFECTIVE execution profile for an agent: the per-run override
+ * (`executionProfile`) wins, and any field it leaves unset falls back to the
+ * agent's saved prefs (`~/.interf/agents.json` `agent_prefs[name]`). This is
+ * the single merge that used to live inline in `spawnAgent`. It is resolved
+ * ONCE at executor construction so the model the executor REPORTS
+ * (`buildRuntimeExecutorInfo`) is the exact model the executor RUNS
+ * (`buildAgentArgs`) — a session can no longer record `model: null` for a run
+ * whose model came from saved prefs (the common path).
+ *
+ * `profile` / `timeoutMs` are not pref-backed today (prefs only carry
+ * `model` / `effort` / `env_vars`), so they pass through unchanged.
+ */
+export function resolveEffectiveAgentExecutionProfile(agent, executionProfile = {}) {
+    const name = readAgentName(agent);
+    const prefs = name ? loadAgentPrefs()[name] : undefined;
+    return {
+        ...executionProfile,
+        model: executionProfile.model ?? prefs?.model ?? null,
+        effort: executionProfile.effort ?? prefs?.effort ?? null,
+    };
+}
 export function applyInternalAcceptanceExecutionProfileDefaults(agent, overrides = {}) {
-    const defaults = INTERNAL_ACCEPTANCE_DEFAULTS[readAgentName(agent) ?? ""];
+    const provider = getBuiltInProvider(readAgentName(agent) ?? "");
+    const defaultModel = provider?.defaultModel ?? null;
+    const defaultEffort = provider?.defaultEffort ?? null;
     const profile = overrides.profile ?? null;
     const explicitEffort = overrides.effort ?? null;
+    const hasDefaults = Boolean(provider && (defaultModel || defaultEffort));
     return {
-        model: overrides.model ?? defaults?.model ?? null,
+        model: overrides.model ?? defaultModel ?? null,
         profile,
-        effort: explicitEffort ?? (profile ? null : defaults?.effort ?? null),
-        timeoutMs: overrides.timeoutMs ?? (defaults ? INTERNAL_ACCEPTANCE_TIMEOUT_MS : null),
+        effort: explicitEffort ?? (profile ? null : defaultEffort ?? null),
+        timeoutMs: overrides.timeoutMs ?? (hasDefaults ? INTERNAL_ACCEPTANCE_TIMEOUT_MS : null),
     };
 }
 export function hasAgentExecutionProfile(profile) {

package/dist/packages/{engine → runtime}/agents/lib/execution.js

@@ -1,14 +1,22 @@
 import { spawn } from "node:child_process";
 import chalk from "chalk";
-import { CODEX_NOISE_PATTERNS } from "./constants.js";
+import { getBuiltInProvider } from "../providers/index.js";
+import { loadAgentPrefs } from "../registry.js";
 import { buildAgentArgs, buildAgentEnv } from "./args.js";
-import { appendAgentEventLog, appendAgentStatusLog } from "./logs.js";
-import { displayAgentEvent, emitVisibleAgentText, summarizeAgentToolActivity, } from "./render.js";
+import { appendAgentEventLog, appendAgentReasoningLog, appendAgentStatusLog } from "./logs.js";
+import { displayAgentEvent, emitVisibleAgentText, extractAgentReasoning, summarizeAgentToolActivity, } from "./render.js";
 import { classifyTerminalVisibleStatus, extractAgentFailureStatus, hasAgentStalled, } from "./status.js";
 const STOP_SIGNAL_GRACE_MS = 1500;
 export function spawnAgent(agent, dirPath, prompt, options = {}) {
     return new Promise((resolve) => {
-        const args = buildAgentArgs(agent, prompt, options.executionProfile);
+        const noiseFilters = getBuiltInProvider(agent.name)?.noiseFilters ?? [];
+        const prefs = loadAgentPrefs()[agent.name];
+        // The execution profile arrives already resolved (per-run override ∨ saved
+        // prefs) from `createLocalAgentExecutor`, so the CLI args built here use the
+        // SAME model/effort the session records via `buildRuntimeExecutorInfo` (F1).
+        // `prefs.env_vars` is still read below — env vars are a spawn concern, not
+        // part of the execution profile, so they are not pre-resolved.
+        const args = buildAgentArgs(agent, prompt, options.executionProfile ?? {});
         appendAgentEventLog(options.eventLogPath, {
             type: "spawn",
             command: agent.command,
@@ -19,9 +27,11 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
         console.log(chalk.dim(`  ${launchLine}`));
         appendAgentStatusLog(options.statusLogPath, launchLine);
         options.onStatus?.(launchLine);
+        const baseEnv = buildAgentEnv(agent);
+        const env = prefs?.env_vars ? { ...baseEnv, ...prefs.env_vars } : baseEnv;
         const proc = spawn(agent.command, args, {
             cwd: dirPath,
-            env: buildAgentEnv(agent),
+            env,
             stdio: ["ignore", "pipe", "pipe"],
         });
         const timeoutMs = options.executionProfile?.timeoutMs ?? null;
@@ -174,6 +184,12 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
                     if (toolActivity) {
                         lastToolActivity = toolActivity;
                     }
+                    // Tee reasoning/thinking spans the display path discards to the
+                    // reasoning transcript. Best-effort: the writer swallows errors and
+                    // events without reasoning yield nothing, so the run is never blocked.
+                    for (const span of extractAgentReasoning(event)) {
+                        appendAgentReasoningLog(options.reasoningLogPath, span);
+                    }
                     failureStatus ||= extractAgentFailureStatus(event);
                     if (displayAgentEvent(event, options.statusLogPath, lastVisibleText, options.onStatus)) {
                         sawVisibleEvent = true;
@@ -202,7 +218,7 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
                     type: "stderr",
                     line,
                 });
-                if (CODEX_NOISE_PATTERNS.some((pattern) => pattern.test(line)))
+                if (noiseFilters.some((pattern) => pattern.test(line)))
                     continue;
                 sawRawOutput = true;
                 lastVisibleOutputAt = Date.now();

package/dist/packages/{engine → runtime}/agents/lib/executors.d.ts

@@ -10,6 +10,7 @@ export interface AgentExecutionProfile {
 export interface AgentExecuteOptions {
     eventLogPath?: string | null;
     statusLogPath?: string | null;
+    reasoningLogPath?: string | null;
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
 }