tines 0.0.315 → 0.0.316

package/README.md

@@ -135,6 +135,7 @@ TINES_API_KEY=tines_… tines runner install --name laptop --harness claude-code
 
 registers this machine as a local runner and installs the daemon as a launchd/systemd
 service that polls for work and keeps itself updated (`tines runner daemon` with the same
-flags runs it in the foreground instead). See
+flags runs it in the foreground instead). `--harness` is `claude-code`, `codex`, `pi` or
+`custom`. See
 [docs/runner-daemon.md](https://github.com/tbuckley/tines/blob/main/docs/runner-daemon.md)
 for the flags, token rotation, and what the service does.

package/dist/index.js

@@ -5848,6 +5848,7 @@ function isSupportedCodexRolloutVersion(version) {
 // ../shared/src/effort.ts
 var EFFORT_TOKEN_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/;
 var EFFORT_CAPABILITIES_MAX_BYTES = 64 * 1024;
+var EFFORT_CAPABILITIES_MAX_MODELS = 256;
 var RECOGNIZED_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max", "ultra"];
 function admitEffort(allowed, value, assertable) {
   if (allowed !== null)
@@ -7917,7 +7918,7 @@ function register3(program3) {
       const blockedBy = await Promise.all(
         (opts.blockedBy ?? []).map(async (ref) => (await resolveIssue(api, ref)).id)
       );
-      const blocks = await Promise.all(
+      const blocks2 = await Promise.all(
         (opts.blocks ?? []).map(async (ref) => (await resolveIssue(api, ref)).id)
       );
       const duplicateOf = opts.duplicateOf ? (await resolveIssue(api, opts.duplicateOf)).id : void 0;
@@ -7929,7 +7930,7 @@ function register3(program3) {
         schedule: schedule2,
         labels: opts.label,
         ...blockedBy.length > 0 ? { blocked_by: blockedBy } : {},
-        ...blocks.length > 0 ? { blocks } : {},
+        ...blocks2.length > 0 ? { blocks: blocks2 } : {},
         ...duplicateOf ? { duplicate_of: duplicateOf } : {}
       });
       if (opts.json) return printJson(issue);
@@ -9474,6 +9475,7 @@ import {
   createWriteStream,
   existsSync as existsSync6,
   mkdirSync as mkdirSync5,
+  readdirSync as readdirSync3,
   readFileSync as readFileSync10,
   realpathSync,
   rmSync as rmSync4,
@@ -9482,7 +9484,7 @@ import {
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 
 // src/version.ts
@@ -9507,6 +9509,7 @@ function copySummary(value) {
   return {
     ...value,
     ...value.usage ? { usage: { ...value.usage } } : {},
+    ...value.harnessOutcome ? { harnessOutcome: { ...value.harnessOutcome } } : {},
     ...value.pricingEvidence ? {
       pricingEvidence: {
         ...value.pricingEvidence,
@@ -9851,6 +9854,284 @@ var CodexStreamRenderer = class {
   }
 };
 
+// src/daemon/pi-stream.ts
+function blocks(content) {
+  return Array.isArray(content) ? content : [];
+}
+function blockText(content) {
+  return (content ?? []).map((block) => typeof block?.text === "string" ? block.text : "").join("").trim();
+}
+function failedStop(message3) {
+  return message3.stopReason === "error" || message3.stopReason === "aborted";
+}
+function toolLine(event) {
+  const name2 = event.toolName ?? "tool";
+  const args = event.args && typeof event.args === "object" ? event.args : {};
+  if (name2 === "bash" && typeof args.command === "string") {
+    return `[tool] bash: ${clip(args.command, 300)}`;
+  }
+  if (typeof args.path === "string") return `[tool] ${name2} ${clip(args.path, 300)}`;
+  const rest = event.args === void 0 ? "" : JSON.stringify(event.args);
+  return `[tool] ${name2} ${clip(rest, 300)}`.trimEnd();
+}
+function renderPiEvent(event) {
+  switch (event.type) {
+    case "session":
+      return ["[session] started"];
+    case "message_end": {
+      if (event.message?.role !== "assistant") return [];
+      const lines2 = [];
+      for (const block of blocks(event.message.content)) {
+        if (block.type === "text" && block.text?.trim()) {
+          lines2.push(`[agent] ${clip(block.text.trim(), 2e3)}`);
+        }
+      }
+      return lines2;
+    }
+    case "tool_execution_start":
+      return [toolLine(event)];
+    case "tool_execution_end": {
+      const exitCode = event.result?.structuredContent?.exit_code;
+      if (!event.isError && !(typeof exitCode === "number" && exitCode !== 0)) return [];
+      const output = blockText(event.result?.content) || (event.result?.structuredContent?.output ?? "").trim();
+      return [`[tool] ${event.toolName ?? "tool"} failed: ${clip(output, 300)}`];
+    }
+    case "auto_retry_start":
+      return [
+        `[retry] attempt ${event.attempt ?? "?"}/${event.maxAttempts ?? "?"}: ${clip(event.errorMessage ?? "", 300)}`
+      ];
+    case "auto_retry_end":
+      if (event.success !== false) return [];
+      return [`[error] ${clip(event.finalError ?? "retries exhausted", 2e3)}`];
+    default:
+      return [];
+  }
+}
+function messageChars(message3) {
+  let chars = typeof message3.content === "string" ? message3.content.length : 0;
+  for (const block of blocks(message3.content)) {
+    if (typeof block.text === "string") chars += block.text.length;
+    if (typeof block.thinking === "string") chars += block.thinking.length;
+    if (block.type === "toolCall") {
+      chars += (block.name ?? "").length + JSON.stringify(block.arguments ?? {}).length;
+    }
+  }
+  for (const section of Object.values(message3.sections ?? {})) {
+    if (typeof section === "string") chars += section.length;
+  }
+  if (message3.toolsAdded !== void 0) chars += JSON.stringify(message3.toolsAdded).length;
+  return chars;
+}
+function classifyFailure(detail) {
+  if (/^429\b/.test(detail)) return { kind: "rate_limited", detail };
+  if (/^5\d\d\b/.test(detail) || /Connection error|fetch failed|ECONNREFUSED/.test(detail)) {
+    return { kind: "provider_error", detail };
+  }
+  return { kind: "error", detail };
+}
+var UNSPOOLED_PI_EVENTS = /* @__PURE__ */ new Set(["message_update", "message_start", "tool_execution_update"]);
+function spooledPiLine(line) {
+  let type = /^\s*\{"type":"([A-Za-z_]+)"/.exec(line)?.[1];
+  if (type === void 0 && line.trimStart().startsWith("{")) {
+    try {
+      const event = JSON.parse(line);
+      if (typeof event?.type === "string") type = event.type;
+    } catch {
+      return line;
+    }
+  }
+  if (type === void 0) return line;
+  if (UNSPOOLED_PI_EVENTS.has(type)) return null;
+  return type === "agent_end" ? '{"type":"agent_end"}' : line;
+}
+var PiRawSpoolFilter = class {
+  pending = "";
+  /** Feeds a chunk in; returns the complete lines to spool, newline-terminated. */
+  write(chunk) {
+    this.pending += chunk;
+    let out = "";
+    let nl = this.pending.indexOf("\n");
+    while (nl !== -1) {
+      const kept = spooledPiLine(this.pending.slice(0, nl));
+      if (kept !== null) out += `${kept}
+`;
+      this.pending = this.pending.slice(nl + 1);
+      nl = this.pending.indexOf("\n");
+    }
+    return out;
+  }
+  /** The trailing partial line, if the stream ended without a newline. */
+  end() {
+    const last = this.pending;
+    this.pending = "";
+    return last ? spooledPiLine(last) ?? "" : "";
+  }
+};
+var PiStreamRenderer = class {
+  constructor(emit, opts = {}) {
+    this.emit = emit;
+    this.opts = opts;
+  }
+  emit;
+  opts;
+  pending = "";
+  finished = false;
+  providerSessionId;
+  numTurns = 0;
+  tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  cost = 0;
+  /** Assistant messages that ended, and those of them that were real answers. */
+  assistantMessages = 0;
+  answered = 0;
+  lastAssistant = null;
+  lastRetryFailure = null;
+  appliedEffort;
+  /** The estimate's running totals, in characters. */
+  contextChars = 0;
+  estimatedInputChars = 0;
+  estimatedOutputChars = 0;
+  write(chunk) {
+    this.pending += chunk;
+    let nl = this.pending.indexOf("\n");
+    while (nl !== -1) {
+      this.line(this.pending.slice(0, nl));
+      this.pending = this.pending.slice(nl + 1);
+      nl = this.pending.indexOf("\n");
+    }
+  }
+  /**
+   * Renders any trailing partial line, then — when the model server reported
+   * no usage at all — the labelled estimate. Call once the harness has exited.
+   */
+  finish() {
+    if (this.finished) return;
+    this.finished = true;
+    if (this.pending) {
+      this.line(this.pending);
+      this.pending = "";
+    }
+    if (this.answered > 0 && !this.measured()) {
+      this.emit(
+        `[usage] the model server reported no token usage; rough estimate ~${Math.round(this.estimatedInputChars / 4)} input / ~${Math.round(this.estimatedOutputChars / 4)} output tokens (characters \xF7 4, not recorded)${this.opts.resumed ? "; this run's messages only" : ""}
+`
+      );
+    }
+  }
+  summary() {
+    const usage2 = this.usage();
+    return copySummary({
+      ...this.providerSessionId ? { providerSessionId: this.providerSessionId } : {},
+      ...usage2 ? { usage: usage2 } : {},
+      ...this.numTurns > 0 ? { numTurns: this.numTurns } : {},
+      harnessOutcome: this.outcome(),
+      ...this.appliedEffort ? { appliedEffort: this.appliedEffort } : {}
+    });
+  }
+  measured() {
+    return this.cost > 0 || Object.values(this.tokens).some((value) => value > 0);
+  }
+  /**
+   * Nothing when every sum is zero: a local model server that reports no
+   * usage must not be recorded as a run that used zero tokens. Tokens alone
+   * carry no `cost_source` — `none` beside tokens reads as inconsistent to
+   * usage accounting — and Pi's own cost is passed on only when it has one.
+   */
+  usage() {
+    if (!this.measured()) return void 0;
+    return {
+      input_tokens: this.tokens.input,
+      output_tokens: this.tokens.output,
+      cache_read_tokens: this.tokens.cacheRead,
+      cache_write_tokens: this.tokens.cacheWrite,
+      ...this.cost > 0 ? { cost_usd: this.cost, cost_source: "provider" } : {}
+    };
+  }
+  outcome() {
+    const last = this.lastAssistant;
+    if (!last) return { kind: "error", detail: "pi ended without an assistant message" };
+    if (!failedStop(last)) return { kind: "ok" };
+    return classifyFailure(last.errorMessage || this.lastRetryFailure || last.stopReason);
+  }
+  line(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) return;
+    if (!trimmed.startsWith("{")) {
+      this.emit(`${raw}
+`);
+      return;
+    }
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      this.emit(`${raw}
+`);
+      return;
+    }
+    if (!event || typeof event !== "object" || Array.isArray(event)) return;
+    for (const line of this.collect(event)) this.emit(`${line}
+`);
+    for (const line of renderPiEvent(event)) this.emit(`${line}
+`);
+  }
+  /** Updates the summary; returns the lines only the renderer's state can write. */
+  collect(event) {
+    switch (event.type) {
+      case "session":
+        if (!this.providerSessionId && validProviderSessionId(event.id)) {
+          this.providerSessionId = event.id;
+        }
+        return [];
+      case "turn_end":
+        this.numTurns++;
+        return [];
+      case "auto_retry_end":
+        if (event.success === false) this.lastRetryFailure = event.finalError ?? null;
+        return [];
+      case "message_end":
+        return event.message && typeof event.message === "object" ? this.collectMessage(event.message) : [];
+      default:
+        return [];
+    }
+  }
+  collectMessage(message3) {
+    const chars = messageChars(message3);
+    if (message3.role !== "assistant") {
+      if (message3.role === "toolResult") this.addUsage(message3.usage);
+      this.contextChars += chars;
+      return [];
+    }
+    const lines2 = [];
+    if (this.assistantMessages++ === 0 && message3.model) {
+      const model = message3.provider ? `${message3.provider}/${message3.model}` : message3.model;
+      lines2.push(
+        `[session] model ${model}${message3.thinkingLevel ? ` thinking=${message3.thinkingLevel}` : ""}`
+      );
+    }
+    this.lastAssistant = message3;
+    this.addUsage(message3.usage);
+    if (failedStop(message3)) return lines2;
+    this.answered++;
+    this.estimatedInputChars += this.contextChars;
+    this.estimatedOutputChars += chars;
+    this.contextChars += chars;
+    if (this.appliedEffort === void 0 && typeof message3.thinkingLevel === "string") {
+      this.appliedEffort = message3.thinkingLevel;
+      this.opts.onAppliedEffort?.(message3.thinkingLevel);
+    }
+    return lines2;
+  }
+  addUsage(usage2) {
+    if (!usage2 || typeof usage2 !== "object") return;
+    for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+      const value = usage2[key];
+      if (validMetric(value)) this.tokens[key] += value;
+    }
+    const cost = usage2.cost?.total;
+    if (validMetric(cost)) this.cost += cost;
+  }
+};
+
 // src/daemon/codex-rollout.ts
 import { open, opendir, realpath, stat } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
@@ -10299,15 +10580,24 @@ var MAX_STDOUT = 1024 * 1024;
 var DEADLINE_MS = 5e3;
 var EFFORT_CAPABILITIES_TTL_MS = 10 * 6e4;
 var MIN_CLAUDE_EFFORT_VERSION = [2, 1, 258];
-function claudeEffortVersionSupported(version) {
+var MIN_PI_VERSION = [0, 99, 2];
+var PI_VERSION_FLOOR = MIN_PI_VERSION.join(".");
+var PI_DEADLINE_MS = 2e4;
+function versionAtLeast(version, floor) {
   const parsed = version.match(/(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
   if (!parsed) return false;
-  for (let i = 0; i < MIN_CLAUDE_EFFORT_VERSION.length; i++) {
-    if (parsed[i] > MIN_CLAUDE_EFFORT_VERSION[i]) return true;
-    if (parsed[i] < MIN_CLAUDE_EFFORT_VERSION[i]) return false;
+  for (let i = 0; i < floor.length; i++) {
+    if (parsed[i] > floor[i]) return true;
+    if (parsed[i] < floor[i]) return false;
   }
   return true;
 }
+function claudeEffortVersionSupported(version) {
+  return versionAtLeast(version, MIN_CLAUDE_EFFORT_VERSION);
+}
+function piVersionSupported(version) {
+  return versionAtLeast(version, MIN_PI_VERSION);
+}
 function assignmentEffortRejection(assignment, capabilities, harness) {
   if (!assignment.effort) return null;
   if (!capabilities || capabilities.version !== 1 || !("models" in capabilities))
@@ -10473,8 +10763,106 @@ async function discoverCodex(daemonVersion) {
     );
   });
 }
+async function discoverPi(daemonVersion, deadlineMs = PI_DEADLINE_MS) {
+  let harnessVersion;
+  try {
+    harnessVersion = (await run("pi", ["--version"])).trim().slice(0, 100);
+  } catch (error) {
+    return failure("pi", daemonVersion, error instanceof Error ? error.message : String(error));
+  }
+  if (!piVersionSupported(harnessVersion))
+    return failure(
+      "pi",
+      daemonVersion,
+      `installed pi ${harnessVersion || "unknown"} predates the supported ${MIN_PI_VERSION.join(".")}`
+    );
+  return new Promise((resolve3) => {
+    const child = spawn("pi", ["--mode", "rpc", "--no-session"], {
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    let buffer = "";
+    let bytes2 = 0;
+    let settled = false;
+    let requestId = 0;
+    let awaiting = null;
+    const finish = (report) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      resolve3(report);
+    };
+    const fail = (reason) => finish(failure("pi", daemonVersion, reason));
+    const request = (command) => new Promise((deliver) => {
+      const id2 = `tines-${++requestId}`;
+      awaiting = { id: id2, deliver };
+      child.stdin.write(`${JSON.stringify({ id: id2, ...command })}
+`);
+    });
+    const timer = setTimeout(() => fail("pi model discovery timed out"), deadlineMs);
+    child.on("error", (error) => fail(error.message));
+    child.stdin.on("error", (error) => fail(`pi rpc stdin: ${error.message}`));
+    child.on(
+      "close",
+      (code, signal) => fail(`pi rpc exited (${signal ?? `code ${code}`}) before listing models`)
+    );
+    child.stdout.on("data", (chunk) => {
+      bytes2 += chunk.length;
+      if (bytes2 > MAX_STDOUT) return fail("pi model discovery exceeded 1 MiB");
+      buffer += chunk.toString("utf8");
+      for (; ; ) {
+        const newline = buffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        buffer = buffer.slice(newline + 1);
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (record?.type !== "response" || !awaiting || record.id !== awaiting.id) continue;
+        const { deliver } = awaiting;
+        awaiting = null;
+        deliver(record);
+      }
+    });
+    void (async () => {
+      const listed = await request({ type: "get_available_models" });
+      if (!listed.success)
+        return fail(`pi get_available_models failed: ${String(listed.error ?? "no reason given")}`);
+      const models = [];
+      const names = /* @__PURE__ */ new Set();
+      for (const entry of Array.isArray(listed.data?.models) ? listed.data.models : []) {
+        if (settled || models.length >= EFFORT_CAPABILITIES_MAX_MODELS) break;
+        if (typeof entry?.provider !== "string" || typeof entry?.id !== "string") continue;
+        const model = `${entry.provider}/${entry.id}`;
+        if (model.length > 200 || names.has(model)) continue;
+        const selected = await request({
+          type: "set_model",
+          provider: entry.provider,
+          modelId: entry.id
+        });
+        if (!selected.success) continue;
+        const thinking = await request({ type: "get_available_thinking_levels" });
+        const levels = thinking.success && Array.isArray(thinking.data?.levels) ? thinking.data.levels : [];
+        names.add(model);
+        models.push({ model, efforts: [...new Set(levels.filter(isRecognizedEffort))] });
+      }
+      finish({
+        version: 1,
+        daemon_version: daemonVersion,
+        harness: "pi",
+        harness_version: harnessVersion,
+        catalog_digest: digest(models),
+        models
+      });
+    })();
+  });
+}
 async function discoverEffortCapabilities(harness, daemonVersion) {
   if (harness === "custom") return void 0;
+  if (harness === "pi") return discoverPi(daemonVersion);
   return harness === "codex" ? discoverCodex(daemonVersion) : discoverClaude(daemonVersion);
 }
 var EffortCapabilityRefresher = class {
@@ -10511,11 +10899,12 @@ var EffortCapabilityRefresher = class {
 // src/daemon/cli-refresh.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
 
 // src/daemon/support.ts
-import { delimiter, sep as sep3 } from "node:path";
-var HARNESS_KINDS = ["claude_code", "codex", "custom"];
+import { delimiter, join as join5, sep as sep3 } from "node:path";
+var HARNESS_KINDS = ["claude_code", "codex", "pi", "custom"];
+var PI_SESSION_DIR = ".pi-sessions";
 var KEEP_WORKSPACES_MODES = ["never", "failed", "always"];
 function keepWorkspace(mode, outcome) {
   return mode === "always" || mode === "failed" && outcome === "failed";
@@ -10548,6 +10937,14 @@ function buildHarnessInvocation(spec, input2) {
           input2.prompt
         ]
       };
+    case "pi":
+      return {
+        file: "sh",
+        args: [
+          "-c",
+          `pi --mode json --no-approve --session-dir ${shellQuote(join5(input2.workspace, PI_SESSION_DIR))}${input2.resumeSessionId ? ` --session ${shellQuote(input2.resumeSessionId)}` : ""}${input2.model ? ` --model ${shellQuote(input2.model)}` : ""}${input2.effort ? ` --thinking ${shellQuote(input2.effort)}` : ""}${(input2.skillDirs ?? []).map((dir) => ` --skill ${shellQuote(dir)}`).join("")} < ${shellQuote(input2.promptFile)}`
+        ]
+      };
     case "custom": {
       if (!spec.command) throw new Error("the custom harness needs a --command template");
       return { file: "sh", args: ["-c", expandCommandTemplate(spec.command, input2)] };
@@ -10569,7 +10966,9 @@ function formatLaunchCommand(invocation) {
 function formatLaunchBanner(invocation, input2, meta) {
   const fields = [
     `harness=${meta.harness}`,
-    `model=${input2.model ?? "(fixed)"}`,
+    // Pi with no model named is not fixed: it runs whatever its own
+    // settings default to, and the stream's `[session] model` line says which.
+    `model=${input2.model ?? (meta.harness === "pi" ? "(pi default)" : "(fixed)")}`,
     `effort=${input2.effort ?? "(provider-default)"}`,
     `timeout=${meta.timeoutMinutes}m`,
     `cli=${meta.cliVersion}`,
@@ -10599,6 +10998,68 @@ function exitLineForRun(run3, exit) {
   if (run3.settled) return null;
   return formatExitLine({ ...exit, timedOut: run3.timedOut });
 }
+function classifyExit(facts) {
+  const mask = (text4) => redactSecrets(text4, facts.secrets);
+  if (facts.timedOut) {
+    return {
+      status: "failed",
+      error: `run exceeded the ${facts.timeoutMinutes}m timeout; harness killed`
+    };
+  }
+  if (facts.effortMismatch) return { status: "failed", error: mask(facts.effortMismatch) };
+  if (facts.signal) return { status: "failed", error: `harness killed by ${facts.signal}` };
+  const outcome = facts.harness === "pi" ? facts.harnessOutcome : void 0;
+  if (facts.code !== 0) {
+    if (facts.limited) {
+      const detail = mask(facts.limited.detail);
+      return {
+        status: "failed",
+        error: `rate limited: ${detail}`,
+        judgment: "rate_limited",
+        ...facts.limited.resumeAt !== null ? { resume_at: facts.limited.resumeAt } : {},
+        note: `harness rate limited (${detail})`
+      };
+    }
+    if (facts.providerError) {
+      const detail = mask(facts.providerError.detail);
+      return {
+        status: "failed",
+        error: `provider error: ${detail}`,
+        judgment: "interrupted",
+        note: `transient provider error (${detail})`
+      };
+    }
+    return (outcome && providerVerdict(outcome, mask)) ?? {
+      status: "failed",
+      error: `harness exited with code ${facts.code}`
+    };
+  }
+  if (outcome && outcome.kind !== "ok") {
+    return providerVerdict(outcome, mask) ?? { status: "failed", error: `pi: ${mask(outcome.detail)}` };
+  }
+  return { status: "completed" };
+}
+function providerVerdict(outcome, mask) {
+  if (outcome.kind === "rate_limited") {
+    const detail = mask(outcome.detail);
+    return {
+      status: "failed",
+      error: `rate limited: ${detail}`,
+      judgment: "rate_limited",
+      note: `harness rate limited (${detail})`
+    };
+  }
+  if (outcome.kind === "provider_error") {
+    const detail = mask(outcome.detail);
+    return {
+      status: "failed",
+      error: `provider error: ${detail}`,
+      judgment: "interrupted",
+      note: `transient provider error (${detail})`
+    };
+  }
+  return null;
+}
 var RunTable = class {
   constructor(effects, opts = {}) {
     this.effects = effects;
@@ -10913,14 +11374,14 @@ var SecretRedactor = class {
 var PACKAGE = "tines";
 var NPM_ARGS = ["--min-release-age=0", "--no-audit", "--no-fund", "--loglevel=error"];
 function agentCliPrefix(configDir) {
-  return join5(configDir, "cli");
+  return join6(configDir, "cli");
 }
 function binDirOf(prefix) {
-  return join5(prefix, "node_modules", ".bin");
+  return join6(prefix, "node_modules", ".bin");
 }
 function installedVersion(prefix) {
   try {
-    const pkg = readFileSync8(join5(prefix, "node_modules", PACKAGE, "package.json"), "utf8");
+    const pkg = readFileSync8(join6(prefix, "node_modules", PACKAGE, "package.json"), "utf8");
     const version = JSON.parse(pkg).version;
     return typeof version === "string" ? version : null;
   } catch {
@@ -10929,7 +11390,7 @@ function installedVersion(prefix) {
 }
 function lastGood(prefix) {
   const binDir = binDirOf(prefix);
-  if (!existsSync5(join5(binDir, PACKAGE))) return AMBIENT_CLI;
+  if (!existsSync5(join6(binDir, PACKAGE))) return AMBIENT_CLI;
   return { binDir, version: installedVersion(prefix), source: "stale" };
 }
 function runNpm(file, args, cwd, timeoutMs) {
@@ -10974,7 +11435,7 @@ async function installAgentCli(opts) {
   const args = ["install", "--prefix", prefix, `${PACKAGE}@latest`, ...NPM_ARGS];
   let result = await runNpm("npm", args, prefix, timeoutMs);
   if (result.spawnError?.code === "ENOENT") {
-    const sibling = join5(dirname3(process.execPath), "npm");
+    const sibling = join6(dirname3(process.execPath), "npm");
     if (existsSync5(sibling)) result = await runNpm(sibling, args, prefix, timeoutMs);
   }
   if (result.code !== 0) {
@@ -11001,12 +11462,12 @@ import { arch, hostname, platform } from "node:os";
 
 // src/daemon/store.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync9, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function credentialsKey(url, name2) {
   return `${url.replace(/\/+$/, "")}#${name2}`;
 }
 function credentialsPath(dir) {
-  return join6(dir, "runners.json");
+  return join7(dir, "runners.json");
 }
 function loadRunnerCredentials(dir, url, name2) {
   const all = readJsonFile(credentialsPath(dir));
@@ -11029,7 +11490,7 @@ function clearRunnerCredentials(dir, url, name2) {
   writeJsonFile(path2, all, { secret: true });
 }
 function daemonStatePath(dir, runnerId) {
-  return join6(dir, `daemon-state-${runnerId}.json`);
+  return join7(dir, `daemon-state-${runnerId}.json`);
 }
 function loadDaemonState(path2) {
   const state = readJsonFile(path2);
@@ -11042,7 +11503,7 @@ function saveDaemonState(path2, runs) {
   writeJsonFile(path2, { runs });
 }
 function daemonDeclinesPath(dir, runnerId) {
-  return join6(dir, `daemon-declines-${runnerId}.json`);
+  return join7(dir, `daemon-declines-${runnerId}.json`);
 }
 function loadDaemonDeclines(path2) {
   const state = readJsonFile(path2);
@@ -11072,10 +11533,10 @@ function processStartTimeMs(pid) {
   }
 }
 function workspacesDir(configDir) {
-  return join6(configDir, "workspaces");
+  return join7(configDir, "workspaces");
 }
 function keptMarkerPath(workspace) {
-  return join6(workspace, "kept.json");
+  return join7(workspace, "kept.json");
 }
 function writeKeptMarker(workspace, marker) {
   writeJsonFile(keptMarkerPath(workspace), marker);
@@ -11097,7 +11558,7 @@ function listKeptWorkspaces(configDir) {
   }
   const kept = [];
   for (const name2 of names) {
-    const path2 = join6(root, name2);
+    const path2 = join7(root, name2);
     const marker = readKeptMarker(path2);
     if (marker) kept.push({ ...marker, path: path2 });
   }
@@ -11134,7 +11595,7 @@ function directorySizeBytes(path2) {
     return 0;
   }
   for (const entry of entries) {
-    const child = join6(path2, entry.name);
+    const child = join7(path2, entry.name);
     if (entry.isDirectory()) total += directorySizeBytes(child);
     else if (entry.isFile()) {
       try {
@@ -11213,6 +11674,15 @@ async function uploadRawLog(run3) {
 }
 var log = (message3) => console.log(`[${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)}] ${message3}`);
 var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+function piSessionExists(workspace, sessionId) {
+  try {
+    return readdirSync3(join8(workspace, PI_SESSION_DIR)).some(
+      (name2) => name2.endsWith(`_${sessionId}.jsonl`)
+    );
+  } catch {
+    return false;
+  }
+}
 function killTree(pid, signal) {
   try {
     process.kill(-pid, signal);
@@ -11298,7 +11768,7 @@ async function runDaemon(opts) {
   const selfUpdate = opts.selfUpdate && opts.cliRefresh && managedInstall;
   if (opts.selfUpdate && opts.cliRefresh) {
     log(
-      managedInstall ? `self-update: on \u2014 this daemon (tines ${DAEMON_VERSION}) runs from ${prefix} and will restart once idle after a newer release is installed there` : `self-update: off \u2014 this daemon (tines ${DAEMON_VERSION}) runs from ${selfPath ?? process.argv[1] ?? "?"}, not ${prefix}; launch it from ${join7(prefix, "node_modules", ".bin", "tines")} to have refreshes apply on restart \u2014 \`tines runner install --name ${opts.name} --harness ${opts.harness.replaceAll("_", "-")}\` sets that up as a service (docs/runner-daemon.md)`
+      managedInstall ? `self-update: on \u2014 this daemon (tines ${DAEMON_VERSION}) runs from ${prefix} and will restart once idle after a newer release is installed there` : `self-update: off \u2014 this daemon (tines ${DAEMON_VERSION}) runs from ${selfPath ?? process.argv[1] ?? "?"}, not ${prefix}; launch it from ${join8(prefix, "node_modules", ".bin", "tines")} to have refreshes apply on restart \u2014 \`tines runner install --name ${opts.name} --harness ${opts.harness.replaceAll("_", "-")}\` sets that up as a service (docs/runner-daemon.md)`
     );
   }
   let pendingUpdate = null;
@@ -11471,7 +11941,7 @@ async function runDaemon(opts) {
         `run ${runId}: resume workspace ${assignment.resume.workspace_path} is gone; launching fresh`
       );
     }
-    const workspace = resume ? resume.workspace_path : join7(workspacesDir(opts.configDir), runId);
+    const workspace = resume ? resume.workspace_path : join8(workspacesDir(opts.configDir), runId);
     const issueLabel = assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : void 0;
     const run3 = {
       runId,
@@ -11516,7 +11986,7 @@ async function runDaemon(opts) {
       const currentRepoDirs = assignment.bundle.repos.map((repo) => repo.dir);
       let retainedRepoDirs = [];
       if (resume) {
-        const retainedPath = join7(workspace, "repos.json");
+        const retainedPath = join8(workspace, "repos.json");
         let retained;
         try {
           retained = JSON.parse(readFileSync10(retainedPath, "utf8"));
@@ -11539,14 +12009,14 @@ async function runDaemon(opts) {
         rmSync4(workspace, { recursive: true, force: true });
         mkdirSync5(workspace, { recursive: true });
       } else {
-        rmSync4(join7(workspace, "kept.json"), { force: true });
+        rmSync4(join8(workspace, "kept.json"), { force: true });
       }
       materializeSkills(workspace, assignment.bundle.skills);
-      writeFileSync4(join7(workspace, "prompt.md"), `${assignment.prompt}
+      writeFileSync4(join8(workspace, "prompt.md"), `${assignment.prompt}
 `);
       if (!resume)
         writeFileSync4(
-          join7(workspace, "repos.json"),
+          join8(workspace, "repos.json"),
           `${JSON.stringify(assignment.bundle.repos, null, 2)}
 `
         );
@@ -11578,13 +12048,24 @@ async function runDaemon(opts) {
 ` : `warning: no daemon-managed tines CLI; using whatever \`tines\` is on this machine's PATH
 `
       );
+      let resumeSessionId = resume?.provider_session_id;
+      if (opts.harness === "pi" && resumeSessionId && !piSessionExists(workspace, resumeSessionId)) {
+        log(`run ${runId}: pi session ${resumeSessionId} is gone; launching fresh`);
+        run3.batcher.append(`pi session ${resumeSessionId} is gone; launching fresh
+`);
+        resumeSessionId = void 0;
+        run3.priorTurns = 0;
+      }
       const harnessInput = {
         workspace,
-        promptFile: join7(workspace, "prompt.md"),
+        promptFile: join8(workspace, "prompt.md"),
         prompt: assignment.prompt,
         model: assignment.run.model,
         effort: assignment.effort?.value ?? null,
-        ...resume ? { resumeSessionId: resume.provider_session_id } : {}
+        ...resumeSessionId ? { resumeSessionId } : {},
+        // Pi does not load `.agents/skills` in a folder it has not been told
+        // to trust, so each materialized skill is named on the command line.
+        ...opts.harness === "pi" ? { skillDirs: assignment.bundle.skills.map((skill) => `.agents/skills/${skill.name}`) } : {}
       };
       const invocation = buildHarnessInvocation(
         { harness: opts.harness, command: opts.command },
@@ -11646,7 +12127,7 @@ async function runDaemon(opts) {
           (event) => limiter.noteStreamEvent(event)
         );
         run3.renderer = renderer;
-        const spoolPath = join7(opts.configDir, "rawlogs", `${runId}.ndjson`);
+        const spoolPath = join8(opts.configDir, "rawlogs", `${runId}.ndjson`);
         mkdirSync5(dirname4(spoolPath), { recursive: true });
         run3.rawSpoolPath = spoolPath;
         run3.rawSpool = createWriteStream(spoolPath);
@@ -11667,6 +12148,63 @@ async function runDaemon(opts) {
           run3.rawSpool?.write(rawRedactor.write(text4));
           renderer.write(text4);
         });
+      } else if (opts.harness === "pi") {
+        const renderer = new PiStreamRenderer((line) => run3.batcher.append(line), {
+          resumed: Boolean(resumeSessionId),
+          // Pi clamps `--thinking` to what the model supports without
+          // saying so; the level its first answer records is the proof.
+          // A match confirms an enforced effort. Anything else is a run
+          // at an effort nobody assigned, so it stops here.
+          onAppliedEffort: (level) => {
+            const assigned = assignment.effort?.value;
+            if (!assigned || run3.settled) return;
+            if (level === assigned) {
+              run3.effortEvidence = {
+                status: "confirmed",
+                attempted_effort: assigned,
+                transport: "argv"
+              };
+            } else {
+              const reason = `pi applied thinking level ${level.slice(0, 100)}, not the assigned ${assigned}`;
+              run3.effortEvidence = {
+                status: "rejected",
+                attempted_effort: assigned,
+                transport: "argv",
+                reason,
+                observed_effort: level.slice(0, 100)
+              };
+              run3.effortMismatch = reason;
+              log(`run ${runId}: ${reason}; killing`);
+              run3.batcher.append(`[effort] ${reason}; stopping the run
+`);
+              if (child.pid) killTree(child.pid, "SIGTERM");
+              if (child.pid) setTimeout(() => killTree(child.pid, "SIGKILL"), 5e3).unref?.();
+            }
+            void client2.appendRunLog(runId, { chunk: "", effort_application: run3.effortEvidence }).catch((err) => log(`run ${runId}: effort evidence rejected: ${message2(err)}`));
+          }
+        });
+        run3.renderer = renderer;
+        const spoolPath = join8(opts.configDir, "rawlogs", `${runId}.ndjson`);
+        mkdirSync5(dirname4(spoolPath), { recursive: true });
+        run3.rawSpoolPath = spoolPath;
+        run3.rawSpool = createWriteStream(spoolPath);
+        run3.rawUpload = (body) => client2.putRunLogRaw(runId, body);
+        const decoder = new StringDecoder2("utf8");
+        const spoolFilter = new PiRawSpoolFilter();
+        const rawRedactor = new SecretRedactor(secretEnvValues);
+        run3.drain = () => {
+          const trailing = decoder.end();
+          run3.rawSpool?.write(
+            rawRedactor.write(spoolFilter.write(trailing) + spoolFilter.end()) + rawRedactor.end()
+          );
+          if (trailing) renderer.write(trailing);
+          renderer.finish();
+        };
+        child.stdout?.on("data", (data) => {
+          const text4 = decoder.write(data);
+          run3.rawSpool?.write(rawRedactor.write(spoolFilter.write(text4)));
+          renderer.write(text4);
+        });
       } else if (opts.harness === "codex") {
         const renderer = new CodexStreamRenderer((line) => run3.batcher.append(line));
         const decoder = new StringDecoder2("utf8");
@@ -11731,38 +12269,21 @@ async function runDaemon(opts) {
           durationMs: Date.now() - (run3.spawnedAt ?? Date.now())
         });
         if (closing) run3.batcher.append(closing);
-        if (run3.timedOut) {
-          void table2.finishAndCleanup(
-            run3,
-            "failed",
-            `run exceeded the ${assignment.timeout_minutes}m timeout; harness killed`
-          );
-        } else if (code === 0) {
-          void table2.finishAndCleanup(run3, "completed");
-        } else {
-          const limited = signal ? null : run3.limiter?.signal() ?? null;
-          const providerError = signal ? null : run3.limiter?.providerError() ?? null;
-          if (limited) {
-            const detail = redactSecrets(limited.detail, secretEnvValues);
-            log(`run ${runId}: harness rate limited (${detail}); reporting without a strike`);
-            void table2.finishAndCleanup(run3, "failed", `rate limited: ${detail}`, {
-              judgment: "rate_limited",
-              ...limited.resumeAt !== null ? { resume_at: limited.resumeAt } : {}
-            });
-          } else if (providerError) {
-            const detail = redactSecrets(providerError.detail, secretEnvValues);
-            log(`run ${runId}: transient provider error (${detail}); reporting without a strike`);
-            void table2.finishAndCleanup(run3, "failed", `provider error: ${detail}`, {
-              judgment: "interrupted"
-            });
-          } else {
-            void table2.finishAndCleanup(
-              run3,
-              "failed",
-              signal ? `harness killed by ${signal}` : `harness exited with code ${code}`
-            );
-          }
-        }
+        const { status, error, note, ...judgment } = classifyExit({
+          harness: opts.harness,
+          code,
+          signal,
+          timedOut: run3.timedOut,
+          timeoutMinutes: assignment.timeout_minutes,
+          limited: run3.limiter?.signal() ?? null,
+          providerError: run3.limiter?.providerError() ?? null,
+          // pi: its stream, not its exit code, says how the run ended.
+          ...run3.renderer ? { harnessOutcome: run3.renderer.summary().harnessOutcome } : {},
+          effortMismatch: run3.effortMismatch ?? null,
+          secrets: secretEnvValues
+        });
+        if (note) log(`run ${runId}: ${note}; reporting without a strike`);
+        void table2.finishAndCleanup(run3, status, error, judgment.judgment ? judgment : void 0);
       });
     } catch (err) {
       void table2.finishAndCleanup(
@@ -11929,7 +12450,7 @@ function withDaemonFlags(cmd) {
   return cmd.option(
     "--name <name>",
     "runner name, unique per user; name it machine-plus-harness, e.g. macbook-claude (default: this hostname)"
-  ).option("--harness <harness>", "claude-code | codex | custom", "claude-code").option(
+  ).option("--harness <harness>", "claude-code | codex | pi | custom", "claude-code").option(
     "--command <template>",
     "custom harness command template ({prompt_file}, {workspace}, {model}, {effort})"
   ).option(
@@ -11959,7 +12480,7 @@ function withDaemonFlags(cmd) {
 function parseDaemonFlags(opts) {
   const harness = opts.harness.replaceAll("-", "_");
   if (!HARNESS_KINDS.includes(harness)) {
-    die(`--harness must be claude-code, codex, or custom, got "${opts.harness}"`);
+    die(`--harness must be claude-code, codex, pi, or custom, got "${opts.harness}"`);
   }
   if (harness === "custom" && !opts.command) {
     die(
@@ -12010,7 +12531,7 @@ import { promisify } from "node:util";
 
 // src/daemon/service.ts
 import { existsSync as existsSync7, statSync as statSync5 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname5, join as join8, sep as sep4 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname5, join as join9, sep as sep4 } from "node:path";
 function defaultServiceManager(platform2 = process.platform) {
   if (platform2 === "darwin") return "launchd";
   if (platform2 === "linux") return "systemd";
@@ -12021,13 +12542,13 @@ function serviceLabel(name2, kind) {
 }
 function unitPath(name2, kind, home) {
   const label = serviceLabel(name2, kind);
-  return kind === "launchd" ? join8(home, "Library", "LaunchAgents", `${label}.plist`) : join8(home, ".config", "systemd", "user", `${label}.service`);
+  return kind === "launchd" ? join9(home, "Library", "LaunchAgents", `${label}.plist`) : join9(home, ".config", "systemd", "user", `${label}.service`);
 }
 function serviceLogPath(configDir, name2) {
-  return join8(configDir, "logs", `runner-${name2}.log`);
+  return join9(configDir, "logs", `runner-${name2}.log`);
 }
 function managedBinary(prefix) {
-  return join8(prefix, "node_modules", ".bin", "tines");
+  return join9(prefix, "node_modules", ".bin", "tines");
 }
 function daemonArgs(input2) {
   const args = [
@@ -12056,7 +12577,7 @@ function daemonArgs(input2) {
 function findOnPath(name2, envPath) {
   for (const dir of (envPath ?? "").split(delimiter2)) {
     if (!dir) continue;
-    const candidate = join8(dir, name2);
+    const candidate = join9(dir, name2);
     try {
       if (statSync5(candidate).isFile()) return candidate;
     } catch {
@@ -12077,6 +12598,11 @@ function servicePath(input2) {
   );
   return { path: [...new Set(dirs)].join(delimiter2), missing };
 }
+function listedPiModels(stdout) {
+  const lines2 = stdout.split("\n").filter((line) => line.trim() !== "");
+  if (lines2.length === 0 || !/^provider\s+model\b/.test(lines2[0])) return 0;
+  return lines2.length - 1;
+}
 function xml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
@@ -12205,6 +12731,12 @@ function managedBinaryPresent(prefix) {
 var run2 = promisify(execFile2);
 var STARTUP_TIMEOUT_MS = 3e4;
 var log2 = (message3) => console.log(message3);
+var HARNESS_BINARIES = {
+  claude_code: "claude",
+  codex: "codex",
+  pi: "pi",
+  custom: null
+};
 function resolveServiceManager(flag) {
   if (flag !== void 0) {
     if (flag !== "launchd" && flag !== "systemd")
@@ -12257,6 +12789,44 @@ async function waitForStart(logPath, offset, name2) {
   }
   return false;
 }
+async function requirePiVersion(path2) {
+  const pi = findOnPath("pi", path2);
+  if (!pi) return false;
+  let version;
+  try {
+    version = (await run2(pi, ["--version"], { timeout: 1e4 })).stdout.trim();
+  } catch (err) {
+    die(`\`${pi} --version\` failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!piVersionSupported(version)) {
+    die(
+      `${pi} is pi ${version || "(unknown version)"}, older than ${PI_VERSION_FLOOR}, the oldest the pi harness supports \u2014 update it (\`npm install -g @earendil-works/pi-coding-agent\`), then install again`
+    );
+  }
+  return true;
+}
+async function warnIfPiListsNoModels(path2) {
+  let count;
+  try {
+    const { stdout } = await run2("pi", ["--list-models"], {
+      env: { PATH: path2, HOME: homedir3() },
+      timeout: 3e4
+    });
+    count = listedPiModels(stdout);
+  } catch (err) {
+    log2(
+      `warning: could not run \`pi --list-models\` with the service's PATH (${err instanceof Error ? err.message.split("\n")[0] : String(err)}); check the model list yourself before routing work here`
+    );
+    return;
+  }
+  if (count > 0) {
+    log2(`pi lists ${count} model${count === 1 ? "" : "s"} in the service's environment`);
+    return;
+  }
+  log2(
+    'warning: `pi --list-models` lists no models in the service\'s environment. The service gets only PATH and HOME, not this shell\'s variables, so model credentials that depend on one (an API key exported in your shell profile) are invisible to it and every run would fail. Put the credential where pi reads it without the shell (`~/.pi/agent/auth.json`, or a literal key in `~/.pi/agent/models.json`), then `tines runner restart`. See docs/runner-daemon.md, "Pi" \u2192 "Model credentials".'
+  );
+}
 function serviceTarget(name2, kind) {
   return { kind, name: name2, unitPath: unitPath(name2, kind, homedir3()), uid: userInfo().uid };
 }
@@ -12292,6 +12862,14 @@ ${lines2.join("\n")}
 stop it first \u2014 \`tines runners pause ${settings.name}\`, wait for 0 active runs, kill that process \u2014 then run install again; it reconnects with the stored token, so no key is needed`
       );
     }
+    const harnessBinary = HARNESS_BINARIES[settings.harness];
+    const { path: path2, missing } = servicePath({
+      execPath: process.execPath,
+      required: [...harnessBinary ? [harnessBinary] : [], "git"],
+      envPath: process.env.PATH,
+      platform: process.platform
+    });
+    const piPresent = settings.harness === "pi" && await requirePiVersion(path2);
     if (!managedBinaryPresent(prefix)) {
       log2(`installing the daemon-managed tines into ${prefix} \u2026`);
       await installAgentCli({ configDir, log: log2 });
@@ -12317,18 +12895,12 @@ stop it first \u2014 \`tines runners pause ${settings.name}\`, wait for 0 active
     } catch (err) {
       die(err instanceof Error ? err.message : String(err));
     }
-    const harnessBinary = settings.harness === "claude_code" ? "claude" : settings.harness === "codex" ? "codex" : null;
-    const { path: path2, missing } = servicePath({
-      execPath: process.execPath,
-      required: [...harnessBinary ? [harnessBinary] : [], "git"],
-      envPath: process.env.PATH,
-      platform: process.platform
-    });
     for (const name2 of missing) {
       log2(
         `warning: \`${name2}\` is not on this shell's PATH, so it is not on the service's either \u2014 install it, then \`tines runner install\` again`
       );
     }
+    if (piPresent) await warnIfPiListsNoModels(path2);
     const target = serviceTarget(settings.name, kind);
     const logPath = serviceLogPath(configDir, settings.name);
     const spec = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.315",
+  "version": "0.0.316",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",