ework-daemon 0.4.26 → 0.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.4.26",
+  "version": "0.4.28",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",

package/src/config.ts

@@ -28,12 +28,20 @@ export const configSchema = z.object({
   }),
   opencode: z.object({
     binary: z.string().default("opencode"),
-    baseWorkdir: z.string(),
+    baseWorkdir: z.string().default(
+      `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/ework-aio/opencode-workdir`
+    ),
     dbPath: z.string().default(
       `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`
     ),
     defaultModel: z.string().default(""),
   }),
+  pi: z.object({
+    binary: z.string().default("pi"),
+    provider: z.string().default("bailian"),
+    defaultModel: z.string().default(""),
+  }).optional(),
+  runtime: z.enum(["opencode", "pi"]).default("opencode"),
   work: z.object({
     capacity: z.coerce.number().int().positive().default(4),
     maxConcurrent: z.coerce.number().int().positive().default(4),
@@ -138,6 +146,12 @@ export function loadConfig(): Config {
         dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
         defaultModel: process.env.WORK_DEFAULT_MODEL ?? TEST_DEFAULTS.opencode.defaultModel,
       },
+      pi: {
+        binary: process.env.WORK_PI_BINARY ?? "pi",
+        provider: process.env.WORK_PI_PROVIDER ?? "bailian",
+        defaultModel: process.env.WORK_PI_DEFAULT_MODEL ?? process.env.WORK_DEFAULT_MODEL ?? "",
+      },
+      runtime: (process.env.WORK_RUNTIME ?? "opencode").trim().toLowerCase() as "opencode" | "pi",
       work: readWorkSection(),
       db: readDbSection(TEST_DEFAULTS.db.path),
       completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
@@ -175,6 +189,12 @@ export function loadConfig(): Config {
       dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
       defaultModel: process.env.WORK_DEFAULT_MODEL ?? "",
     },
+    pi: {
+      binary: process.env.WORK_PI_BINARY ?? "pi",
+      provider: process.env.WORK_PI_PROVIDER ?? "bailian",
+      defaultModel: process.env.WORK_PI_DEFAULT_MODEL ?? process.env.WORK_DEFAULT_MODEL ?? "",
+    },
+    runtime: (process.env.WORK_RUNTIME ?? "opencode").trim().toLowerCase() as "opencode" | "pi",
     work: readWorkSection(),
     db: readDbSection(PRODUCTION_DB_DEFAULT),
     completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {

package/src/op.ts

@@ -230,25 +230,27 @@ export class Store {
     const existing = rowToSession(row);
     const updated = { ...existing, ...patch };
 
+    const sets: string[] = [];
+    const vals: (string | number | null)[] = [];
+    if (updated.state !== undefined) { sets.push("state = ?"); vals.push(updated.state); }
+    if (updated.opencodeSessionId !== undefined) { sets.push("opencode_session_id = ?"); vals.push(updated.opencodeSessionId ?? null); }
+    if (updated.opencodePid !== undefined) { sets.push("opencode_pid = ?"); vals.push(updated.opencodePid ?? null); }
+    if (updated.workdir !== undefined) { sets.push("workdir = ?"); vals.push(updated.workdir ?? null); }
+    if (updated.startedAt !== undefined) { sets.push("started_at = ?"); vals.push(updated.startedAt ?? null); }
+    if (updated.progressCommentId !== undefined) { sets.push("progress_comment_id = ?"); vals.push(updated.progressCommentId ?? null); }
+    if (updated.reactionCommentId !== undefined) { sets.push("reaction_comment_id = ?"); vals.push(updated.reactionCommentId ?? null); }
+    if (updated.currentPrompt !== undefined) { sets.push("current_prompt = ?"); vals.push(updated.currentPrompt ?? null); }
+    if (updated.lastOutputAt !== undefined) { sets.push("last_output_at = ?"); vals.push(updated.lastOutputAt != null ? new Date(updated.lastOutputAt).toISOString() : null); }
+    if (updated.nudgeRounds !== undefined) { sets.push("nudge_rounds = ?"); vals.push(updated.nudgeRounds); }
+    if (updated.stuckNudgeRounds !== undefined) { sets.push("stuck_nudge_rounds = ?"); vals.push(updated.stuckNudgeRounds); }
+    if (updated.generation !== undefined) { sets.push("generation = ?"); vals.push(updated.generation); }
+
+    if (sets.length === 0) return updated;
+
+    vals.push(id);
     await getDB().run(
-      `UPDATE {{op_sessions}} SET state = ?, opencode_session_id = ?, opencode_pid = ?, workdir = ?,
-       started_at = ?, progress_comment_id = ?, reaction_comment_id = ?, current_prompt = ?,
-       last_output_at = ?, nudge_rounds = ?, stuck_nudge_rounds = ?, generation = ? WHERE uid = ?`,
-      [
-        updated.state,
-        updated.opencodeSessionId ?? null,
-        updated.opencodePid ?? null,
-        updated.workdir ?? null,
-        updated.startedAt ?? null,
-        updated.progressCommentId ?? null,
-        updated.reactionCommentId ?? null,
-        updated.currentPrompt ?? null,
-        updated.lastOutputAt != null ? new Date(updated.lastOutputAt).toISOString() : null,
-        updated.nudgeRounds ?? 0,
-        updated.stuckNudgeRounds ?? 0,
-        updated.generation ?? 0,
-        id,
-      ]
+      `UPDATE {{op_sessions}} SET ${sets.join(", ")} WHERE uid = ?`,
+      vals
     );
     return updated;
   }

package/src/opencode.ts

@@ -1,4 +1,3 @@
-import { spawn, type Subprocess } from "bun";
 import { Database } from "bun:sqlite";
 import { mkdirSync, writeFileSync, readdirSync, existsSync } from "fs";
 import { join, resolve, isAbsolute } from "path";
@@ -8,6 +7,9 @@ import type { Config } from "./config";
 import type { Store } from "./op";
 import type { IssueTracker, TrackerRef, TrackerEvent, TrackerComment, Issue, OpSession, Message } from "./trackers/types";
 import { formatKey, parseKey } from "./trackers/types";
+import type { RuntimeBackend, RuntimeHandle } from "./runtime/types";
+import { OpencodeBackend } from "./runtime/opencode-backend";
+import { PiBackend } from "./runtime/pi-backend";
 
 // ─── Types ───
 
@@ -278,10 +280,16 @@ export function pickLastActive(sessions: OpSession[]): OpSession | undefined {
 // ─── Engine ───
 
 export interface EngineOptions {
-  /** DB-allocated logical daemon id (from Store.registerDaemon). */
   daemonId: number;
-  /** Workdir + session-resume strategy; defaults to RecloneStrategy. */
   takeover?: TakeoverStrategy;
+  backend?: RuntimeBackend;
+}
+
+function createDefaultBackend(cfg: Config): RuntimeBackend {
+  if (cfg.runtime === "pi" && cfg.pi) {
+    return new PiBackend(cfg.pi.binary, cfg.pi.provider, cfg.pi.defaultModel, cfg.childEnvDeny);
+  }
+  return new OpencodeBackend(cfg.opencode.binary, cfg.opencode.dbPath, cfg.childEnvDeny);
 }
 
 export class Engine {
@@ -290,10 +298,11 @@ export class Engine {
   private trackers: TrackerRegistry;
   private readonly daemonId: number;
   private readonly takeover: TakeoverStrategy;
+  private readonly backend: RuntimeBackend;
   private heartbeatTimer?: ReturnType<typeof setInterval>;
 
   // Runtime state keyed by session key (trackerType:scopeKey#issueId@sessionName)
-  private processes = new Map<string, Subprocess<"ignore", "pipe", "pipe">>();
+  private processes = new Map<string, RuntimeHandle>();
   private running = new Set<string>();
   private stopping = new Set<string>();
   private processingComments = new Set<string>();
@@ -338,6 +347,7 @@ export class Engine {
     this.trackers = trackers;
     this.daemonId = opts.daemonId;
     this.takeover = opts.takeover ?? new RecloneStrategy(cfg);
+    this.backend = opts.backend ?? createDefaultBackend(cfg);
     this.startGlobalObserver();
     void this.recover();
   }
@@ -545,10 +555,6 @@ export class Engine {
     return [...comments].reverse().find(c => tracker.isBotUser(c.author) && !this.isSystemComment(c));
   }
 
-  private async checkSessionOutput(opencodeSessionId: string | undefined): Promise<{ hasOutput: boolean; tokenCount: number }> {
-    return checkSessionOutput(this.cfg.opencode.dbPath, opencodeSessionId);
-  }
-
   // ─── Event Dispatch ───
 
   async handleEvent(event: TrackerEvent, groupConfig?: GroupConfig) {
@@ -966,129 +972,69 @@ export class Engine {
     const ref = this.sessionToRef(session, issue);
     const tracker = this.getTracker(issue.trackerType);
 
-    const args = [this.cfg.opencode.binary, "run", "--format", "json", "--dir", workdir];
-    // Prefer the captured session id (resume our own previous run). Otherwise
-    // ask the takeover strategy whether a resumable session exists elsewhere
-    // (e.g. NAS-backed). Default strategy returns null → fresh session.
     let resumeSessionId = session.opencodeSessionId;
     if (!resumeSessionId) {
       const fromStrategy = await this.takeover.resumeOpenCodeSession(session);
       if (fromStrategy) resumeSessionId = fromStrategy;
     }
-    if (resumeSessionId && !(await opencodeSessionExists(this.cfg.opencode.dbPath, resumeSessionId))) {
-      log.warn(`stale opencode session ${resumeSessionId} not found in db, starting fresh`);
+    if (resumeSessionId && !(await this.backend.sessionExists(resumeSessionId))) {
+      log.warn(`stale session ${resumeSessionId} not found in db, starting fresh`);
       resumeSessionId = undefined;
       await this.store.updateSession(session.id, { opencodeSessionId: undefined });
     }
-    if (resumeSessionId) {
-      args.push("--session", resumeSessionId);
-    }
-    // Resolve the model: explicit per-message > daemon default > omit.
-    // Without this, opencode's own default (influenced by plugin agent
-    // presets) can pick a non-existent model, causing ProviderModelNotFoundError.
-    const model = msg.model || this.cfg.opencode.defaultModel;
+
+    const model = msg.model || (this.cfg.runtime === "pi" && this.cfg.pi ? this.cfg.pi.defaultModel : this.cfg.opencode.defaultModel);
     this.currentModel.set(k, model);
-    if (model) {
-      args.push("--model", model);
-    }
-    args.push(msg.content);
 
-    // Set eyes reaction on the source comment
     if (msg.sourceCommentId) {
-      try {
-        await tracker.setReaction(ref, msg.sourceCommentId, "eyes");
-      } catch { /* non-critical */ }
+      try { await tracker.setReaction(ref, msg.sourceCommentId, "eyes"); } catch { /* non-critical */ }
     }
 
-    let exitCode: number | null = null;
-
-    // M-1: build the child env explicitly. When a model IS resolved we push
-    // --model above, so opencode ignores OPENCODE_MODEL anyway. When NO model
-    // is resolved we must not let a leaked OPENCODE_MODEL from our own env
-    // silently win — strip it so opencode falls back to its opencode.json
-    // (the operator's explicit config) instead of arbitrary env pollution.
-    // Provider keys / Gitea vars are preserved (opencode + its plugin need
-    // them); only the explicit model-override var is neutralized.
     const childEnv = { ...process.env, ...this.hookEnvFor(issue, session, workdir) };
-    if (!model) delete childEnv.OPENCODE_MODEL;
-    delete childEnv.OPENCODE;
-    delete childEnv.OPENCODE_PID;
-    delete childEnv.OPENCODE_RUN_ID;
-    delete childEnv.OPENCODE_PROCESS_ROLE;
-    for (const k of this.cfg.childEnvDeny) delete childEnv[k];
+
+    let exitCode: number | null = null;
 
     try {
-      const proc = spawn({
-        cmd: args,
-        cwd: workdir,
-        env: childEnv,
-        stdout: "pipe",
-        stderr: "pipe",
-        stdin: "ignore",
-      });
+      const handle = await this.backend.spawn(
+        {
+          workdir,
+          prompt: msg.content,
+          model: model || undefined,
+          resumeSessionId: resumeSessionId || undefined,
+          env: childEnv,
+        },
+        {
+          onOutput: () => { this.lastOutputAt.set(k, Date.now()); },
+          onSessionId: async (id: string) => {
+            if (!session.opencodeSessionId) {
+              await this.store.updateSession(session.id, { opencodeSessionId: id });
+              session.opencodeSessionId = id;
+              log.info(`engine: captured sessionID=${id.slice(0, 8)} for ${k} (early persist)`);
+            }
+          },
+        },
+      );
 
       if (this.generation.get(k) !== gen) {
-        log.warn(`engine: spawned pid=${proc.pid} but generation superseded — killing orphan for ${k}`);
-        try { this.killProcessTree(proc.pid); } catch { /* already dead */ }
+        log.warn(`engine: spawned pid=${handle.pid} but generation superseded — killing orphan for ${k}`);
+        try { this.killProcessTree(handle.pid); } catch { /* already dead */ }
         return;
       }
 
-      this.processes.set(k, proc);
+      this.processes.set(k, handle);
       this.lastOutputAt.set(k, Date.now());
-      if (!this.startedAt.has(k)) {
-        this.startedAt.set(k, Date.now());
-      }
+      if (!this.startedAt.has(k)) this.startedAt.set(k, Date.now());
       this.currentPrompt.set(k, msg.content);
 
-      // Persist PID for crash recovery
-      await this.store.updateSession(session.id, { opencodePid: proc.pid });
+      await this.store.updateSession(session.id, { opencodePid: handle.pid });
       await this.persistRuntimeState(session.id);
 
-      log.info(`engine: spawned pid=${proc.pid} for ${k}`);
-
-      // Read stdout to capture session ID
-      let opencodeSessionId: string | null = null;
-      const stderrPromise = new Response(proc.stderr).text();
-      const reader = proc.stdout.getReader();
-      const decoder = new TextDecoder();
-      let lineBuf = "";
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        this.lastOutputAt.set(k, Date.now());
-
-        if (!opencodeSessionId) {
-          lineBuf += decoder.decode(value, { stream: true });
-          const lines = lineBuf.split("\n");
-          lineBuf = lines.pop()!;
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            try {
-              const ev = JSON.parse(line);
-              if (ev.sessionID) {
-                const sid: string = ev.sessionID;
-                opencodeSessionId = sid;
-                // Persist now, not at exit: a preempt/crash before exit must
-                // not lose the ID, otherwise the re-run opens a fresh session.
-                if (!session.opencodeSessionId) {
-                  await this.store.updateSession(session.id, { opencodeSessionId: sid });
-                  session.opencodeSessionId = sid;
-                  log.info(`engine: captured sessionID=${sid.slice(0, 8)} for ${k} (early persist)`);
-                }
-                break;
-              }
-            } catch { /* not json */ }
-          }
-        }
-      }
+      log.info(`engine: spawned pid=${handle.pid} for ${k} (backend=${this.backend.name})`);
 
-      exitCode = await proc.exited;
-      const stderr = await stderrPromise;
+      exitCode = await handle.exited;
+      const stderr = await handle.stderrText;
 
-      // Detect preemption or force-stop: if our process is no longer in the map, another took over
-      if (this.processes.get(k) !== proc) {
+      if (this.processes.get(k) !== handle) {
         log.info(`engine: process replaced, skipping finishRun for ${k}`);
         this.stopping.delete(k);
         return;
@@ -1099,20 +1045,15 @@ export class Engine {
       await this.store.updateSession(session.id, { opencodePid: undefined });
 
       if (exitCode !== 0) {
-        log.error(`engine: pid=${proc.pid} exited ${exitCode} for ${k}`);
+        log.error(`engine: pid=${handle.pid} exited ${exitCode} for ${k}`);
         log.error(`  stderr: ${stderr.slice(0, 2000)}`);
         await this.store.updateMessageStatus(msg.id, "failed", `exit ${exitCode}: ${stderr.slice(0, 500)}`);
       } else {
-        log.info(`engine: pid=${proc.pid} completed for ${k}`);
-        if (stderr) log.warn(`engine: pid=${proc.pid} stderr on exit 0: ${stderr.slice(0, 500)}`);
-        if (!opencodeSessionId) log.warn(`engine: pid=${proc.pid} produced NO sessionID (no stdout output)`);
+        log.info(`engine: pid=${handle.pid} completed for ${k}`);
+        if (stderr) log.warn(`engine: pid=${handle.pid} stderr on exit 0: ${stderr.slice(0, 500)}`);
+        if (!session.opencodeSessionId) log.warn(`engine: pid=${handle.pid} produced NO sessionID (no stdout output)`);
         await this.store.updateMessageStatus(msg.id, "done");
       }
-
-      // Save opencode session ID for continuity
-      if (opencodeSessionId && !session.opencodeSessionId) {
-        await this.store.updateSession(session.id, { opencodeSessionId });
-      }
     } catch (err) {
       log.error(`engine: exec failed for ${k}:`, err);
       await this.store.updateMessageStatus(msg.id, "failed", (err as Error).message);
@@ -1198,7 +1139,7 @@ export class Engine {
       await this.persistRuntimeState(session.id);
       void tracker.updateStatus(ref, "");
     } else {
-      const sessionOutput = await this.checkSessionOutput(session.opencodeSessionId);
+      const sessionOutput = await this.backend.getSessionOutputTokens(session.opencodeSessionId);
       const emptyRound = this.emptyResponseRounds.get(k) ?? 0;
 
       if (!sessionOutput.hasOutput && emptyRound < Engine.MAX_EMPTY_RESPONSE_ROUNDS) {

package/src/runtime/opencode-backend.ts

@@ -0,0 +1,129 @@
+import { spawn } from "bun";
+import { Database } from "bun:sqlite";
+import { log } from "../logger";
+import type {
+  RuntimeBackend,
+  RuntimeSpawnOpts,
+  RuntimeSpawnCallbacks,
+  RuntimeHandle,
+  SessionOutputResult,
+} from "./types";
+
+const ENV_DENY_ALWAYS = ["OPENCODE", "OPENCODE_PID", "OPENCODE_RUN_ID", "OPENCODE_PROCESS_ROLE"] as const;
+
+export class OpencodeBackend implements RuntimeBackend {
+  readonly name = "opencode";
+
+  constructor(
+    private binary: string,
+    private dbPath: string,
+    private childEnvDeny: string[] = [],
+  ) {}
+
+  async spawn(opts: RuntimeSpawnOpts, cb: RuntimeSpawnCallbacks): Promise<RuntimeHandle> {
+    const args = [this.binary, "run", "--format", "json", "--dir", opts.workdir];
+
+    if (opts.resumeSessionId) {
+      args.push("--session", opts.resumeSessionId);
+    }
+    if (opts.model) {
+      args.push("--model", opts.model);
+    }
+    args.push(opts.prompt);
+
+    const childEnv = { ...opts.env };
+    if (!opts.model) delete childEnv.OPENCODE_MODEL;
+    for (const key of ENV_DENY_ALWAYS) delete childEnv[key];
+    for (const key of this.childEnvDeny) delete childEnv[key];
+
+    const proc = spawn({
+      cmd: args,
+      cwd: opts.workdir,
+      env: childEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+
+    const stderrText = new Response(proc.stderr).text();
+
+    void this.readStdout(proc, cb);
+
+    return { pid: proc.pid, exited: proc.exited, stderrText };
+  }
+
+  private async readStdout(
+    proc: ReturnType<typeof spawn>,
+    cb: RuntimeSpawnCallbacks,
+  ): Promise<void> {
+    let captured = false;
+    const stdout = proc.stdout;
+    if (!stdout || typeof stdout === "number") return;
+    const reader = stdout.getReader();
+    const decoder = new TextDecoder();
+    let lineBuf = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      cb.onOutput();
+
+      if (!captured) {
+        lineBuf += decoder.decode(value, { stream: true });
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop()!;
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const ev = JSON.parse(line);
+            if (ev.sessionID) {
+              await cb.onSessionId(ev.sessionID as string);
+              captured = true;
+              break;
+            }
+          } catch { /* not json */ }
+        }
+      }
+    }
+  }
+
+  async sessionExists(sessionId: string): Promise<boolean> {
+    let db: Database;
+    try {
+      db = new Database(this.dbPath, { readonly: true });
+    } catch {
+      return false;
+    }
+    try {
+      const row = db.prepare("SELECT 1 FROM session WHERE id = ? LIMIT 1").get(sessionId);
+      return !!row;
+    } catch {
+      return false;
+    } finally {
+      db.close();
+    }
+  }
+
+  async getSessionOutputTokens(sessionId: string | undefined): Promise<SessionOutputResult> {
+    if (!sessionId) return { hasOutput: true, tokenCount: 0 };
+    let db: Database;
+    try {
+      db = new Database(this.dbPath, { readonly: true });
+    } catch {
+      return { hasOutput: true, tokenCount: 0 };
+    }
+    try {
+      const row = db.prepare(
+        "SELECT COUNT(*) AS n, COALESCE(SUM(CAST(json_extract(data,'$.tokens.output') AS INT)), 0) AS tokens " +
+        "FROM message WHERE session_id = ? AND json_extract(data,'$.role') = 'assistant'"
+      ).get(sessionId) as { n: number; tokens: number } | null;
+      if (!row) return { hasOutput: true, tokenCount: 0 };
+      return { hasOutput: row.n > 0 && row.tokens > 0, tokenCount: row.tokens };
+    } catch {
+      return { hasOutput: true, tokenCount: 0 };
+    } finally {
+      db.close();
+    }
+  }
+}

package/src/runtime/pi-backend.ts

@@ -0,0 +1,167 @@
+import { spawn } from "bun";
+import { readdirSync, existsSync } from "fs";
+import { join } from "path";
+import { log } from "../logger";
+import type {
+  RuntimeBackend,
+  RuntimeSpawnOpts,
+  RuntimeSpawnCallbacks,
+  RuntimeHandle,
+  SessionOutputResult,
+} from "./types";
+
+export class PiBackend implements RuntimeBackend {
+  readonly name = "pi";
+
+  constructor(
+    private binary: string,
+    private provider: string,
+    private defaultModel: string | undefined,
+    private childEnvDeny: string[] = [],
+  ) {}
+
+  async spawn(opts: RuntimeSpawnOpts, cb: RuntimeSpawnCallbacks): Promise<RuntimeHandle> {
+    const args: string[] = [this.binary, "--mode", "json", "--print"];
+
+    const model = opts.model || this.defaultModel;
+    if (model) {
+      if (model.includes("/")) {
+        const slashIdx = model.indexOf("/");
+        const provider = model.slice(0, slashIdx);
+        const modelId = model.slice(slashIdx + 1);
+        args.push("--provider", provider, "--model", modelId);
+      } else {
+        args.push("--provider", this.provider, "--model", model);
+      }
+    } else {
+      args.push("--provider", this.provider);
+    }
+
+    if (opts.resumeSessionId) {
+      args.push("--session-id", opts.resumeSessionId);
+    }
+
+    args.push(opts.prompt);
+
+    const childEnv = { ...opts.env };
+    for (const key of this.childEnvDeny) delete childEnv[key];
+
+    const proc = spawn({
+      cmd: args,
+      cwd: opts.workdir,
+      env: childEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+
+    const stderrText = new Response(proc.stderr).text();
+
+    void this.readStdout(proc, cb);
+
+    return { pid: proc.pid, exited: proc.exited, stderrText };
+  }
+
+  private async readStdout(
+    proc: ReturnType<typeof spawn>,
+    cb: RuntimeSpawnCallbacks,
+  ): Promise<void> {
+    let captured = false;
+    const stdout = proc.stdout;
+    if (!stdout || typeof stdout === "number") return;
+    const reader = stdout.getReader();
+    const decoder = new TextDecoder();
+    let lineBuf = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      cb.onOutput();
+
+      if (!captured) {
+        lineBuf += decoder.decode(value, { stream: true });
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop()!;
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const ev = JSON.parse(line);
+            if (ev.type === "session" && ev.id) {
+              await cb.onSessionId(ev.id as string);
+              captured = true;
+              break;
+            }
+          } catch { /* not json */ }
+        }
+      }
+    }
+  }
+
+  async sessionExists(sessionId: string): Promise<boolean> {
+    const sessionDir = this.resolveSessionDir();
+    if (!existsSync(sessionDir)) return false;
+    try {
+      const files = readdirSync(sessionDir);
+      return files.some((f) => f.includes(sessionId) && f.endsWith(".jsonl"));
+    } catch {
+      return false;
+    }
+  }
+
+  async getSessionOutputTokens(sessionId: string | undefined): Promise<SessionOutputResult> {
+    if (!sessionId) return { hasOutput: true, tokenCount: 0 };
+
+    const filePath = this.findSessionFile(sessionId);
+    if (!filePath) return { hasOutput: true, tokenCount: 0 };
+
+    try {
+      const { readFileSync } = await import("fs");
+      const content = readFileSync(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      let totalTokens = 0;
+      let hasAssistant = false;
+
+      for (const line of lines) {
+        try {
+          const ev = JSON.parse(line);
+          if (ev.type === "message" && ev.message?.role === "assistant") {
+            hasAssistant = true;
+            const output = ev.message?.usage?.output ?? 0;
+            totalTokens += output;
+          }
+        } catch { /* skip */ }
+      }
+
+      return { hasOutput: hasAssistant && totalTokens > 0, tokenCount: totalTokens };
+    } catch {
+      return { hasOutput: true, tokenCount: 0 };
+    }
+  }
+
+  private resolveSessionDir(): string {
+    const envDir = process.env.PI_CODING_AGENT_SESSION_DIR;
+    if (envDir) return envDir;
+    const agentDir = process.env.PI_CODING_AGENT_DIR || join(process.env.HOME || "~", ".pi", "agent");
+    return join(agentDir, "sessions");
+  }
+
+  private findSessionFile(sessionId: string): string | null {
+    const sessionDir = this.resolveSessionDir();
+    if (!existsSync(sessionDir)) return null;
+    try {
+      const subdirs = readdirSync(sessionDir, { withFileTypes: true });
+      for (const dir of subdirs) {
+        if (!dir.isDirectory()) continue;
+        const dirPath = join(sessionDir, dir.name);
+        const files = readdirSync(dirPath);
+        for (const f of files) {
+          if (f.includes(sessionId) && f.endsWith(".jsonl")) {
+            return join(dirPath, f);
+          }
+        }
+      }
+    } catch { /* not found */ }
+    return null;
+  }
+}

package/src/runtime/types.ts

@@ -0,0 +1,33 @@
+export interface RuntimeSpawnOpts {
+  workdir: string;
+  prompt: string;
+  model?: string;
+  resumeSessionId?: string;
+  env: Record<string, string | undefined>;
+}
+
+export interface RuntimeSpawnCallbacks {
+  onOutput: () => void;
+  onSessionId: (id: string) => Promise<void> | void;
+}
+
+export interface RuntimeHandle {
+  pid: number;
+  exited: Promise<number>;
+  stderrText: Promise<string>;
+}
+
+export interface SessionOutputResult {
+  hasOutput: boolean;
+  tokenCount: number;
+}
+
+export interface RuntimeBackend {
+  readonly name: string;
+
+  spawn(opts: RuntimeSpawnOpts, callbacks: RuntimeSpawnCallbacks): Promise<RuntimeHandle>;
+
+  sessionExists(sessionId: string): Promise<boolean>;
+
+  getSessionOutputTokens(sessionId: string | undefined): Promise<SessionOutputResult>;
+}