@interf/compiler 0.5.1 → 0.6.3

package/dist/packages/agents/lib/execution.js

@@ -0,0 +1,243 @@
+import { spawn } from "node:child_process";
+import chalk from "chalk";
+import { CODEX_NOISE_PATTERNS } from "./constants.js";
+import { buildAgentArgs, buildAgentEnv } from "./args.js";
+import { appendAgentEventLog, appendAgentStatusLog } from "./logs.js";
+import { displayAgentEvent, emitVisibleAgentText, 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);
+        appendAgentEventLog(options.eventLogPath, {
+            type: "spawn",
+            command: agent.command,
+            args,
+            cwd: dirPath,
+        });
+        const launchLine = `Launching ${agent.displayName}...`;
+        console.log(chalk.dim(`  ${launchLine}`));
+        appendAgentStatusLog(options.statusLogPath, launchLine);
+        const proc = spawn(agent.command, args, {
+            cwd: dirPath,
+            env: buildAgentEnv(agent),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const timeoutMs = options.executionProfile?.timeoutMs ?? null;
+        let buffer = "";
+        let stderrBuffer = "";
+        let lastVisibleOutputAt = Date.now();
+        let lastActivityAt = Date.now();
+        let lastHeartbeatAt = 0;
+        let sawRawOutput = false;
+        let sawVisibleEvent = false;
+        let timedOut = false;
+        let completionSatisfied = false;
+        let failureStatus = null;
+        let terminalSignalSent = false;
+        let lastToolActivity = null;
+        let stopPhase = "running";
+        let stopTimer = null;
+        const lastVisibleText = { current: null };
+        const clearStopTimer = () => {
+            if (!stopTimer)
+                return;
+            clearTimeout(stopTimer);
+            stopTimer = null;
+        };
+        const requestProcessStop = (signal = "SIGINT") => {
+            if (proc.exitCode != null)
+                return;
+            if (signal === "SIGINT") {
+                if (stopPhase !== "running")
+                    return;
+                stopPhase = "sigint";
+            }
+            else if (signal === "SIGTERM") {
+                if (stopPhase === "sigterm" || stopPhase === "sigkill")
+                    return;
+                stopPhase = "sigterm";
+            }
+            else if (signal === "SIGKILL") {
+                if (stopPhase === "sigkill")
+                    return;
+                stopPhase = "sigkill";
+            }
+            appendAgentEventLog(options.eventLogPath, {
+                type: "signal",
+                signal,
+            });
+            proc.kill(signal);
+            clearStopTimer();
+            if (signal === "SIGKILL")
+                return;
+            stopTimer = setTimeout(() => {
+                if (proc.exitCode != null)
+                    return;
+                requestProcessStop(signal === "SIGINT" ? "SIGTERM" : "SIGKILL");
+            }, STOP_SIGNAL_GRACE_MS);
+        };
+        const heartbeat = setInterval(() => {
+            const now = Date.now();
+            const minQuietMs = sawVisibleEvent ? 15000 : 8000;
+            const minHeartbeatGapMs = sawVisibleEvent ? 30000 : 12000;
+            if (now - lastVisibleOutputAt < minQuietMs)
+                return;
+            if (now - lastHeartbeatAt < minHeartbeatGapMs)
+                return;
+            lastHeartbeatAt = now;
+            const seconds = Math.floor((now - lastVisibleOutputAt) / 1000);
+            const activitySuffix = lastToolActivity ? ` while ${lastToolActivity}` : "";
+            const label = sawVisibleEvent
+                ? `${agent.displayName} is still running${activitySuffix}... (${seconds}s since last output)`
+                : sawRawOutput
+                    ? `${agent.displayName} is active${activitySuffix}, but has not emitted visible progress yet... (${seconds}s)`
+                    : `${agent.displayName} started, but has not emitted visible progress yet... (${seconds}s)`;
+            console.log(chalk.dim(`  ${label}`));
+            appendAgentStatusLog(options.statusLogPath, label);
+        }, 5000);
+        const forwardSignal = () => {
+            requestProcessStop("SIGINT");
+        };
+        const maybeInterruptAfterTerminalStatus = () => {
+            if (options.completionCheck)
+                return;
+            if (terminalSignalSent || !lastVisibleText.terminalStatus)
+                return;
+            terminalSignalSent = true;
+            appendAgentEventLog(options.eventLogPath, {
+                type: "terminal-status",
+                status: lastVisibleText.terminalStatus,
+            });
+            const terminalKind = classifyTerminalVisibleStatus(lastVisibleText.terminalStatus);
+            if (terminalKind === "done") {
+                completionSatisfied = true;
+            }
+            else if (terminalKind === "failure") {
+                failureStatus ||= lastVisibleText.terminalStatus;
+            }
+            requestProcessStop("SIGINT");
+        };
+        const timeout = typeof timeoutMs === "number" && timeoutMs > 0
+            ? setInterval(() => {
+                const now = Date.now();
+                const idleMs = now - lastActivityAt;
+                if (!hasAgentStalled(lastActivityAt, now, timeoutMs))
+                    return;
+                timedOut = true;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "stall-timeout",
+                    timeout_ms: timeoutMs,
+                    idle_ms: idleMs,
+                });
+                console.log(chalk.red(`  ${agent.displayName} stalled for ${Math.round(idleMs / 1000)}s without agent output.`));
+                requestProcessStop("SIGINT");
+            }, 2000)
+            : null;
+        const completionPoll = options.completionCheck
+            ? setInterval(() => {
+                if (timedOut || completionSatisfied)
+                    return;
+                try {
+                    if (!options.completionCheck?.())
+                        return;
+                    completionSatisfied = true;
+                    appendAgentEventLog(options.eventLogPath, {
+                        type: "completion-check-satisfied",
+                    });
+                    requestProcessStop("SIGINT");
+                }
+                catch {
+                    // Ignore completion check failures and let the agent continue.
+                }
+            }, 1000)
+            : null;
+        process.once("SIGINT", forwardSignal);
+        proc.stdout?.on("data", (chunk) => {
+            sawRawOutput = true;
+            lastActivityAt = Date.now();
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "stdout",
+                    line,
+                });
+                try {
+                    const event = JSON.parse(line);
+                    const toolActivity = summarizeAgentToolActivity(event);
+                    if (toolActivity) {
+                        lastToolActivity = toolActivity;
+                    }
+                    failureStatus ||= extractAgentFailureStatus(event);
+                    if (displayAgentEvent(event, options.statusLogPath, lastVisibleText)) {
+                        sawVisibleEvent = true;
+                        lastVisibleOutputAt = Date.now();
+                    }
+                    maybeInterruptAfterTerminalStatus();
+                }
+                catch {
+                    if (emitVisibleAgentText(line, options.statusLogPath, lastVisibleText)) {
+                        sawVisibleEvent = true;
+                        lastVisibleOutputAt = Date.now();
+                    }
+                    maybeInterruptAfterTerminalStatus();
+                }
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            lastActivityAt = Date.now();
+            stderrBuffer += chunk.toString();
+            const lines = stderrBuffer.split("\n");
+            stderrBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "stderr",
+                    line,
+                });
+                if (CODEX_NOISE_PATTERNS.some((pattern) => pattern.test(line)))
+                    continue;
+                sawRawOutput = true;
+                lastVisibleOutputAt = Date.now();
+                process.stderr.write(`${line}\n`);
+                sawVisibleEvent = true;
+            }
+        });
+        proc.on("close", (code) => {
+            clearInterval(heartbeat);
+            if (timeout)
+                clearInterval(timeout);
+            if (completionPoll)
+                clearInterval(completionPoll);
+            clearStopTimer();
+            process.removeListener("SIGINT", forwardSignal);
+            const finalCode = timedOut ? 124 : failureStatus ? 1 : completionSatisfied ? 0 : (code ?? 0);
+            appendAgentEventLog(options.eventLogPath, {
+                type: "close",
+                code: finalCode,
+                failure_status: failureStatus,
+            });
+            resolve(finalCode);
+        });
+        proc.on("error", () => {
+            clearInterval(heartbeat);
+            if (timeout)
+                clearInterval(timeout);
+            if (completionPoll)
+                clearInterval(completionPoll);
+            clearStopTimer();
+            process.removeListener("SIGINT", forwardSignal);
+            appendAgentEventLog(options.eventLogPath, {
+                type: "error",
+                message: `Failed to start ${agent.displayName}`,
+            });
+            console.log(chalk.red(`  Failed to start ${agent.displayName}.`));
+            resolve(1);
+        });
+    });
+}

