tryharness 0.4.1 → 0.4.2

package/README.md

@@ -14,6 +14,10 @@ service, validates readiness, and starts indexing existing coding sessions local
 SQLite. Setup returns as soon as the daemon is ready; indexing continues in the
 background and does not require an open Harness tab.
 
+JSONL histories are streamed from beginning to end and only normalized conversation
+records are retained. Source-file size does not truncate recall; long read results are
+paged when Harness displays them.
+
 The command is idempotent. Run it again after installing another agent or to repair its
 configuration.
 
@@ -23,6 +27,7 @@ configuration.
 npx tryharness status
 npx tryharness doctor
 npx tryharness sync --agent codex
+npx tryharness task <run-id> --follow
 npx tryharness logs --follow
 npx tryharness handoff codex --file ./implementation-brief.md
 npx tryharness disconnect
@@ -32,6 +37,16 @@ npx tryharness disconnect
 daemon, the bridge, the database, and agent discovery. `sync` requests a background
 rescan; it is diagnostic, not part of normal setup.
 
+Delegated coding tasks start only after the user presses Start on Harness's proposal
+card. They then run non-interactively with each agent's full-authority/auto-approve mode
+inside the exact absolute working directory shown on that card; Harness never falls
+back to the user's home directory. The card immediately shows a
+`npx tryharness task <run-id> --follow` command for watching the machine-local raw output
+in a terminal. Both the card and the follow command print the agent's native session
+command as soon as the agent reports its session id, including while the run is active,
+so the user can enter and steer the agent directly rather than interacting through a
+Harness wrapper.
+
 The daemon dials out to Harness over one authenticated WebSocket. Its local control
 socket is permissioned to the current user. When OpenCode is installed, the daemon also
 starts OpenCode's own helper on a random loopback-only port with a random per-process

package/cli.mjs

@@ -12,7 +12,7 @@ import { installRuntime } from "./lib/runtime-install.mjs";
 import { installService, serviceInfo, uninstallService } from "./lib/service.mjs";
 
 const SOURCE_ROOT = path.dirname(fileURLToPath(import.meta.url));
