u-foo 1.0.6 → 1.1.9

package/src/agent/ucodeBuild.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+const {
+  resolveNativeFallbackCommand,
+} = require("./ucode");
+
+function resolveCoreRoot({
+  env = process.env,
+  config = {},
+} = {}) {
+  void env;
+  void config;
+  const native = resolveNativeFallbackCommand();
+  return native.root || path.resolve(__dirname, "..", "code");
+}
+
+function inspectUcodeBuildSetup({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const coreRoot = resolveCoreRoot({ env, config });
+  const native = resolveNativeFallbackCommand();
+  const workspaceRoot = root;
+  const distCliPath = Array.isArray(native.args) && native.args[0] ? path.resolve(native.args[0]) : "";
+  const distCliExists = Boolean(distCliPath && fs.existsSync(distCliPath));
+  const nodeModulesPath = "";
+  return {
+    projectRoot: root,
+    coreRoot,
+    workspaceRoot,
+    distCliPath,
+    distCliExists,
+    nodeModulesPath,
+    nodeModulesExists: Boolean(nodeModulesPath && fs.existsSync(nodeModulesPath)),
+  };
+}
+
+function buildUcodeCore({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+  installIfMissing = true,
+  stdio = "inherit",
+} = {}) {
+  const before = inspectUcodeBuildSetup({
+    projectRoot,
+    env,
+    loadConfigImpl,
+  });
+  void installIfMissing;
+  void stdio;
+  void env;
+  if (!before.distCliExists) {
+    throw new Error(`ucode native core entry missing: ${before.distCliPath || "(unknown)"}`);
+  }
+  return { ...before, steps: ["native-check"] };
+}
+
+module.exports = {
+  inspectUcodeBuildSetup,
+  buildUcodeCore,
+  resolveCoreRoot,
+};

package/src/agent/ucodeDoctor.js

@@ -0,0 +1,184 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+const {
+  resolveNativeFallbackCommand,
+  defaultBundledPromptFile,
+} = require("./ucode");
+const { inspectUcodeBuildSetup } = require("./ucodeBuild");
+const { inspectUcodeRuntimeConfig } = require("./ucodeRuntimeConfig");
+const { prepareUcodeBootstrap } = require("./ucodeBootstrap");
+
+function inspectUcodeSetup({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+  resolveNativeImpl = resolveNativeFallbackCommand,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const native = resolveNativeImpl({ env, config, cwd: root });
+  const coreAvailable = Boolean(native && native.available !== false && native.command);
+  const core = native ? {
+    root: native.root || path.resolve(__dirname, "..", "code"),
+    command: native.command,
+    args: native.args || [],
+    available: coreAvailable,
+    missingReason: String(native.missingReason || "").trim(),
+    resolvedPath: String(native.resolvedPath || "").trim(),
+  } : null;
+  const promptFile = String(
+    env.UFOO_UCODE_PROMPT_FILE
+      || config.ucodePromptFile
+      || defaultBundledPromptFile()
+  ).trim();
+  const bootstrapFile = String(
+    env.UFOO_UCODE_BOOTSTRAP_FILE
+      || config.ucodeBootstrapFile
+      || path.join(root, ".ufoo", "agent", "ucode", "bootstrap.md")
+  ).trim();
+  const build = inspectUcodeBuildSetup({
+    projectRoot: root,
+    env,
+    loadConfigImpl,
+  });
+  const runtime = inspectUcodeRuntimeConfig({
+    projectRoot: root,
+    env,
+    loadConfigImpl,
+  });
+  let importMeta = null;
+  if (core && core.root) {
+    const candidates = [
+      path.join(core.root, ".ufoo-import.json"),
+      path.join(core.root, "..", ".ufoo-import.json"),
+      path.join(core.root, "..", "..", ".ufoo-import.json"),
+      path.join(core.root, "..", "..", "..", ".ufoo-import.json"),
+    ].map((item) => path.resolve(item));
+    for (const candidate of candidates) {
+      try {
+        if (!fs.existsSync(candidate)) continue;
+        const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        if (parsed && typeof parsed === "object") {
+          importMeta = {
+            file: candidate,
+            importedAt: String(parsed.imported_at || "").trim(),
+            upstreamCommit: String(parsed.upstream_commit || "").trim(),
+            upstreamBranch: String(parsed.upstream_branch || "").trim(),
+            upstreamRemote: String(parsed.upstream_remote || "").trim(),
+          };
+          break;
+        }
+      } catch {
+        // ignore malformed metadata
+      }
+    }
+  }
+
+  return {
+    projectRoot: root,
+    expectedBundledCoreRoot: core ? core.root : "",
+    core: {
+      found: Boolean(core && core.available),
+      root: core ? core.root : "",
+      command: core ? core.command : "",
+      args: core ? core.args : [],
+      available: Boolean(core && core.available),
+      missingReason: core ? core.missingReason : "",
+      resolvedPath: core ? core.resolvedPath : "",
+    },
+    promptFile,
+    promptExists: Boolean(promptFile && fs.existsSync(promptFile)),
+    bootstrapFile,
+    build,
+    runtime,
+    importMeta,
+    configuredCommand: String(
+      env.UFOO_UCODE_CMD
+        || env.UFOO_UFOO_CODE_CMD
+        || config.ucodeCommand
+        || config.ufooCodeCommand
+        || ""
+    ).trim(),
+  };
+}
+
+function formatUcodeDoctor(result = {}) {
+  const lines = [];
+  lines.push("=== ucode doctor ===");
+  lines.push(`project: ${result.projectRoot || process.cwd()}`);
+  lines.push(`core: ${result.core && result.core.found ? "ready" : "missing"}`);
+  if (result.core && result.core.found) {
+    lines.push(`  root: ${result.core.root}`);
+    lines.push(`  launch: ${result.core.command} ${(result.core.args || []).join(" ")}`.trim());
+    if (result.core.resolvedPath) {
+      lines.push(`  resolved path: ${result.core.resolvedPath}`);
+    }
+  } else {
+    if (result.expectedBundledCoreRoot) {
+      lines.push(`  expected bundled root: ${result.expectedBundledCoreRoot}`);
+    }
+    if (result.core && result.core.command) {
+      lines.push(`  attempted launch: ${result.core.command} ${(result.core.args || []).join(" ")}`.trim());
+    }
+    if (result.core && result.core.missingReason) {
+      lines.push(`  missing reason: ${result.core.missingReason}`);
+    } else {
+      lines.push("  missing reason: native executable is unavailable");
+    }
+  }
+  if (result.configuredCommand) {
+    lines.push(`configured command override (ignored in native-only mode): ${result.configuredCommand}`);
+  }
+  lines.push(`prompt: ${result.promptFile || "(none)"}${result.promptExists ? "" : " (missing)"}`);
+  lines.push(`bootstrap: ${result.bootstrapFile || "(none)"}`);
+  if (result.build && result.build.coreRoot) {
+    lines.push(`build: ${result.build.distCliExists ? "ready" : "missing dist"}`);
+    lines.push(`  core root: ${result.build.coreRoot}`);
+    lines.push(`  workspace root: ${result.build.workspaceRoot || "(none)"}`);
+    lines.push(`  dist entry: ${result.build.distCliPath || "(none)"}${result.build.distCliExists ? "" : " (missing)"}`);
+  } else {
+    lines.push("build: unresolved core root");
+  }
+  if (result.importMeta) {
+    lines.push(`import metadata: ${result.importMeta.file || "(unknown)"}`);
+    lines.push(`  imported at: ${result.importMeta.importedAt || "(unknown)"}`);
+    lines.push(`  upstream commit: ${result.importMeta.upstreamCommit || "(unknown)"}`);
+    lines.push(`  upstream branch: ${result.importMeta.upstreamBranch || "(unknown)"}`);
+    lines.push(`  upstream remote: ${result.importMeta.upstreamRemote ? "(set)" : "(unset)"}`);
+  }
+  if (result.runtime) {
+    lines.push(`runtime: ${result.runtime.agentDir || "(none)"}`);
+    lines.push(`  provider: ${result.runtime.provider || "(unset)"}`);
+    lines.push(`  model: ${result.runtime.model || "(unset)"}`);
+    lines.push(`  base url: ${result.runtime.baseUrl ? "(set)" : "(unset)"}`);
+    lines.push(`  api key: ${result.runtime.apiKey ? "(set)" : "(unset)"}`);
+  }
+  if (!(result.core && result.core.found) && !result.configuredCommand) {
+    lines.push("hint: verify native entry exists at src/code/agent.js");
+  }
+  return lines.join("\n");
+}
+
+function prepareAndInspectUcode({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const inspection = inspectUcodeSetup({ projectRoot, env, loadConfigImpl });
+  const prepared = prepareUcodeBootstrap({
+    projectRoot: inspection.projectRoot,
+    promptFile: inspection.promptFile,
+    targetFile: inspection.bootstrapFile,
+  });
+  return {
+    ...inspection,
+    bootstrapPrepared: prepared,
+  };
+}
+
+module.exports = {
+  inspectUcodeSetup,
+  formatUcodeDoctor,
+  prepareAndInspectUcode,
+};

package/src/agent/ucodeRuntimeConfig.js

@@ -0,0 +1,129 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("../config");
+
+function readJson(filePath = "", fallback = {}) {
+  if (!filePath) return fallback;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
+    return parsed;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath = "", data = {}) {
+  if (!filePath) return;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function resolveRuntimeValues({
+  env = process.env,
+  config = {},
+  projectRoot = process.cwd(),
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const provider = String(env.UFOO_UCODE_PROVIDER || config.ucodeProvider || "").trim();
+  const model = String(env.UFOO_UCODE_MODEL || config.ucodeModel || "").trim();
+  const apiKey = String(env.UFOO_UCODE_API_KEY || config.ucodeApiKey || "").trim();
+  const baseUrl = String(env.UFOO_UCODE_BASE_URL || config.ucodeBaseUrl || "").trim();
+  const agentDir = path.resolve(
+    String(
+      env.PI_CODING_AGENT_DIR
+        || env.UFOO_UCODE_AGENT_DIR
+        || config.ucodeAgentDir
+        || path.join(root, ".ufoo", "agent", "ucode", "pi-agent")
+    ).trim()
+  );
+  return {
+    projectRoot: root,
+    provider,
+    model,
+    apiKey,
+    baseUrl,
+    agentDir,
+  };
+}
+
+function inspectUcodeRuntimeConfig({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const root = path.resolve(projectRoot);
+  const config = loadConfigImpl(root);
+  const resolved = resolveRuntimeValues({
+    env,
+    config,
+    projectRoot: root,
+  });
+  const settingsFile = path.join(resolved.agentDir, "settings.json");
+  const authFile = path.join(resolved.agentDir, "auth.json");
+  const modelsFile = path.join(resolved.agentDir, "models.json");
+  return {
+    ...resolved,
+    settingsFile,
+    authFile,
+    modelsFile,
+    settingsExists: fs.existsSync(settingsFile),
+    authExists: fs.existsSync(authFile),
+    modelsExists: fs.existsSync(modelsFile),
+  };
+}
+
+function prepareUcodeRuntimeConfig({
+  projectRoot = process.cwd(),
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const inspection = inspectUcodeRuntimeConfig({
+    projectRoot,
+    env,
+    loadConfigImpl,
+  });
+
+  const settings = readJson(inspection.settingsFile, {});
+  if (inspection.provider) settings.defaultProvider = inspection.provider;
+  if (inspection.model) settings.defaultModel = inspection.model;
+  writeJson(inspection.settingsFile, settings);
+
+  if (inspection.provider && inspection.apiKey) {
+    const auth = readJson(inspection.authFile, {});
+    auth[inspection.provider] = {
+      type: "api_key",
+      key: inspection.apiKey,
+    };
+    writeJson(inspection.authFile, auth);
+  }
+
+  if (inspection.provider && inspection.baseUrl) {
+    const models = readJson(inspection.modelsFile, {});
+    if (!models.providers || typeof models.providers !== "object" || Array.isArray(models.providers)) {
+      models.providers = {};
+    }
+    const providerConfig = models.providers[inspection.provider];
+    const nextProviderConfig = (providerConfig && typeof providerConfig === "object" && !Array.isArray(providerConfig))
+      ? { ...providerConfig }
+      : {};
+    nextProviderConfig.baseUrl = inspection.baseUrl;
+    models.providers[inspection.provider] = nextProviderConfig;
+    writeJson(inspection.modelsFile, models);
+  }
+
+  return {
+    ...inspection,
+    env: {
+      PI_CODING_AGENT_DIR: inspection.agentDir,
+    },
+  };
+}
+
+module.exports = {
+  resolveRuntimeValues,
+  inspectUcodeRuntimeConfig,
+  prepareUcodeRuntimeConfig,
+};
+

package/src/agent/ufooAgent.js

@@ -75,16 +75,18 @@ function buildSystemPrompt(context) {
   const hasAgents = context.agents && context.agents.length > 0;
   const agentGuidance = hasAgents
     ? ""
-    : "\n- IMPORTANT: No agents are currently online. To execute tasks, you MUST launch agents using ops.launch.\n- Example: {\"reply\":\"Creating agent\",\"ops\":[{\"action\":\"launch\",\"agent\":\"claude\",\"count\":1}]}";
+    : "\n- IMPORTANT: No coding agents are currently online. For lightweight exploration or temporary command execution, prefer top-level assistant_call.\n- Use ops.launch only when persistent coding-agent sessions are necessary.";
 
   return [
     "You are ufoo-agent, a headless routing controller.",
+    "You can call a private execution helper via top-level assistant_call (not visible on bus).",
     "Return ONLY valid JSON. No extra text.",
     "Schema:",
     "{",
     '  "reply": "string",',
+    '  "assistant_call": {"kind":"explore|bash|mixed","task":"string","context":"optional","expect":"optional","provider":"codex|claude|ufoo (optional)","model":"optional","timeout_ms":60000},',
     '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string"}],',
-    '  "ops": [{"action":"launch|close|rename","agent":"codex|claude","count":1,"agent_id":"id","nickname":"optional"}],',
+    '  "ops": [{"action":"launch|close|rename|cron","agent":"codex|claude|ucode","count":1,"agent_id":"id","nickname":"optional","operation":"start|list|stop","every":"30m","interval_ms":1800000,"target":"agent-id|nickname|csv","targets":["agent-id"],"prompt":"message","id":"task-id|all"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',
     "}",
     "Rules:",
@@ -92,6 +94,13 @@ function buildSystemPrompt(context) {
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
     "- If user specifies a nickname for a new agent, include ops.launch with nickname so daemon can rename.",
     "- If user requests rename, use ops.rename with agent_id and nickname (do NOT launch).",
+    "- For scheduled follow-up (cron/corn), use ops.cron with operation=start and include every+target(s)+prompt.",
+    "- To check scheduled tasks, use ops.cron with operation=list.",
+    "- To stop scheduled tasks, use ops.cron with operation=stop and id (or id=all).",
+    "- Use top-level assistant_call for project exploration, temporary shell tasks, and quick execution support.",
+    "- assistant_call fields: kind (explore|bash|mixed), task (required), context/expect (optional), provider (codex|claude|ufoo, optional), model/timeout_ms (optional).",
+    "- Prefer assistant_call over launching coding agents when the task is short-lived.",
+    "- Legacy compatibility: if model emits ops.assistant_call, daemon will still process it.",
     "- If no action needed, return reply with empty dispatch/ops.",
     agentGuidance,
     "",

package/src/assistant/agent.js

@@ -0,0 +1,260 @@
+const fs = require("fs");
+const path = require("path");
+const { runCliAgent } = require("../agent/cliRunner");
+const { normalizeCliOutput } = require("../agent/normalizeOutput");
+const { resolveAssistantEngine, runExternalAssistantEngine } = require("./engine");
+const { getUfooPaths } = require("../ufoo/paths");
+
+const ASSISTANT_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    ok: { type: "boolean" },
+    summary: { type: "string" },
+    artifacts: {
+      type: "array",
+      items: { type: "string" },
+    },
+    logs: {
+      type: "array",
+      items: { type: "string" },
+    },
+    error: { type: "string" },
+    metrics: {
+      type: "object",
+      additionalProperties: true,
+    },
+  },
+  required: ["ok", "summary"],
+};
+
+function parseTaskPayload(payload = {}) {
+  const projectRoot = typeof payload.project_root === "string" ? payload.project_root : process.cwd();
+  const provider = typeof payload.provider === "string" ? payload.provider : "";
+  const fallbackProvider = typeof payload.fallback_provider === "string" ? payload.fallback_provider : "";
+  const model = typeof payload.model === "string" ? payload.model : "";
+  const task = typeof payload.task === "string" ? payload.task.trim() : "";
+  const kind = typeof payload.kind === "string" && payload.kind ? payload.kind : "mixed";
+  const context = typeof payload.context === "string" ? payload.context : "";
+  const expectText = typeof payload.expect === "string" ? payload.expect : "";
+  const timeoutMs = Number.isFinite(payload.timeout_ms) ? payload.timeout_ms : 60000;
+
+  return {
+    projectRoot,
+    provider,
+    fallbackProvider,
+    model,
+    task,
+    kind,
+    context,
+    expect: expectText,
+    timeoutMs,
+  };
+}
+
+function normalizeAssistantPayload(parsed, fallbackError = "") {
+  if (!parsed || typeof parsed !== "object") {
+    const text = String(parsed || "").trim();
+    if (text) {
+      return {
+        ok: true,
+        summary: text,
+        artifacts: [],
+        logs: [],
+        error: "",
+        metrics: {},
+      };
+    }
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: fallbackError || "assistant returned invalid payload",
+      metrics: {},
+    };
+  }
+
+  return {
+    ok: parsed.ok !== false,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+    logs: Array.isArray(parsed.logs) ? parsed.logs : [],
+    error: typeof parsed.error === "string" ? parsed.error : "",
+    metrics: parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {},
+  };
+}
+
+function buildAssistantSystemPrompt(taskInput) {
+  return [
+    "You are ufoo-assistant-agent, a private helper for ufoo-agent.",
+    "You are NOT exposed on the event bus.",
+    "Execute the requested task using local project context and shell/tool access as needed.",
+    "Return ONLY JSON that matches schema: {ok, summary, artifacts, logs, error, metrics}.",
+    "Rules:",
+    "- summary: concise factual result for ufoo-agent to consume.",
+    "- artifacts: key files/commands/findings (short strings).",
+    "- logs: optional concise trace points.",
+    "- error: non-empty only when ok=false.",
+    "- Do not include markdown or prose outside JSON.",
+    "",
+    "Task input:",
+    JSON.stringify(taskInput),
+  ].join("\n");
+}
+
+function getAssistantStatePaths(projectRoot) {
+  const dir = getUfooPaths(projectRoot).agentDir;
+  return {
+    sessionDir: path.join(dir, "sessions"),
+  };
+}
+
+function getAssistantSessionStateFile(projectRoot, engine = "assistant") {
+  const { sessionDir } = getAssistantStatePaths(projectRoot);
+  return path.join(sessionDir, `ufoo-assistant-${engine}.json`);
+}
+
+function loadAssistantState(projectRoot, engine = "assistant") {
+  const file = getAssistantSessionStateFile(projectRoot, engine);
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveAssistantState(projectRoot, engine = "assistant", state = {}) {
+  const { sessionDir } = getAssistantStatePaths(projectRoot);
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const file = getAssistantSessionStateFile(projectRoot, engine);
+  fs.writeFileSync(file, JSON.stringify(state, null, 2));
+}
+
+function isSessionError(errorText = "") {
+  const text = String(errorText || "").toLowerCase();
+  return text.includes("session id")
+    || text.includes("session-id")
+    || text.includes("already in use");
+}
+
+async function runAssistantAgentTask(payload = {}) {
+  const taskInput = parseTaskPayload(payload);
+  const startedAt = Date.now();
+
+  if (!taskInput.task) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: "missing task",
+      metrics: { duration_ms: Date.now() - startedAt },
+    };
+  }
+
+  const systemPrompt = buildAssistantSystemPrompt(taskInput);
+  const engine = resolveAssistantEngine({
+    projectRoot: taskInput.projectRoot,
+    requestedProvider: taskInput.provider,
+    requestedModel: taskInput.model,
+    fallbackProvider: taskInput.fallbackProvider,
+  });
+  const assistantState = loadAssistantState(taskInput.projectRoot, engine.engine);
+
+  let cliRes = null;
+  if (engine.kind === "external") {
+    cliRes = await runExternalAssistantEngine({
+      engine,
+      timeoutMs: taskInput.timeoutMs,
+      payload: {
+        request_type: "assistant_task",
+        schema_version: 1,
+        engine: engine.engine,
+        project_root: taskInput.projectRoot,
+        task: taskInput.task,
+        kind: taskInput.kind,
+        context: taskInput.context,
+        expect: taskInput.expect,
+        model: engine.model || "",
+        session_id: assistantState && typeof assistantState.sessionId === "string" ? assistantState.sessionId : "",
+        timeout_ms: taskInput.timeoutMs,
+      },
+    });
+  } else {
+    const runCli = async (sessionId) => runCliAgent({
+      provider: engine.provider,
+      model: engine.model,
+      prompt: taskInput.task,
+      systemPrompt,
+      jsonSchema: ASSISTANT_JSON_SCHEMA,
+      disableSession: false,
+      sessionId,
+      cwd: taskInput.projectRoot,
+      timeoutMs: taskInput.timeoutMs,
+      sandbox: taskInput.kind === "explore" ? "read-only" : "workspace-write",
+    });
+
+    const preferredSession = assistantState && typeof assistantState.sessionId === "string"
+      ? assistantState.sessionId
+      : undefined;
+    cliRes = await runCli(preferredSession);
+    if (!cliRes.ok && preferredSession && isSessionError(cliRes.error)) {
+      cliRes = await runCli(undefined);
+    }
+  }
+
+  if (!cliRes || cliRes.ok === false) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: (cliRes && cliRes.error) || "assistant cli failed",
+      metrics: { duration_ms: Date.now() - startedAt },
+    };
+  }
+
+  let result;
+  if (engine.kind === "external") {
+    result = normalizeAssistantPayload(cliRes);
+  } else {
+    const normalized = normalizeCliOutput(cliRes.output);
+    let parsed;
+    try {
+      parsed = JSON.parse(normalized);
+    } catch {
+      parsed = normalized;
+    }
+    result = normalizeAssistantPayload(parsed);
+  }
+
+  result.metrics = {
+    ...result.metrics,
+    duration_ms: Date.now() - startedAt,
+  };
+  if (!result.ok && !result.error) {
+    result.error = "assistant task failed";
+  }
+
+  saveAssistantState(taskInput.projectRoot, engine.engine, {
+    engine: engine.engine,
+    provider: engine.provider || "",
+    model: engine.model || "",
+    sessionId: cliRes && typeof cliRes.sessionId === "string" ? cliRes.sessionId : "",
+    updated_at: new Date().toISOString(),
+  });
+
+  return result;
+}
+
+module.exports = {
+  runAssistantAgentTask,
+  parseTaskPayload,
+  normalizeAssistantPayload,
+  buildAssistantSystemPrompt,
+  getAssistantSessionStateFile,
+  loadAssistantState,
+  saveAssistantState,
+  isSessionError,
+  ASSISTANT_JSON_SCHEMA,
+};