package/dist/packages/agents/lib/executors.d.ts

@@ -0,0 +1,32 @@
+import type { RuntimeExecutorInfo } from "../../../lib/schema.js";
+import type { Agent } from "./types.js";
+export type WorkflowExecutorKind = "local-agent" | "connected-provider" | "managed";
+export interface WorkflowExecutionProfile {
+    model?: string | null;
+    effort?: string | null;
+    profile?: string | null;
+    timeoutMs?: number | null;
+}
+export interface WorkflowExecuteOptions {
+    eventLogPath?: string | null;
+    statusLogPath?: string | null;
+    completionCheck?: (() => boolean) | null;
+}
+export interface WorkflowExecutor {
+    kind: WorkflowExecutorKind;
+    name: string;
+    displayName: string;
+    command?: string | null;
+    executionProfile?: WorkflowExecutionProfile;
+    execute(rootPath: string, prompt: string, options?: WorkflowExecuteOptions): Promise<number>;
+}
+export type { RuntimeExecutorInfo } from "../../../lib/schema.js";
+export declare function buildRuntimeExecutorInfo(executor: WorkflowExecutor): RuntimeExecutorInfo;
+export declare function createLocalAgentExecutor(agent: Agent, executionProfile?: WorkflowExecutionProfile): WorkflowExecutor;
+export declare function resolveLocalExecutor(options?: {
+    preflight?: boolean;
+    executionProfile?: WorkflowExecutionProfile;
+}): {
+    executor: WorkflowExecutor | null;
+    error?: string;
+};