-const PACKAGE = readJson(path.join(SOURCE_ROOT, "package.json"), { version: "0.4.1" });
+const PACKAGE = readJson(path.join(SOURCE_ROOT, "package.json"), { version: "0.4.2" });
 const VERSION = PACKAGE.version;
 const NODE_MAJOR = Number(process.versions.node.split(".")[0]);
 if (!Number.isFinite(NODE_MAJOR) || NODE_MAJOR < 18) {
@@ -31,6 +31,18 @@ function arg(flag, fallback = null) {
   return index >= 0 && argv[index + 1] ? argv[index + 1] : fallback;
 }
 function has(flag) { return argv.includes(flag); }
+function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+function shellQuote(value) { return `'${String(value).replace(/'/g, `'\\''`)}'`; }
+function resumeCommand(agent, sessionId, cwd) {
+  const command = agent === "claude-code"
+    ? `claude --dangerously-skip-permissions --resume ${shellQuote(sessionId)}`
+    : agent === "codex"
+      ? `codex resume --dangerously-bypass-approvals-and-sandbox ${shellQuote(sessionId)}`
+      : agent === "pi"
+        ? `pi --approve --session ${shellQuote(sessionId)}`
+        : `opencode --auto --session ${shellQuote(sessionId)}`;
+  return cwd ? `cd ${shellQuote(cwd)} && ${command}` : command;
+}
 function origin() {
   const saved = readJson(paths.config, {});
   return String(arg("--origin", saved.origin || "https://tryharness.ai")).replace(/\/$/, "");
@@ -213,6 +225,46 @@ async function handoff() {
   console.log(`Handoff ${response.id} is ready for ${agent}. Harness's get_handoff tool can read it.`);
 }
 
+async function task() {
+  const runId = String(argv[0] || "").trim();
+  if (!/^[a-zA-Z0-9._-]{1,128}$/.test(runId)) throw new Error("usage: tryharness task <run-id> [--follow]");
+  const follow = has("--follow") || has("-f");
+  let offset = Math.max(0, Math.floor(Number(arg("--offset", "0")) || 0));
+  let announced = false;
+  let sessionShown = null;
+  let misses = 0;
+  for (;;) {
+    const response = await daemonRequest({ command: "tasks.get", runId, offset });
+    if (!response.ok) {
+      if (follow && misses < 10) { misses += 1; await sleep(500); continue; }
+      throw new Error(response.error || `task ${runId} was not found on this machine`);
+    }
+    misses = 0;
+    const current = response.task;
+    if (!announced) {
+      console.log(`Harness task ${runId} · ${current.agent} · ${current.status}`);
+      if (current.cwd) console.log(`directory: ${current.cwd}`);
+      if (follow) console.log("following machine-local agent output (Ctrl-C stops following, not the task)\n");
+      announced = true;
+    }
+    if (current.log) process.stdout.write(current.log);
+    offset = current.nextOffset;
+    if (current.sessionId && current.sessionId !== sessionShown) {
+      sessionShown = current.sessionId;
+      console.log(`\nagent session: ${current.sessionId}`);
+      console.log(`open live session: ${resumeCommand(current.agent, current.sessionId, current.cwd)}`);
+    }
+    const terminal = current.status === "done" || current.status === "failed";
+    if (!follow || (terminal && offset >= current.logLength)) {
+      console.log(`\nstatus: ${current.status}`);
+      if (current.message) console.log(current.message);
+      if (current.status === "failed") process.exitCode = 1;
+      return;
+    }
+    await sleep(500);
+  }
+}
+
 function logs() {
   if (!fs.existsSync(paths.log)) { console.log("No daemon log yet."); return; }
   const lines = fs.readFileSync(paths.log, "utf8").split("\n");
@@ -230,7 +282,7 @@ async function disconnect() {
 }
 
 function help() {
-  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness handoff <agent> --file <path>\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
+  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness handoff <agent> --file <path>\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
 }
 
 try {
@@ -238,6 +290,7 @@ try {
   else if (command === "status" || command === "bridge") await status();
   else if (command === "doctor") await doctor();
   else if (command === "sync" || command === "backfill" || command === "drain") await sync();
+  else if (command === "task") await task();
   else if (command === "handoff") await handoff();
   else if (command === "logs") logs();
   else if (command === "disconnect") await disconnect();

package/lib/daemon.mjs

@@ -5,14 +5,16 @@ import { spawn } from "node:child_process";
 import WebSocket from "ws";
 import { randomBytes, randomUUID } from "node:crypto";
 import { detectAgents, run } from "./commands.mjs";
-import { appendLog, ensureDir, listJsonl, readJson, tailFile, writeJsonAtomic } from "./files.mjs";
+import { appendLog, ensureDir, listJsonl, readJson, writeJsonAtomic } from "./files.mjs";
+import { parseSessionFile } from "./parsers.mjs";
 import { historyRoots, paths } from "./paths.mjs";
 import { openStore } from "./store.mjs";
 import { runAgentTask } from "./runner.mjs";
 
-const DAEMON_VERSION = "0.4.1";
+const DAEMON_VERSION = "0.4.2";
 const PROTOCOL_VERSION = 1;
 const RESCAN_MS = 60_000;
+const TASK_LOG_PAGE = 64_000;
 
 export async function startDaemon() {
   ensureDir(paths.home);
@@ -38,6 +40,27 @@ export async function startDaemon() {
     writeJsonAtomic(paths.status, state);
   };
   const log = (message) => { appendLog(paths.log, message); };
+  const taskRuns = new Map();
+  const validRunId = (runId) => typeof runId === "string" && /^[a-zA-Z0-9._-]{1,128}$/.test(runId);
+  const taskFiles = (runId) => ({
+    state: path.join(paths.runs, `${runId}.json`),
+    log: path.join(paths.runs, `${runId}.log`),
+  });
+  const persistTask = (task) => {
+    ensureDir(paths.runs);
+    writeJsonAtomic(taskFiles(task.runId).state, task);
+  };
+  const readTask = (runId, requestedOffset) => {
+    if (!validRunId(runId)) return null;
+    const files = taskFiles(runId);
+    const task = taskRuns.get(runId) || readJson(files.state, null);
+    if (!task) return null;
+    let raw = "";
+    try { raw = fs.readFileSync(files.log, "utf8"); } catch {}
+    const offset = Math.max(0, Math.min(raw.length, Math.floor(Number(requestedOffset) || 0)));
+    const chunk = raw.slice(offset, offset + TASK_LOG_PAGE);
+    return { ...task, log: chunk, offset, nextOffset: offset + chunk.length, logLength: raw.length };
+  };
   saveStatus();
   log(`daemon ${DAEMON_VERSION} starting; agents=${installedAgents.join(",") || "none"}`);
 
@@ -105,8 +128,8 @@ export async function startDaemon() {
   async function indexFile(agent, item) {
     const sessionId = path.basename(item.file);
     if (!store.needsIndex(agent, sessionId, item.mtime, item.size)) return false;
-    const raw = tailFile(item.file);
-    store.indexRaw({ agent, sessionId, source: item.file, raw, mtime: item.mtime, size: item.size });
+    const parsed = await parseSessionFile(agent, item.file);
+    store.indexParsed({ agent, sessionId, source: item.file, parsed, mtime: item.mtime, size: item.size });
     return true;
   }
 
@@ -152,7 +175,7 @@ export async function startDaemon() {
         if (requested.length) {
           for (const item of requested) await readOpencodeSession(item.sessionId, item.cwd);
         } else {
-          const listed = run("opencode", ["session", "list", "-n", "500", "--format", "json"], { timeout: 20_000, maxBuffer: 20_000_000 });
+          const listed = run("opencode", ["session", "list", "--format", "json"], { timeout: 20_000, maxBuffer: 20_000_000 });
           if (listed.ok) {
             let rows = [];
             try { rows = JSON.parse(listed.stdout); } catch {}
@@ -176,7 +199,10 @@ export async function startDaemon() {
   function sourceRaw(agent, sessionId) {
     const row = store.findSource(agent, sessionId);
     if (!row?.source || row.source.startsWith("opencode:")) return null;
-    try { return { raw: tailFile(row.source, 800_000), cwd: row.cwd || undefined }; } catch { return null; }
+    // Compatibility fetches are explicit reads. Return the complete source instead of
+    // silently changing their meaning to "the last N bytes"; normal 0.4 search/read
+    // traffic is served from the normalized SQLite transcript and never ships raw logs.
+    try { return { raw: fs.readFileSync(row.source, "utf8"), cwd: row.cwd || undefined }; } catch { return null; }
   }
 
   if (process.platform !== "win32") {
@@ -207,6 +233,9 @@ export async function startDaemon() {
       else if (request.command === "handoffs.get") {
         const handoff = store.getHandoff(request.id, request.consume === true);
         reply(handoff && handoff.target_agent === request.agent ? { ok: true, handoff } : { ok: false, error: "handoff not found" });
+      } else if (request.command === "tasks.get") {
+        const task = readTask(request.runId, request.offset);
+        reply(task ? { ok: true, task } : { ok: false, error: "task not found" });
       } else if (request.command === "shutdown") {
         reply({ ok: true, shuttingDown: true });
         setTimeout(shutdown, 25);
@@ -225,6 +254,47 @@ export async function startDaemon() {
   const send = (message) => {
     try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
   };
+  const startTask = (message) => {
+    if (!validRunId(message.runId)) {
+      send({ type: "event", runId: message.runId, kind: "failed", text: "Invalid task run id." });
+      return;
+    }
+    ensureDir(paths.runs);
+    const files = taskFiles(message.runId);
+    try { fs.writeFileSync(files.log, "", { mode: 0o600 }); } catch {}
+    const task = {
+      runId: message.runId,
+      agent: message.agent,
+      title: message.title,
+      cwd: message.cwd || null,
+      status: "starting",
+      sessionId: null,
+      startedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      message: null,
+    };
+    taskRuns.set(message.runId, task);
+    persistTask(task);
+    const emit = (kind, text, extra) => {
+      if (kind === "accepted") task.status = "running";
+      if (kind === "session") {
+        task.sessionId = text || null;
+        if (extra?.cwd) task.cwd = extra.cwd;
+      }
+      if (kind === "done" || kind === "failed") {
+        task.status = kind;
+        task.finishedAt = new Date().toISOString();
+        task.message = text || null;
+      }
+      task.updatedAt = new Date().toISOString();
+      persistTask(task);
+      send({ type: "event", runId: message.runId, kind, ...(text ? { text } : {}), ...(extra || {}) });
+    };
+    const observe = (stream, raw) => {
+      try { fs.appendFileSync(files.log, stream === "stderr" ? `\n[stderr] ${raw}` : raw, { mode: 0o600 }); } catch {}
+    };
+    runAgentTask(message, emit, observe);
+  };
   const scheduleReconnect = () => {
     if (reconnectTimer) return;
     const delay = Math.round(retry * (0.8 + Math.random() * 0.4));
@@ -285,7 +355,7 @@ export async function startDaemon() {
           return;
         }
         if (message.type === "task") {
-          runAgentTask(message, (kind, text, extra) => send({ type: "event", runId: message.runId, kind, ...(text ? { text } : {}), ...(extra || {}) }));
+          startTask(message);
         }
       });
       const dropped = (error) => {

package/lib/files.mjs

@@ -43,17 +43,3 @@ export function listJsonl(root) {
   }
   return found;
 }
-
-export function tailFile(file, cap = 2_000_000) {
-  const stat = fs.statSync(file);
-  const start = Math.max(0, stat.size - cap);
-  const length = stat.size - start;
-  const fd = fs.openSync(file, "r");
-  try {
-    const buffer = Buffer.alloc(length);
-    fs.readSync(fd, buffer, 0, length, start);
-    return buffer.toString("utf8");
-  } finally {
-    fs.closeSync(fd);
-  }
-}

package/lib/parsers.mjs

@@ -1,5 +1,8 @@
-// Fail-open normalizers for the four supported agents. The daemon owns this copy so
-// indexing never depends on a Harness tab or on code downloaded after installation.
+import fs from "node:fs";
+import readline from "node:readline";
+
+// Fail-open normalizers for the four supported agents. JSONL sources are streamed so
+// source-file size never decides which part of a conversation is remembered.
 
 const TITLE_MAX = 120;
 const TOOL_INPUT_CLIP = 100;
@@ -45,71 +48,98 @@ function contentText(content) {
   return parts.join("\n").trim();
 }
 
-function parseClaude(text) {
-  const records = parseLines(text).filter((row) => row.type === "user" || row.type === "assistant");
-  const byId = new Map(records.filter((row) => typeof row.uuid === "string").map((row) => [row.uuid, row]));
+function slimClaude(row) {
+  if (row?.type !== "user" && row?.type !== "assistant") return null;
+  return {
+    type: row.type,
+    uuid: typeof row.uuid === "string" ? row.uuid : null,
+    parentUuid: typeof row.parentUuid === "string" ? row.parentUuid : null,
+    timestamp: typeof row.timestamp === "string" ? row.timestamp : null,
+    cwd: typeof row.cwd === "string" ? row.cwd : null,
+    text: contentText(row.message?.content),
+  };
+}
+
+function finishClaude(records) {
+  const byId = new Map(records.filter((row) => row.uuid).map((row) => [row.uuid, row]));
   const chain = [];
   const seen = new Set();
   let cursor = records.at(-1);
   while (cursor) {
-    if (typeof cursor.uuid === "string") {
+    if (cursor.uuid) {
       if (seen.has(cursor.uuid)) break;
       seen.add(cursor.uuid);
     }
     chain.unshift(cursor);
-    cursor = typeof cursor.parentUuid === "string" ? byId.get(cursor.parentUuid) : undefined;
+    cursor = cursor.parentUuid ? byId.get(cursor.parentUuid) : undefined;
   }
   const source = chain.length >= records.length / 2 ? chain : records;
-  const messages = source.flatMap((row) => {
-    const textValue = contentText(row.message?.content);
-    return textValue ? [{ role: row.type === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
+  const messages = source.flatMap((row) => row.text ? [{
+    role: row.type === "user" ? "user" : "agent",
+    text: row.text,
+    ts: row.timestamp,
+  }] : []);
   return {
     meta: {
-      cwd: typeof records[0]?.cwd === "string" ? records[0].cwd : null,
-      startedAt: typeof records[0]?.timestamp === "string" ? records[0].timestamp : null,
-      endedAt: typeof records.at(-1)?.timestamp === "string" ? records.at(-1).timestamp : null,
+      cwd: records.find((row) => row.cwd)?.cwd || null,
+      startedAt: records.find((row) => row.timestamp)?.timestamp || null,
+      endedAt: [...records].reverse().find((row) => row.timestamp)?.timestamp || null,
     },
     messages,
   };
 }
 
+function parseClaude(text) {
+  return finishClaude(parseLines(text).map(slimClaude).filter(Boolean));
+}
+
+function finishCodex(meta, messages, startedAt, endedAt) {
+  return {
+    meta: { cwd: typeof meta?.cwd === "string" ? meta.cwd : null, startedAt, endedAt },
+    messages,
+  };
+}
+
 function parseCodex(text) {
-  const records = parseLines(text);
-  const meta = records.find((row) => row.type === "session_meta")?.payload || {};
-  const messages = records.flatMap((row) => {
+  let meta = {};
+  let startedAt = null;
+  let endedAt = null;
+  const messages = [];
+  for (const row of parseLines(text)) {
+    if (row.type === "session_meta" && row.payload && !Object.keys(meta).length) meta = row.payload;
+    if (typeof row.timestamp === "string") {
+      startedAt ||= row.timestamp;
+      endedAt = row.timestamp;
+    }
     const payload = row.type === "response_item" ? row.payload : null;
-    if (!payload || payload.type !== "message") return [];
+    if (!payload || payload.type !== "message") continue;
     const textValue = contentText(payload.content);
-    return textValue ? [{ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
-  const timestamps = records.map((row) => row.timestamp).filter((value) => typeof value === "string");
+    if (textValue) messages.push({ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  return finishCodex(meta, messages, startedAt, endedAt);
+}
+
+function finishPi(header, messages) {
   return {
     meta: {
-      cwd: typeof meta.cwd === "string" ? meta.cwd : null,
-      startedAt: timestamps[0] || null,
-      endedAt: timestamps.at(-1) || null,
+      cwd: typeof header?.cwd === "string" ? header.cwd : null,
+      startedAt: typeof header?.timestamp === "string" ? header.timestamp : null,
+      endedAt: messages.at(-1)?.ts || null,
     },
     messages,
   };
 }
 
 function parsePi(text) {
-  const records = parseLines(text);
-  const header = records.find((row) => row.type === "session") || {};
-  const messages = records.flatMap((row) => {
-    if (row.type !== "message") return [];
+  let header = {};
+  const messages = [];
+  for (const row of parseLines(text)) {
+    if (row.type === "session" && !Object.keys(header).length) header = row;
+    if (row.type !== "message") continue;
     const textValue = contentText(row.message?.content);
-    return textValue ? [{ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
-  });
-  return {
-    meta: {
-      cwd: typeof header.cwd === "string" ? header.cwd : null,
-      startedAt: typeof header.timestamp === "string" ? header.timestamp : null,
-      endedAt: messages.at(-1)?.ts || null,
-    },
-    messages,
-  };
+    if (textValue) messages.push({ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  return finishPi(header, messages);
 }
 
 function asIso(value) {
@@ -143,20 +173,74 @@ function parseOpencode(text) {
   };
 }
 
-const PARSERS = { "claude-code": parseClaude, codex: parseCodex, pi: parsePi, opencode: parseOpencode };
+function titleCandidate(message) {
+  if (message.role !== "user") return false;
+  const text = message.text.trim().toLowerCase();
+  if (text.length <= 2 || text.startsWith("[")) return false;
+  return !text.startsWith("<environment_context>")
+    && !text.startsWith("<permissions instructions>")
+    && !text.startsWith("<skills_instructions>");
+}
 
-export function parseSession(agent, raw) {
-  const parser = PARSERS[agent];
-  if (!parser) throw new Error(`unsupported agent: ${agent}`);
-  const { meta, messages } = parser(raw);
-  const firstUser = messages.find((message) => message.role === "user" && !message.text.startsWith("[") && message.text.trim().length > 2)
-    || messages.find((message) => message.role === "user");
+function normalize({ meta, messages }) {
+  const firstUser = messages.find(titleCandidate) || messages.find((message) => message.role === "user");
   return {
     meta: {
       ...meta,
       title: (firstUser?.text || "").replace(/\s+/g, " ").trim().slice(0, TITLE_MAX),
       messageCount: messages.length,
     },
-    transcript: messages.map((message) => `${message.role === "user" ? "User" : "Agent"}: ${message.text}`).join("\n\n").slice(0, 400_000),
+    transcript: messages.map((message) => `${message.role === "user" ? "User" : "Agent"}: ${message.text}`).join("\n\n"),
   };
 }
+
+const PARSERS = { "claude-code": parseClaude, codex: parseCodex, pi: parsePi, opencode: parseOpencode };
+
+export function parseSession(agent, raw) {
+  const parser = PARSERS[agent];
+  if (!parser) throw new Error(`unsupported agent: ${agent}`);
+  return normalize(parser(raw));
+}
+
+export async function parseSessionFile(agent, file) {
+  if (agent === "opencode") return parseSession(agent, await fs.promises.readFile(file, "utf8"));
+  if (!["claude-code", "codex", "pi"].includes(agent)) throw new Error(`unsupported agent: ${agent}`);
+
+  const claudeRecords = [];
+  const messages = [];
+  let codexMeta = {};
+  let piHeader = {};
+  let startedAt = null;
+  let endedAt = null;
+  const input = fs.createReadStream(file, { encoding: "utf8" });
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    if (agent === "claude-code") {
+      const slim = slimClaude(row);
+      if (slim) claudeRecords.push(slim);
+      continue;
+    }
+    if (agent === "codex") {
+      if (row.type === "session_meta" && row.payload && !Object.keys(codexMeta).length) codexMeta = row.payload;
+      if (typeof row.timestamp === "string") {
+        startedAt ||= row.timestamp;
+        endedAt = row.timestamp;
+      }
+      const payload = row.type === "response_item" ? row.payload : null;
+      if (!payload || payload.type !== "message") continue;
+      const textValue = contentText(payload.content);
+      if (textValue) messages.push({ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+      continue;
+    }
+    if (row.type === "session" && !Object.keys(piHeader).length) piHeader = row;
+    if (row.type !== "message") continue;
+    const textValue = contentText(row.message?.content);
+    if (textValue) messages.push({ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null });
+  }
+  if (agent === "claude-code") return normalize(finishClaude(claudeRecords));
+  if (agent === "codex") return normalize(finishCodex(codexMeta, messages, startedAt, endedAt));
+  return normalize(finishPi(piHeader, messages));
+}

package/lib/paths.mjs

@@ -14,6 +14,7 @@ export const paths = {
   status: path.join(harnessHome, "daemon-status.json"),
   socket: process.platform === "win32" ? "\\\\.\\pipe\\tryharness-daemon" : path.join(harnessHome, "daemon.sock"),
   log: path.join(harnessHome, "daemon.log"),
+  runs: path.join(harnessHome, "runs"),
   runtime: path.join(harnessHome, "runtime"),
   legacyBridgeConfig: path.join(harnessHome, "bridge.json"),
   legacySpool: path.join(harnessHome, "pending-sessions.json"),

package/lib/runner.mjs

@@ -1,56 +1,75 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 
 const running = new Set();
 
-function workingDirectory(requested) {
-  const home = os.homedir();
-  const resolved = !requested ? home : requested === "~" ? home : requested.startsWith("~/") ? path.join(home, requested.slice(2)) : requested;
-  return fs.existsSync(resolved) ? resolved : home;
+export function resolveWorkingDirectory(requested) {
+  if (!requested || !path.isAbsolute(requested)) throw new Error("Delegated tasks require an absolute working directory.");
+  let stat;
+  try { stat = fs.statSync(requested); }
+  catch { throw new Error(`Delegated task directory does not exist: ${requested}`); }
+  if (!stat.isDirectory()) throw new Error(`Delegated task working directory is not a directory: ${requested}`);
+  return requested;
 }
 
-export function runAgentTask(task, emit) {
+export function agentInvocation(task) {
+  if (task.agent === "claude-code") {
+    return {
+      command: "claude",
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions", "--name", `Harness: ${task.title}`],
+    };
+  }
+  if (task.agent === "codex") {
+    return {
+      command: "codex",
+      args: ["exec", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "-"],
+      stdin: task.brief,
+    };
+  }
+  // Pi has no permission prompts. --approve trusts project-local configuration for
+  // this non-interactive run; its complete built-in tool set remains enabled.
+  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", "-p", task.brief] };
+  if (task.agent === "opencode") {
+    return { command: "opencode", args: ["run", "--format", "json", "--auto", "--title", task.title, "--", task.brief] };
+  }
+  throw new Error(`Unsupported agent: ${task.agent}`);
+}
+
+export function runAgentTask(task, emit, observe = () => {}) {
   if (running.has(task.agent)) {
     emit("failed", `A ${task.agent} task is already running on this machine.`);
     return;
   }
-  running.add(task.agent);
+  let cwd;
+  let invocation;
+  try {
+    cwd = resolveWorkingDirectory(task.cwd);
+    invocation = agentInvocation(task);
+  } catch (error) {
+    emit("failed", error.message);
+    return;
+  }
   emit("accepted");
-  const cwd = workingDirectory(task.cwd);
   let child;
   try {
-    if (task.agent === "claude-code") {
-      child = spawn("claude", ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"], { cwd });
-    } else if (task.agent === "codex") {
-      const help = spawnSync("codex", ["exec", "--help"], { encoding: "utf8" });
-      const args = ["exec", "--json", "--sandbox", "workspace-write", "--skip-git-repo-check"];
-      if (String(help.stdout || "").includes("--approve-for-me")) args.push("--approve-for-me");
-      args.push("-");
-      child = spawn("codex", args, { cwd });
-      child.stdin.end(task.brief);
-    } else if (task.agent === "pi") {
-      child = spawn("pi", ["--mode", "json", "-p", task.brief], { cwd });
-    } else if (task.agent === "opencode") {
-      child = spawn("opencode", ["run", "--format", "json", "--title", task.title, "--", task.brief], { cwd });
-    } else {
-      running.delete(task.agent);
-      emit("failed", `Unsupported agent: ${task.agent}`);
-      return;
-    }
+    child = spawn(invocation.command, invocation.args, { cwd });
+    if (invocation.stdin !== undefined) child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(task.agent);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);
     return;
   }
+  running.add(task.agent);
 
   let resultText = "";
   let tail = "";
   let buffer = "";
   let sessionReported = false;
   child.stdout?.on("data", (chunk) => {
-    buffer += String(chunk);
+    const raw = String(chunk);
+    observe("stdout", raw);
+    buffer += raw;
     const lines = buffer.split("\n");
     buffer = lines.pop() || "";
     for (const line of lines) {
@@ -76,7 +95,11 @@ export function runAgentTask(task, emit) {
       if (progress?.trim()) emit("progress", progress.trim().slice(0, 200));
     }
   });
-  child.stderr?.on("data", (chunk) => { tail = (tail + "\n" + String(chunk)).slice(-4_000); });
+  child.stderr?.on("data", (chunk) => {
+    const raw = String(chunk);
+    observe("stderr", raw);
+    tail = (tail + "\n" + raw).slice(-4_000);
+  });
   child.on("close", (code) => {
     running.delete(task.agent);
     if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000));

package/lib/store.mjs

@@ -1,7 +1,8 @@
 import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
 
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 3;
+const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
 function bindings(values) {
@@ -33,6 +34,7 @@ export function openStore(file) {
       message_count integer not null default 0,
       source_mtime real not null default 0,
       source_size integer not null default 0,
+      parser_version integer not null default 0,
       transcript text not null default '',
       indexed_at text not null,
       primary key(agent, session_id)
@@ -58,6 +60,10 @@ export function openStore(file) {
       consumed_at text
     );
   `);
+  const sessionColumns = new Set(db.all("pragma table_info(sessions)").map((column) => column.name));
+  if (!sessionColumns.has("parser_version")) {
+    db.exec("alter table sessions add column parser_version integer not null default 0");
+  }
 
   const statements = [];
   const prepare = (sql) => {
@@ -77,20 +83,21 @@ export function openStore(file) {
     const bound = bindings(values);
     return bound === undefined ? db[method](sql) : db[method](sql, bound);
   };
-  const existing = prepare("select source_mtime, source_size from sessions where agent = ? and session_id = ?");
+  const existing = prepare("select source_mtime, source_size, parser_version from sessions where agent = ? and session_id = ?");
   const upsert = prepare(`
-    insert into sessions(agent, session_id, source, cwd, title, started_at, ended_at, message_count, source_mtime, source_size, transcript, indexed_at)
-    values(@agent, @sessionId, @source, @cwd, @title, @startedAt, @endedAt, @messageCount, @mtime, @size, @transcript, @indexedAt)
+    insert into sessions(agent, session_id, source, cwd, title, started_at, ended_at, message_count, source_mtime, source_size, parser_version, transcript, indexed_at)
+    values(@agent, @sessionId, @source, @cwd, @title, @startedAt, @endedAt, @messageCount, @mtime, @size, @parserVersion, @transcript, @indexedAt)
     on conflict(agent, session_id) do update set
       source=excluded.source, cwd=excluded.cwd, title=excluded.title,
       started_at=excluded.started_at, ended_at=excluded.ended_at,
       message_count=excluded.message_count, source_mtime=excluded.source_mtime,
-      source_size=excluded.source_size, transcript=excluded.transcript,
+      source_size=excluded.source_size, parser_version=excluded.parser_version,
+      transcript=excluded.transcript,
       indexed_at=excluded.indexed_at
   `);
   const deleteSearch = prepare("delete from session_fts where agent = ? and session_id = ?");
   const insertSearch = prepare("insert into session_fts(agent, session_id, title, cwd, transcript) values(?, ?, ?, ?, ?)");
-  const indexParsed = (record) => {
+  const persistParsed = (record) => {
     db.exec("begin immediate");
     try {
       upsert.run(record);
@@ -114,15 +121,29 @@ export function openStore(file) {
     db,
     needsIndex(agent, sessionId, mtime, size) {
       const row = existing.get(agent, sessionId);
-      return !row || Number(row.source_mtime) !== Number(mtime) || Number(row.source_size) !== Number(size);
+      return !row
+        || Number(row.source_mtime) !== Number(mtime)
+        || Number(row.source_size) !== Number(size)
+        || Number(row.parser_version) !== INDEX_FORMAT_VERSION;
     },
     indexRaw({ agent, sessionId, source = null, raw, mtime = Date.now(), size = raw.length, cwd }) {
       const parsed = parseSession(agent, raw);
-      indexParsed({
+      persistParsed({
+        agent, sessionId, source, cwd: cwd || parsed.meta.cwd || null,
+        title: parsed.meta.title, startedAt: parsed.meta.startedAt,
+        endedAt: parsed.meta.endedAt, messageCount: parsed.meta.messageCount,
+        mtime, size, parserVersion: INDEX_FORMAT_VERSION,
+        transcript: parsed.transcript, indexedAt: new Date().toISOString(),
+      });
+      return parsed.meta;
+    },
+    indexParsed({ agent, sessionId, source = null, parsed, mtime, size, cwd }) {
+      persistParsed({
         agent, sessionId, source, cwd: cwd || parsed.meta.cwd || null,
         title: parsed.meta.title, startedAt: parsed.meta.startedAt,
         endedAt: parsed.meta.endedAt, messageCount: parsed.meta.messageCount,
-        mtime, size, transcript: parsed.transcript, indexedAt: new Date().toISOString(),
+        mtime, size, parserVersion: INDEX_FORMAT_VERSION,
+        transcript: parsed.transcript, indexedAt: new Date().toISOString(),
       });
       return parsed.meta;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "One-command local daemon for Harness memory, coding-agent history, handoffs, and delegated tasks.",
   "bin": {
     "tryharness": "cli.mjs"