package/dist/packages/agents/lib/executors.js

@@ -0,0 +1,45 @@
+import { resolveAgent } from "./detection.js";
+import { spawnAgent } from "./execution.js";
+import { ensureAgentAutomatedRunReady } from "./preflight.js";
+export function buildRuntimeExecutorInfo(executor) {
+    return {
+        kind: executor.kind,
+        name: executor.name,
+        display_name: executor.displayName,
+        command: executor.command ?? null,
+        model: executor.executionProfile?.model ?? null,
+        effort: executor.executionProfile?.effort ?? null,
+        profile: executor.executionProfile?.profile ?? null,
+        timeout_ms: executor.executionProfile?.timeoutMs ?? null,
+    };
+}
+export function createLocalAgentExecutor(agent, executionProfile = {}) {
+    return {
+        kind: "local-agent",
+        name: agent.name,
+        displayName: agent.displayName,
+        command: agent.command,
+        executionProfile,
+        execute(rootPath, prompt, options) {
+            return spawnAgent(agent, rootPath, prompt, {
+                eventLogPath: options?.eventLogPath,
+                statusLogPath: options?.statusLogPath,
+                executionProfile,
+                completionCheck: options?.completionCheck,
+            });
+        },
+    };
+}
+export function resolveLocalExecutor(options = {}) {
+    const { agent, error } = resolveAgent();
+    if (!agent) {
+        return { executor: null, error };
+    }
+    if (options.preflight !== false) {
+        const readiness = ensureAgentAutomatedRunReady(agent);
+        if (!readiness.ok) {
+            return { executor: null, error: readiness.error };
+        }
+    }
+    return { executor: createLocalAgentExecutor(agent, options.executionProfile) };
+}

package/dist/packages/agents/lib/logs.d.ts

@@ -0,0 +1,2 @@
+export declare function appendAgentEventLog(eventLogPath: string | null | undefined, event: Record<string, unknown>): void;
+export declare function appendAgentStatusLog(statusLogPath: string | null | undefined, text: string): void;

package/dist/packages/agents/lib/logs.js

@@ -0,0 +1,17 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+export function appendAgentEventLog(eventLogPath, event) {
+    if (!eventLogPath)
+        return;
+    mkdirSync(dirname(eventLogPath), { recursive: true });
+    appendFileSync(eventLogPath, `${JSON.stringify({
+        timestamp: new Date().toISOString(),
+        ...event,
+    })}\n`);
+}
+export function appendAgentStatusLog(statusLogPath, text) {
+    if (!statusLogPath)
+        return;
+    mkdirSync(dirname(statusLogPath), { recursive: true });
+    appendFileSync(statusLogPath, `${new Date().toISOString()} ${text}\n`);
+}

package/dist/packages/agents/lib/preflight.d.ts

@@ -0,0 +1,7 @@
+import type { Agent, AgentAutomationReadiness, AgentPreflightOptions, AgentPreflightResult } from "./types.js";
+export declare function buildAgentPreflightPrompt(): string;
+export declare function runAgentPreflight(agent: Agent, options?: AgentPreflightOptions): AgentPreflightResult;
+export declare function ensureAgentAutomatedRunReady(agent: Agent, options?: {
+    force?: boolean;
+    runPreflight?: typeof runAgentPreflight;
+}): AgentAutomationReadiness;

package/dist/packages/agents/lib/preflight.js

@@ -0,0 +1,77 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CODEX_NOISE_PATTERNS } from "./constants.js";
+import { buildAgentArgs, buildAgentEnv } from "./args.js";
+const successfulPreflightAgents = new Set();
+export function buildAgentPreflightPrompt() {
+    return [
+        "Interf doctor preflight.",
+        'Reply with exactly one line: "DONE: Interf doctor ok".',
+        "Do not use tools.",
+        "Do not read files.",
+        "Do not write files.",
+    ].join(" ");
+}
+export function runAgentPreflight(agent, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 60000;
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const dirPath = mkdtempSync(join(tmpdir(), "interf-doctor-"));
+    try {
+        const result = spawnSyncImpl(agent.command, buildAgentArgs(agent, buildAgentPreflightPrompt()), {
+            cwd: dirPath,
+            encoding: "utf8",
+            env: buildAgentEnv(agent),
+            timeout: timeoutMs,
+        });
+        const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+        const stderr = sanitizeAgentStderr(typeof result.stderr === "string" ? result.stderr : "");
+        const timedOut = result.error?.name === "Error" && result.error.message.includes("timed out");
+        if (result.error) {
+            return {
+                ok: false,
+                code: typeof result.status === "number" ? result.status : null,
+                timedOut,
+                stdout,
+                stderr,
+                error: result.error.message,
+            };
+        }
+        return {
+            ok: result.status === 0,
+            code: typeof result.status === "number" ? result.status : null,
+            timedOut: false,
+            stdout,
+            stderr,
+            error: result.status === 0 ? null : `Exited with code ${result.status ?? "unknown"}`,
+        };
+    }
+    finally {
+        rmSync(dirPath, { recursive: true, force: true });
+    }
+}
+export function ensureAgentAutomatedRunReady(agent, options = {}) {
+    if (!options.force && successfulPreflightAgents.has(agent.name)) {
+        return { ok: true };
+    }
+    const runPreflight = options.runPreflight ?? runAgentPreflight;
+    const result = runPreflight(agent);
+    if (!result.ok) {
+        const details = [result.error, result.stderr].filter(Boolean).join(" ");
+        return {
+            ok: false,
+            error: `${agent.displayName} failed Interf executor preflight. Run \`interf doctor --live\` for details.${details ? ` ${details}` : ""}`,
+        };
+    }
+    successfulPreflightAgents.add(agent.name);
+    return { ok: true };
+}
+function sanitizeAgentStderr(stderr) {
+    return stderr
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .filter((line) => !CODEX_NOISE_PATTERNS.some((pattern) => pattern.test(line)))
+        .join("\n")
+        .trim();
+}

package/dist/packages/agents/lib/render.d.ts

@@ -0,0 +1,8 @@
+export interface VisibleTextState {
+    current: string | null;
+    terminated?: boolean;
+    terminalStatus?: string | null;
+}
+export declare function emitVisibleAgentText(text: string, statusLogPath: string | null | undefined, lastVisibleText?: VisibleTextState): boolean;
+export declare function displayAgentEvent(event: Record<string, unknown>, statusLogPath: string | null | undefined, lastVisibleText: VisibleTextState): boolean;
+export declare function summarizeAgentToolActivity(event: Record<string, unknown>): string | null;

package/dist/packages/agents/lib/render.js

@@ -0,0 +1,218 @@
+import { basename } from "node:path";
+import chalk from "chalk";
+import { SHOW_AGENT_TOOL_EVENTS, VISIBLE_STATUS_PREFIXES, } from "./constants.js";
+import { appendAgentStatusLog } from "./logs.js";
+export function emitVisibleAgentText(text, statusLogPath, lastVisibleText) {
+    if (lastVisibleText?.terminated) {
+        return false;
+    }
+    let displayed = false;
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => shouldDisplayAgentText(line));
+    for (const line of lines) {
+        if (lastVisibleText && lastVisibleText.current === line) {
+            continue;
+        }
+        console.log(chalk.dim(`  ${line}`));
+        appendAgentStatusLog(statusLogPath, line);
+        if (lastVisibleText) {
+            lastVisibleText.current = line;
+            if (isTerminalVisibleStatus(line)) {
+                lastVisibleText.terminated = true;
+                lastVisibleText.terminalStatus = line;
+            }
+        }
+        displayed = true;
+    }
+    return displayed;
+}
+export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
+    const type = event.type;
+    let displayed = false;
+    if (type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
+        const name = event.name ?? "unknown";
+        const input = event.input;
+        let detail = "";
+        if (input) {
+            const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+            if (path)
+                detail = chalk.dim(` ${path.slice(0, 80)}`);
+        }
+        console.log(chalk.blue(`  → ${name}`) + detail);
+        displayed = true;
+    }
+    if (type === "assistant") {
+        const msg = event.message;
+        const content = msg?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === "text" && block.text) {
+                    const text = block.text.trim();
+                    displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+                }
+                if (block.type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
+                    const name = block.name;
+                    const input = block.input;
+                    let detail = "";
+                    if (input) {
+                        const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+                        if (path)
+                            detail = chalk.dim(` ${path.slice(0, 80)}`);
+                    }
+                    console.log(chalk.blue(`  → ${name}`) + detail);
+                    displayed = true;
+                }
+            }
+        }
+    }
+    if (type === "item.started" || type === "item.completed") {
+        const item = event.item;
+        if (item) {
+            displayed = displayItemEvent(type, item, statusLogPath, lastVisibleText) || displayed;
+        }
+    }
+    if (type === "result") {
+        const result = event.result;
+        const subtype = event.subtype;
+        if (result && subtype !== "tool_result") {
+            const lines = result.split("\n");
+            for (const line of lines) {
+                displayed = emitVisibleAgentText(line, statusLogPath, lastVisibleText) || displayed;
+            }
+        }
+    }
+    const message = pickString(event.message) ??
+        pickString(event.text) ??
+        pickString(event.content) ??
+        pickString(event.output) ??
+        pickString(event.summary);
+    if (message && type !== "assistant" && type !== "result") {
+        const text = message.trim();
+        displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+    }
+    return displayed;
+}
+export function summarizeAgentToolActivity(event) {
+    const type = event.type;
+    if (type === "assistant") {
+        const message = event.message;
+        const content = message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === "tool_use") {
+                    return summarizeToolUse(block.name, block.input);
+                }
+            }
+        }
+    }
+    if (type === "item.started" || type === "item.completed") {
+        const item = event.item;
+        if (item?.type === "tool_use") {
+            return summarizeToolUse(item.name, item.input);
+        }
+    }
+    return null;
+}
+function pickString(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return null;
+    for (const entry of value) {
+        if (typeof entry === "string")
+            return entry;
+        if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
+            return entry.text;
+        }
+    }
+    return null;
+}
+function displayItemEvent(type, item, statusLogPath, lastVisibleText) {
+    const itemType = item.type;
+    if (itemType === "agent_message") {
+        const text = item.text?.trim();
+        return text ? emitVisibleAgentText(text, statusLogPath, lastVisibleText) : false;
+    }
+    if (itemType === "command_execution" && type === "item.completed") {
+        const output = item.aggregated_output?.trim();
+        if (output) {
+            return emitVisibleAgentText(output, statusLogPath, lastVisibleText);
+        }
+    }
+    if (!SHOW_AGENT_TOOL_EVENTS) {
+        return false;
+    }
+    const title = pickString(item.title) ?? pickString(item.name);
+    const input = item.input;
+    const detail = input ? describeInput(input) : "";
+    if (type === "item.started" && title) {
+        console.log(chalk.blue(`  → ${title}`) + detail);
+        return true;
+    }
+    if (type === "item.completed" && title) {
+        console.log(chalk.blue(`  → ${title}`) + detail);
+        return true;
+    }
+    return false;
+}
+function describeInput(input) {
+    const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+    return path ? chalk.dim(` ${path.slice(0, 80)}`) : "";
+}
+function summarizeToolUse(name, input) {
+    if (!name)
+        return null;
+    const target = summarizeToolTarget(input);
+    switch (name) {
+        case "Read":
+            return target ? `reading ${target}` : "reading compiled files";
+        case "Write":
+            return target ? `writing ${target}` : "writing compiled files";
+        case "Edit":
+            return target ? `editing ${target}` : "editing compiled files";
+        case "Glob":
+        case "Grep":
+            return target ? `${name.toLowerCase()} on ${target}` : `${name.toLowerCase()}ing compiled files`;
+        case "Bash":
+            return target ? `running ${target}` : "running a local helper";
+        default:
+            return target ? `${name} on ${target}` : name;
+    }
+}
+function summarizeToolTarget(input) {
+    if (!input)
+        return null;
+    const raw = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? input.notebook_path);
+    if (!raw || raw.length === 0)
+        return null;
+    if (raw.includes("\n")) {
+        const commandName = summarizeMultilineCommand(raw);
+        return commandName ? `${commandName} helper` : "a multi-line local helper";
+    }
+    return basename(raw);
+}
+function summarizeMultilineCommand(command) {
+    const lines = command
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"));
+    for (const line of lines) {
+        const token = line.split(/\s+/)[0];
+        if (!token)
+            continue;
+        if (token.includes("="))
+            continue;
+        return basename(token);
+    }
+    return null;
+}
+function shouldDisplayAgentText(text) {
+    if (text.length === 0 || text.length >= 300)
+        return false;
+    return VISIBLE_STATUS_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function isTerminalVisibleStatus(text) {
+    return text.startsWith("DONE:") || text.startsWith("BLOCKED:") || text.startsWith("ERROR:");
+}

package/dist/packages/agents/lib/schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const InterfUserConfigSchema: z.ZodObject<{
+    agent: z.ZodString;
+    agentCommand: z.ZodString;
+    skillsInstalled: z.ZodBoolean;
+    initialized: z.ZodString;
+}, z.core.$strip>;
+export type InterfUserConfig = z.infer<typeof InterfUserConfigSchema>;

package/dist/packages/agents/lib/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const InterfUserConfigSchema = z.object({
+    agent: z.string(),
+    agentCommand: z.string(),
+    skillsInstalled: z.boolean(),
+    initialized: z.string(),
+});