harlay 0.1.3 → 0.2.1

package/dist/harlay.mjs

@@ -27,84 +27,7 @@ var LaunchError = class extends HarlayError {
   written;
 };
 
-// ../core/src/launch/launchers.ts
-import { execFile } from "node:child_process";
-import { chmod, mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
-var pexec = promisify(execFile);
-var HANDOFF_PROMPT = "Read .harlay/HANDOFF.md and continue the task.";
-var DEFAULT_MODES = { "claude-code": "app", codex: "app", cursor: "app" };
-var PROMPT_LIMIT = {
-  "claude-code": { app: 6e3, terminal: 1e5 },
-  codex: { app: 6e3, terminal: 1e5 },
-  cursor: { app: 9900, terminal: 1e5 }
-};
-function promptFits(target, mode, prompt) {
-  const length = mode === "app" ? encodeURIComponent(prompt).length : prompt.length;
-  return length <= PROMPT_LIMIT[target][mode];
-}
-var defaultRunner = {
-  async open(args) {
-    await pexec("/usr/bin/open", args);
-  },
-  async writeExecutable(path, content) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, content, { mode: 493 });
-    await chmod(path, 493);
-  },
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
-};
-function shq(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-var enc = encodeURIComponent;
-function planLaunch(o) {
-  if (o.mode === "app") {
-    switch (o.target) {
-      case "claude-code":
-        return { target: o.target, mode: o.mode, steps: [{ kind: "open", args: [`claude://code/new?folder=${enc(o.cwd)}&q=${enc(o.prompt)}`] }] };
-      case "codex":
-        return { target: o.target, mode: o.mode, steps: [{ kind: "open", args: [`codex://threads/new?path=${enc(o.cwd)}&prompt=${enc(o.prompt)}`] }] };
-      case "cursor":
-        return {
-          target: o.target,
-          mode: o.mode,
-          steps: [
-            { kind: "open", args: ["-a", "Cursor", o.cwd] },
-            { kind: "wait", ms: 1500 },
-            { kind: "open", args: [`cursor://anysphere.cursor-deeplink/prompt?text=${enc(o.prompt)}`] }
-          ]
-        };
-    }
-  }
-  const bin = o.binaries[o.target];
-  if (!bin) throw new HarlayError(`${TOOL_LABEL[o.target]} CLI not found. Install it or switch ${TOOL_LABEL[o.target]} to app mode.`);
-  const argv = o.target === "codex" ? [bin, "-C", o.cwd, o.prompt] : o.target === "cursor" ? [bin, "--workspace", o.cwd, o.prompt] : [bin, o.prompt];
-  const path = join(o.scriptDir, `continue-${o.target}.command`);
-  const content = `#!/bin/zsh -l
-cd -- ${shq(o.cwd)} || exit 1
-exec ${argv.map(shq).join(" ")}
-`;
-  return {
-    target: o.target,
-    mode: o.mode,
-    steps: [
-      { kind: "script", path, content },
-      { kind: "open", args: ["-a", o.terminalApp, path] }
-    ]
-  };
-}
-async function executeLaunch(plan, runner = defaultRunner) {
-  for (const step of plan.steps) {
-    if (step.kind === "open") await runner.open(step.args);
-    else if (step.kind === "script") await runner.writeExecutable(step.path, step.content);
-    else await runner.sleep(step.ms);
-  }
-}
-
 // ../core/src/util/text.ts
-var CHARS_PER_TOKEN = 4;
 var isHigh = (c) => c >= 55296 && c <= 56319;
 var isLow = (c) => c >= 56320 && c <= 57343;
 function tail(s, maxChars) {
@@ -124,29 +47,45 @@ function oneLine(s, max = 120) {
   if (end > 0 && isHigh(t.charCodeAt(end - 1))) end--;
   return t.slice(0, end) + "\u2026";
 }
-function wordCount(s) {
-  return s.split(/\s+/).filter(Boolean).length;
-}
 function clipWords(s, max) {
   const w = s.split(/\s+/).filter(Boolean);
   return w.length <= max ? w.join(" ") : w.slice(0, max).join(" ") + " \u2026";
 }
-function splitSentences(s) {
-  return s.split(/(?<=[.!?])\s+|\n+/).map((x) => x.trim()).filter(Boolean);
-}
 var CONTEXT_BLOCK_RE = /<(ide_opened_file|ide_selection|artifact-view-context|artifact-content-authored-by-others)\b[^>]*?(?:\/>|>[\s\S]*?<\/\1\s*>)/g;
 var MACHINE_TAG_RE = /^<(command-name|command-message|command-args|local-command-stdout|local-command-stderr|local-command-caveat|task-notification|bash-input|bash-stdout|bash-stderr|environment_context|user_instructions)\b/;
+var CODEX_REQUEST_RE = /^## My request:[ \t]*\n/m;
 function cleanPrompt(raw) {
   let s = raw.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<!--[\s\S]*?-->/g, "").replace(CONTEXT_BLOCK_RE, "").trim();
   const query = /<user_query>([\s\S]*?)<\/user_query>/.exec(s);
   if (query) s = query[1].trim();
+  const request = CODEX_REQUEST_RE.exec(s);
+  if (request) s = s.slice(request.index + request[0].length).trim();
   if (MACHINE_TAG_RE.test(s)) return null;
   return s ? s : null;
 }
+var LEGACY_HANDOFF_PROMPT = "Read .harlay/HANDOFF.md and continue the task.";
 var HANDOFF_TAG = '<handoff from="';
 var HANDOFF_END = "</handoff>";
 var CLOSING_RE = /^\s*Continue from (?:the most recent user message|where it stopped)\. Start with the next concrete step\./;
 var HANDOFF_ID_RE = /Only if you need more: \.harlay\/handoffs\/([^/\s]+)\//g;
+var HARLAY_FILE_ID_RE = /"schema":\s*"harlay\/handoff@\d+",\s*(?:\d+\s+)?"id":\s*"([^"\\]+)"/;
+var HARLAY_FILE_END_RE = /"endOfHandoff":\s*"([^"\\]+)"\s*(?:\d+\s+)?\}\s*$/;
+function handoffIdIn(text) {
+  return HARLAY_FILE_ID_RE.exec(text)?.[1] ?? HARLAY_FILE_END_RE.exec(text)?.[1] ?? [...text.matchAll(HANDOFF_ID_RE)].at(-1)?.[1] ?? null;
+}
+var HARLAY_PROMPT_RE = /^\s*(?:this is the context from harlay:?|continue in harlay)(?:[ \t]+(?:[@＠]"?(?:[^\n"]*\/)?(?:\.harlay\/HANDOFF\.md|[^\s/"]*\.harlay)"?|\[[@＠]?[^\]\n]*\.harlay\]\([^)\n]*\))(?=[\s,;:!?)]|\.(?!\w)|$)|[.!]?[ \t]*(?=\r?\n|$)|[.,;:!](?=\s))/i;
+var HARLAY_FILE_RE = /^\s*(?:this is the context from harlay:?|continue in harlay)[ \t]+(?:[@＠]"(\/[^\n"]*\.harlay)"|[@＠](\/[^\n"]*?\.harlay)(?=[\s,;:!?)]|\.(?!\w)|$)|\[[@＠]?[^\]\n]*\.harlay\]\((?:file:\/\/)?(\/[^)\n]*\.harlay)\))/i;
+function harlayFileIn(p) {
+  const m = HARLAY_FILE_RE.exec(p);
+  if (!m) return null;
+  const quotedOrBare = m[1] ?? m[2];
+  if (quotedOrBare) return quotedOrBare;
+  try {
+    return decodeURIComponent(m[3]);
+  } catch {
+    return m[3];
+  }
+}
 function splitHandoffPrompt(p) {
   const start = p.indexOf(HANDOFF_TAG);
   const end = p.lastIndexOf(HANDOFF_END);
@@ -156,7 +95,9 @@ function splitHandoffPrompt(p) {
     const id = [...p.slice(start, end).matchAll(HANDOFF_ID_RE)].at(-1)?.[1] ?? null;
     return { handoff: true, rest: [before, after].filter(Boolean).join("\n\n"), id };
   }
-  if (p.trimStart().startsWith(HANDOFF_TAG) || p.trim() === HANDOFF_PROMPT) return { handoff: true, rest: "", id: null };
+  if (p.trimStart().startsWith(HANDOFF_TAG) || p.trim() === LEGACY_HANDOFF_PROMPT) return { handoff: true, rest: "", id: null };
+  const m = HARLAY_PROMPT_RE.exec(p);
+  if (m) return { handoff: true, rest: p.slice(m[0].length).replace(/^[.,;:!?)]+/, "").trim(), id: null };
   return { handoff: false, rest: p, id: null };
 }
 var OSC_RE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
@@ -171,12 +112,14 @@ function slugify(s, max = 40) {
 }
 
 // ../core/src/sources/claude.ts
-import { readFile, stat as stat2 } from "node:fs/promises";
-import { basename, join as join3, relative, sep } from "node:path";
+import { readFile as readFile3, stat as stat4 } from "node:fs/promises";
+import { basename as basename3, join as join4, relative, sep } from "node:path";
 
 // ../core/src/util/files.ts
+import { createReadStream } from "node:fs";
 import { open, readdir, stat } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
 async function listSessionFiles(root, accept) {
   let names;
   try {
@@ -186,7 +129,7 @@ async function listSessionFiles(root, accept) {
   }
   const out = [];
   for (const name of names) {
-    const path = join2(root, name);
+    const path = join(root, name);
     if (!accept(path)) continue;
     try {
       const s = await stat(path);
@@ -196,27 +139,14 @@ async function listSessionFiles(root, accept) {
   }
   return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
 }
-async function readFirstLine(file, maxBytes = 8 * 1024 * 1024) {
-  const fh = await open(file, "r");
+async function eachLine(file, each, maxBytes = 8 * 1024 * 1024) {
+  const input = createReadStream(file, { encoding: "utf8", end: maxBytes - 1 });
+  const lines2 = createInterface({ input, crlfDelay: Infinity });
   try {
-    const chunks = [];
-    const buf = Buffer.alloc(65536);
-    let total = 0;
-    while (total < maxBytes) {
-      const { bytesRead } = await fh.read(buf, 0, buf.length, total);
-      if (bytesRead === 0) break;
-      const slice = buf.subarray(0, bytesRead);
-      const nl = slice.indexOf(10);
-      if (nl >= 0) {
-        chunks.push(Buffer.from(slice.subarray(0, nl)));
-        return Buffer.concat(chunks).toString("utf8");
-      }
-      chunks.push(Buffer.from(slice));
-      total += bytesRead;
-    }
-    return chunks.length ? Buffer.concat(chunks).toString("utf8") : null;
+    for await (const line of lines2) if (each(line)) break;
   } finally {
-    await fh.close();
+    lines2.close();
+    input.destroy();
   }
 }
 
@@ -249,6 +179,445 @@ function blockText(content) {
   return parts.join("\n");
 }
 
+// ../core/src/sources/folder.ts
+import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2 } from "node:path";
+
+// ../core/src/brief/write.ts
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir as mkdir2, readFile, readdir as readdir2, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+
+// ../core/src/launch/launchers.ts
+import { execFile } from "node:child_process";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+import { promisify } from "node:util";
+var pexec = promisify(execFile);
+var HARLAY_PROMPT = "This is the context from Harlay";
+function launchPrompt(file) {
+  return `${HARLAY_PROMPT} @${/\s/.test(file) ? `"${file}"` : file}`;
+}
+var DEFAULT_MODES = { "claude-code": "app", codex: "app", cursor: "app" };
+var defaultRunner = {
+  async open(args) {
+    await pexec("/usr/bin/open", args);
+  },
+  async writeExecutable(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, { mode: 493 });
+    await chmod(path, 493);
+  },
+  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+};
+function shq(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+var enc = encodeURIComponent;
+function planLaunch(o) {
+  if (o.mode === "app") {
+    switch (o.target) {
+      case "claude-code":
+        return { target: o.target, mode: o.mode, steps: [{ kind: "open", args: [`claude://code/new?folder=${enc(o.cwd)}&q=${enc(o.prompt)}`] }] };
+      case "codex":
+        return { target: o.target, mode: o.mode, steps: [{ kind: "open", args: [`codex://threads/new?path=${enc(o.cwd)}&prompt=${enc(o.prompt)}`] }] };
+      case "cursor":
+        return {
+          target: o.target,
+          mode: o.mode,
+          steps: [
+            { kind: "open", args: ["-a", "Cursor", o.cwd] },
+            { kind: "wait", ms: 1500 },
+            { kind: "open", args: [`cursor://anysphere.cursor-deeplink/prompt?text=${enc(o.prompt)}`] }
+          ]
+        };
+    }
+  }
+  const bin = o.binaries[o.target];
+  if (!bin) throw new HarlayError(`${TOOL_LABEL[o.target]} CLI not found. Install it or switch ${TOOL_LABEL[o.target]} to app mode.`);
+  const argv = o.target === "codex" ? [bin, "-C", o.cwd, o.prompt] : o.target === "cursor" ? [bin, "--workspace", o.cwd, o.prompt] : [bin, o.prompt];
+  const path = join2(o.scriptDir, `continue-${o.target}.command`);
+  const content = `#!/bin/zsh -l
+cd -- ${shq(o.cwd)} || exit 1
+exec ${argv.map(shq).join(" ")}
+`;
+  return {
+    target: o.target,
+    mode: o.mode,
+    steps: [
+      { kind: "script", path, content },
+      { kind: "open", args: ["-a", o.terminalApp, path] }
+    ]
+  };
+}
+async function executeLaunch(plan, runner = defaultRunner) {
+  for (const step of plan.steps) {
+    if (step.kind === "open") await runner.open(step.args);
+    else if (step.kind === "script") await runner.writeExecutable(step.path, step.content);
+    else await runner.sleep(step.ms);
+  }
+}
+
+// ../core/src/redact/redact.ts
+var mark = (kind) => `[REDACTED:${kind}]`;
+var whole = (kind) => () => mark(kind);
+var ENV_KEY = String.raw`(?<![A-Za-z0-9_])((?:export\s+)?(?=[A-Z][A-Z0-9_]*\s*[=:])(?:[A-Z][A-Z0-9_]*)?(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?)[A-Z0-9_]*\s*[=:]\s*)`;
+var CONFIG_KEY = String.raw`(?<![A-Za-z0-9_.-])((["']?)[A-Za-z0-9_.-]*?(?:password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key)\2[ \t]*[=:][ \t]*)`;
+var NOT_A_VALUE = String.raw`(?:true|false|null|none|undefined|await|new|this|self|string|number|boolean|object|unknown|bool)\b`;
+var RULES = [
+  { kind: "private_key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, replace: whole("private_key") },
+  { kind: "anthropic_key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}/g, replace: whole("anthropic_key") },
+  { kind: "openai_key", re: /\bsk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}/g, replace: whole("openai_key") },
+  { kind: "github_token", re: /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{22,})/g, replace: whole("github_token") },
+  { kind: "aws_access_key", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, replace: whole("aws_access_key") },
+  { kind: "stripe_key", re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}/g, replace: whole("stripe_key") },
+  { kind: "slack_token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, replace: whole("slack_token") },
+  { kind: "google_api_key", re: /\bAIza[0-9A-Za-z_-]{35}\b/g, replace: whole("google_api_key") },
+  { kind: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, replace: whole("jwt") },
+  { kind: "bearer", re: /\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/g, replace: (_m, g) => `${g[0]}${mark("bearer")}` },
+  // Env rules run before config rules so an uppercase env line is counted once, as env_secret.
+  {
+    kind: "env_secret",
+    re: new RegExp(String.raw`${ENV_KEY}(["'])(?!\[REDACTED:)[^\n"']{4,}\2`, "g"),
+    replace: (_m, g) => `${g[0]}${g[1]}${mark("env_secret")}${g[1]}`
+  },
+  {
+    kind: "env_secret",
+    re: new RegExp(String.raw`${ENV_KEY}(?!["']|\[REDACTED:)[^\s"']{4,}`, "g"),
+    replace: (_m, g) => `${g[0]}${mark("env_secret")}`
+  },
+  {
+    kind: "config_secret",
+    re: new RegExp(String.raw`${CONFIG_KEY}(["'${"`"}])(?!\[REDACTED:)(?:\\.|(?!\3)[^\n\\]){4,}\3`, "gi"),
+    replace: (_m, g) => `${g[0]}${g[2]}${mark("config_secret")}${g[2]}`
+  },
+  {
+    // The value is matched atomically (lookahead + backreference) so a call like `token = sign(x)` cannot
+    // backtrack into a shorter match.
+    kind: "config_secret",
+    re: new RegExp(String.raw`${CONFIG_KEY}(?!${NOT_A_VALUE})(?=([^\s"'${"`"},;(){}\[\]<>]{4,}))\3(?![(\[<])`, "gi"),
+    replace: (_m, g) => `${g[0]}${mark("config_secret")}`
+  },
+  {
+    kind: "url_credentials",
+    re: /\b([a-z][a-z0-9+.-]{0,30}:\/\/[^\s:/@]+:)(?!\[REDACTED:)[^\s/@]+(?=@)/gi,
+    replace: (_m, g) => `${g[0]}${mark("url_credentials")}`
+  }
+];
+function shannon(s) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const c of s) freq.set(c, (freq.get(c) ?? 0) + 1);
+  let h = 0;
+  for (const n of freq.values()) {
+    const p = n / s.length;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+var Redactor = class {
+  counts = {};
+  bump(kind) {
+    this.counts[kind] = (this.counts[kind] ?? 0) + 1;
+  }
+  apply(text) {
+    let out = text;
+    for (const rule of RULES) {
+      out = out.replace(rule.re, (match, ...rest) => {
+        this.bump(rule.kind);
+        const groups = rest.filter((x) => typeof x === "string");
+        return rule.replace(match, groups);
+      });
+    }
+    out = out.replace(/[A-Za-z0-9_\-+=]{32,}/g, (m) => {
+      if (!/\d/.test(m) || !/[a-z]/.test(m) || !/[A-Z]/.test(m) || shannon(m) < 4.3) return m;
+      this.bump("high_entropy");
+      return mark("high_entropy");
+    });
+    return out;
+  }
+};
+
+// ../core/src/brief/record.ts
+var RECORD_SCHEMA = "harlay/handoff@6";
+var MESSAGE_SCHEMAS = /* @__PURE__ */ new Set([RECORD_SCHEMA, "harlay/handoff@5"]);
+var OLD_SCHEMAS = /* @__PURE__ */ new Set(["harlay/handoff@4", "harlay/handoff@3", "harlay/handoff@2"]);
+var ACTIVITY_MAX = 6e3;
+var DIFF_MAX = 6e3;
+var FAILURE_OUTPUT_MAX = 3e3;
+var FAILURE_OUTPUT_LINES = 40;
+var MAX_UNCOMMITTED = 15;
+var REASON_TEXT = {
+  usage_limit: "it hit a usage limit",
+  crash: "it stopped with an error",
+  manual: "the user moved it here"
+};
+function harlayAbout(from, reason, root) {
+  return `Harlay context: the user was working with ${TOOL_LABEL[from]} in ${root}, and that chat stopped (${REASON_TEXT[reason]}). This file is what happened there: everything the user typed, word for word and oldest first (task.userMessages), where it stopped and their latest request (state), a command that still fails (lastFailure), how each command went (results), what the previous agent read, was given and looked up (references), and the recent activity and diff.`;
+}
+function harlayInstructions(root, createdAt, head) {
+  return [
+    "Reply with a short summary (the task and where it stands, two or three lines), then ask the user what they want to do next.",
+    "Don't run commands or change files until they answer.",
+    "The rules the user set and what they decided are in task.userMessages, in their own words: follow them.",
+    `Work in ${root}, even if this chat was opened somewhere else.`,
+    head ? `This file is a snapshot from ${createdAt}: before changing anything, check the repo still matches it (git status against files.uncommitted, git log -1 against repo.head ${head}).` : `This file is a snapshot from ${createdAt}: before changing anything, check the files still match it.`,
+    "Open what references lists only if you need it."
+  ];
+}
+var LINE_MAX = 500;
+function lines(s) {
+  const out = [];
+  for (const line of wellFormed(s).split("\n")) {
+    if (line.length <= LINE_MAX) {
+      out.push(line);
+      continue;
+    }
+    for (let i = 0; i < line.length; ) {
+      let end = Math.min(i + LINE_MAX, line.length);
+      if (end < line.length && /[\ud800-\udbff]/.test(line[end - 1])) end--;
+      out.push(line.slice(i, end));
+      i = end;
+    }
+  }
+  return out;
+}
+function tailLines(s, max) {
+  if (s.length <= max) return lines(s);
+  const cut = s.slice(s.length - max);
+  const nl = cut.indexOf("\n");
+  return ["\u2026(earlier lines cut)", ...lines(nl === -1 ? cut : cut.slice(nl + 1))];
+}
+function headLines(s, max, more) {
+  if (s.length <= max) return lines(s.replace(/\n$/, ""));
+  const cut = s.slice(0, max);
+  const nl = cut.lastIndexOf("\n");
+  return [...lines(nl === -1 ? cut : cut.slice(0, nl)), more];
+}
+function buildRecord(d, id, previousId, delivery, r) {
+  const a = (s) => wellFormed(r.apply(stripControl(s)));
+  const files = d.git?.files ?? [];
+  const failure = d.lastFailure ? a(d.lastFailure.output).split("\n").slice(-FAILURE_OUTPUT_LINES).join("\n") : "";
+  return {
+    harlay: harlayAbout(d.from.tool, d.from.reason, d.workdir),
+    // The id stays near the start: an agent may read only the file's first lines, and its copy is matched by the id.
+    schema: RECORD_SCHEMA,
+    id,
+    createdAt: d.createdAt.toISOString(),
+    instructions: harlayInstructions(d.workdir, d.createdAt.toISOString(), d.git?.head ?? null),
+    task: {
+      title: a(d.title),
+      originalGoal: d.originalGoal === null ? null : clipWords(a(d.originalGoal), 60),
+      userMessages: d.userMessages.map(a),
+      omittedMessages: d.omittedMessages
+    },
+    state: {
+      whereItStopped: d.whereItStopped === null ? null : a(d.whereItStopped),
+      lastRequest: d.lastRequest === null ? null : a(d.lastRequest),
+      todos: d.todos.map((t) => ({ text: oneLine(a(t.text), 200), status: t.status }))
+    },
+    lastFailure: d.lastFailure ? { cmd: clipWords(a(d.lastFailure.cmd), 30), exitCode: d.lastFailure.exitCode, output: tailLines(failure, FAILURE_OUTPUT_MAX) } : null,
+    results: d.results.map((x) => ({ ...x, cmd: clipWords(a(x.cmd), 30) })),
+    references: { read: d.references.read.map(a), attached: d.references.attached.map(a), urls: d.references.urls.map(a) },
+    files: {
+      touched: d.filesTouched.map(a),
+      uncommitted: files.slice(0, MAX_UNCOMMITTED).map((f) => ({ path: a(f.path), status: f.status, added: f.added, removed: f.removed })),
+      moreUncommitted: Math.max(0, files.length - MAX_UNCOMMITTED)
+    },
+    recentActivity: tailLines(a(d.transcript), ACTIVITY_MAX),
+    diff: d.git && d.git.diff ? headLines(a(d.git.diff), DIFF_MAX, "\u2026(diff cut; run git diff for the rest)") : null,
+    from: {
+      tool: d.from.tool,
+      model: d.from.model,
+      session: d.from.session,
+      reason: d.from.reason,
+      resetsAt: d.from.resetsAt ? d.from.resetsAt.toISOString() : null,
+      message: d.from.message === null ? null : a(d.from.message)
+    },
+    repo: { root: d.workdir, git: d.git !== null, branch: d.git?.branch ?? null, head: d.git?.head ?? null, dirtyFiles: files.length },
+    previous: previousId ? { id: previousId } : null,
+    delivery,
+    unknownRecords: d.unknownRecords,
+    endOfHandoff: id
+  };
+}
+var isStr = (v) => typeof v === "string";
+var isObj2 = (v) => typeof v === "object" && v !== null;
+var isStrs = (v) => Array.isArray(v) && v.every(isStr);
+function messagesOf(schema, task) {
+  if (MESSAGE_SCHEMAS.has(schema)) {
+    if (!isStrs(task.userMessages) || typeof task.omittedMessages !== "number") return null;
+    return { userMessages: task.userMessages, omittedMessages: task.omittedMessages };
+  }
+  const recent = task.recentUserMessages;
+  const rules = task.pinnedRules;
+  if (!isStrs(recent)) return null;
+  if (!Array.isArray(rules) || !rules.every((r) => isObj2(r) && isStr(r.text) && typeof r.message === "number")) return null;
+  const ruleTexts = rules.map((r) => r.text).filter((t) => !recent.some((m) => m.includes(t)));
+  return { userMessages: [...ruleTexts, ...recent], omittedMessages: 0 };
+}
+function validateRecord(raw) {
+  if (!isObj2(raw) || !(MESSAGE_SCHEMAS.has(raw.schema) || OLD_SCHEMAS.has(raw.schema)) || !isStr(raw.id) || !isStr(raw.createdAt)) return null;
+  const { task, from } = raw;
+  if (!isObj2(from) || !isTool(from.tool)) return null;
+  if (!isObj2(task) || !isStr(task.title) || !(task.originalGoal === null || isStr(task.originalGoal))) return null;
+  const messages = messagesOf(raw.schema, task);
+  if (!messages) return null;
+  const sent = isObj2(raw.delivery) ? raw.delivery : isObj2(raw.prompt) ? raw.prompt : null;
+  return {
+    id: raw.id,
+    task: { title: task.title, originalGoal: task.originalGoal, ...messages },
+    target: sent && isTool(sent.target) ? sent.target : null,
+    root: isObj2(raw.repo) && isStr(raw.repo.root) ? raw.repo.root : null
+  };
+}
+
+// ../core/src/brief/write.ts
+function handoffStore(home) {
+  return join3(home, "Library", "Application Support", "Harlay", "handoffs");
+}
+function repoFolder(store, root) {
+  return join3(store, `${slugify(basename(root), 30)}-${createHash("sha256").update(root).digest("hex").slice(0, 8)}`);
+}
+var LEGACY_FILE = "handoff.harlay";
+async function readHandoffState(workdir) {
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(join3(workdir, ".harlay", "state.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const s = raw;
+  if (s.harlay !== 1 || typeof s.lastId !== "string" || typeof s.title !== "string") return null;
+  if (s.goal !== null && typeof s.goal !== "string") return null;
+  return { harlay: 1, lastId: s.lastId, goal: s.goal, title: s.title };
+}
+async function readIfExists(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseRecord(raw) {
+  try {
+    return validateRecord(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function toPrevious(rec) {
+  const { task } = rec;
+  return {
+    id: rec.id,
+    goal: task.originalGoal,
+    title: task.title,
+    userMessages: task.userMessages,
+    omittedMessages: task.omittedMessages,
+    target: rec.target
+  };
+}
+async function newestIn(dir) {
+  let names;
+  try {
+    names = await readdir2(dir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of names) {
+    if (!name.endsWith(".harlay") || name.startsWith(".")) continue;
+    const file = join3(dir, name);
+    try {
+      const at = (await stat2(file)).mtimeMs;
+      if (!best || at > best.at) best = { file, at };
+    } catch {
+    }
+  }
+  return best?.file ?? null;
+}
+async function readPreviousHandoff(store, workdir) {
+  const newest = await newestIn(repoFolder(store, workdir));
+  for (const file of newest ? [newest] : [join3(workdir, LEGACY_FILE), join3(workdir, ".harlay", "handoff.json")]) {
+    const raw = await readIfExists(file);
+    if (raw === null) continue;
+    const rec = parseRecord(raw);
+    return rec ? toPrevious(rec) : null;
+  }
+  const state = await readHandoffState(workdir);
+  return state ? { id: state.lastId, goal: state.goal, title: state.title, userMessages: [], omittedMessages: 0, target: null } : null;
+}
+function addCounts(a, b) {
+  const out = { ...a };
+  for (const [k, n] of Object.entries(b)) out[k] = (out[k] ?? 0) + n;
+  return out;
+}
+var writing = /* @__PURE__ */ new Map();
+function writeHandoff(d, o) {
+  const dir = repoFolder(o.store, d.workdir);
+  const run2 = (writing.get(dir) ?? Promise.resolve()).catch(() => void 0).then(() => write(d, o, dir));
+  writing.set(dir, run2);
+  void run2.finally(() => {
+    if (writing.get(dir) === run2) writing.delete(dir);
+  }).catch(() => void 0);
+  return run2;
+}
+async function exists(file) {
+  try {
+    await stat2(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function write(d, o, dir) {
+  await mkdir2(dir, { recursive: true });
+  const tmp = join3(dir, `.tmp-${process.pid}-${randomUUID().slice(0, 8)}.harlay`);
+  try {
+    for (let n = 1; ; n++) {
+      const id = n === 1 ? d.baseId : `${d.baseId}-${n}`;
+      const path = join3(dir, `${id}.harlay`);
+      if (await exists(path)) continue;
+      const r = new Redactor();
+      const prompt = launchPrompt(path);
+      const record = buildRecord(d, id, o.previousId, { target: o.target, mode: o.mode, prompt }, r);
+      await writeFile2(tmp, JSON.stringify(record, null, 2) + "\n");
+      try {
+        await link(tmp, path);
+      } catch (e) {
+        if (e.code === "EEXIST") continue;
+        throw e;
+      }
+      return { id, path, prompt, redactions: addCounts(d.redactions ?? {}, r.counts) };
+    }
+  } finally {
+    await rm(tmp, { force: true });
+  }
+}
+
+// ../core/src/sources/folder.ts
+async function isDir(p) {
+  try {
+    return (await stat3(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function handoffRepo(file) {
+  let raw = null;
+  try {
+    raw = await readFile2(file, "utf8");
+  } catch {
+  }
+  const root = raw === null ? null : parseRecord(raw)?.root;
+  if (root && await isDir(root)) return root;
+  return basename2(file) === LEGACY_FILE && await isDir(dirname2(file)) ? dirname2(file) : null;
+}
+async function sessionFolder(opened, firstPrompt2) {
+  const file = firstPrompt2 === null ? null : harlayFileIn(firstPrompt2);
+  return (file && await handoffRepo(file)) ?? opened;
+}
+
 // ../core/src/sources/todos.ts
 var STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "cancelled"]);
 function applyTodoWrite(current, input) {
@@ -269,6 +638,14 @@ function applyTodoWrite(current, input) {
 
 // ../core/src/sources/claude.ts
 var OUTPUT_TAIL = 2e4;
+var NOT_RUN_RE = /^(?:Error: )?(?:This command requires approval|The user doesn't want to (?:proceed with this tool use|take this action)|Permission for this action was denied|Permission to use \S+ .*has been denied)/;
+var HANDOFF_FILE_RE = /\.harlay$|\.harlay\/(?:handoffs\/[^/]+\/)?HANDOFF\.md$/;
+function claudeBriefId(a) {
+  if (!isObj(a) || a.type !== "file" || typeof a.filename !== "string" || !HANDOFF_FILE_RE.test(a.filename)) return null;
+  const c = a.content;
+  const text = isObj(c) && isObj(c.file) && typeof c.file.content === "string" ? c.file.content : typeof c === "string" ? c : "";
+  return handoffIdIn(text);
+}
 function claudeHalt(record) {
   if (!isObj(record) || record.type !== "assistant" || record.isApiErrorMessage !== true) return null;
   if (record.error !== "rate_limit" && record.apiErrorStatus !== 429) return null;
@@ -281,16 +658,32 @@ function normalizeClaude(records, ref, invalid = 0) {
   const timeline = [];
   const pendingBash = /* @__PURE__ */ new Map();
   const pendingWrite = /* @__PURE__ */ new Map();
+  const pendingEdit = /* @__PURE__ */ new Map();
+  const pushEdit = (id, edit) => {
+    const item = { kind: "edit", edit };
+    timeline.push(item);
+    if (id) pendingEdit.set(id, item);
+  };
   let todos = null;
   let halt = null;
   let model = null;
   let unknown = invalid;
+  const handoffIds = [];
   for (const rec of records) {
     if (!isObj(rec) || typeof rec.type !== "string") {
       unknown++;
       continue;
     }
     if (rec.isSidechain === true) continue;
+    if (rec.type === "attachment") {
+      const id = claudeBriefId(rec.attachment);
+      if (id && !handoffIds.includes(id)) handoffIds.push(id);
+      const a = rec.attachment;
+      if (!id && isObj(a) && a.type === "file" && typeof a.filename === "string" && !HANDOFF_FILE_RE.test(a.filename)) {
+        timeline.push({ kind: "read", path: a.filename, how: "attached" });
+      }
+      continue;
+    }
     if (rec.type === "assistant") {
       const h = claudeHalt(rec);
       if (h) {
@@ -314,15 +707,31 @@ function normalizeClaude(records, ref, invalid = 0) {
             if (c) pendingBash.set(id, c);
             break;
           }
-          case "Edit":
+          case "Edit": {
+            const p = str(input.file_path);
+            const before = str(input.old_string);
+            const after = str(input.new_string);
+            if (p) pushEdit(id, before !== null && after !== null ? { path: p, kind: "modify", before, after } : { path: p, kind: "modify" });
+            break;
+          }
           case "MultiEdit": {
             const p = str(input.file_path);
-            if (p) timeline.push({ kind: "edit", edit: { path: p, kind: "modify" } });
+            if (p) pushEdit(id, { path: p, kind: "modify" });
+            break;
+          }
+          case "Read": {
+            const p = str(input.file_path);
+            if (p) timeline.push({ kind: "read", path: p });
+            break;
+          }
+          case "WebFetch": {
+            const u = str(input.url);
+            if (u) timeline.push({ kind: "read", path: u, how: "fetched" });
             break;
           }
           case "NotebookEdit": {
             const p = str(input.notebook_path);
-            if (p) timeline.push({ kind: "edit", edit: { path: p, kind: "modify" } });
+            if (p) pushEdit(id, { path: p, kind: "modify" });
             break;
           }
           case "Write": {
@@ -330,7 +739,7 @@ function normalizeClaude(records, ref, invalid = 0) {
             if (p) {
               const edit = { path: p, kind: "modify" };
               pendingWrite.set(id, edit);
-              timeline.push({ kind: "edit", edit });
+              pushEdit(id, edit);
             }
             break;
           }
@@ -356,6 +765,11 @@ function normalizeClaude(records, ref, invalid = 0) {
         if (b.type === "text" && typeof b.text === "string") texts.push(b.text);
         if (b.type !== "tool_result") continue;
         const id = str(b.tool_use_id) ?? "";
+        const e = pendingEdit.get(id);
+        if (e) {
+          pendingEdit.delete(id);
+          if (b.is_error === true) timeline.splice(timeline.lastIndexOf(e), 1);
+        }
         const w = pendingWrite.get(id);
         if (w) {
           pendingWrite.delete(id);
@@ -365,6 +779,10 @@ function normalizeClaude(records, ref, invalid = 0) {
         if (cmd === void 0) continue;
         pendingBash.delete(id);
         const content = blockText(b.content);
+        if (b.is_error === true && NOT_RUN_RE.test(content)) {
+          timeline.push({ kind: "command", run: { cmd, exitCode: null, output: tail(content, OUTPUT_TAIL) } });
+          continue;
+        }
         const code = /^Exit code (\d+)/.exec(content);
         const exitCode = code ? Number(code[1]) : b.is_error === true ? 1 : 0;
         const r = rec.toolUseResult;
@@ -377,14 +795,14 @@ function normalizeClaude(records, ref, invalid = 0) {
       }
     }
   }
-  return { ref, model, timeline, todos: todos ? [...todos.values()] : null, halt, usage: null, unknownRecords: unknown };
+  return { ref, model, timeline, todos: todos ? [...todos.values()] : null, halt, usage: null, unknownRecords: unknown, handoffIds };
 }
 async function loadDesktopTitles(dir) {
   const out = /* @__PURE__ */ new Map();
-  const files = await listSessionFiles(dir, (f) => basename(f).startsWith("local_") && f.endsWith(".json"));
+  const files = await listSessionFiles(dir, (f) => basename3(f).startsWith("local_") && f.endsWith(".json"));
   for (const f of files) {
     try {
-      const d = JSON.parse(await readFile(f.path, "utf8"));
+      const d = JSON.parse(await readFile3(f.path, "utf8"));
       if (isObj(d) && typeof d.cliSessionId === "string" && typeof d.title === "string" && d.title && !out.has(d.cliSessionId)) {
         out.set(d.cliSessionId, d.title);
       }
@@ -394,14 +812,14 @@ async function loadDesktopTitles(dir) {
   return out;
 }
 function createClaudeReader(o) {
-  const root = join3(o.home, ".claude", "projects");
-  const indexDir = join3(o.home, "Library", "Application Support", "Claude", "claude-code-sessions");
+  const root = join4(o.home, ".claude", "projects");
+  const indexDir = join4(o.home, "Library", "Application Support", "Claude", "claude-code-sessions");
   const isSessionFile = (file) => file.startsWith(root + sep) && file.endsWith(".jsonl") && relative(root, file).split(sep).length === 2;
   const cache = /* @__PURE__ */ new Map();
   async function refForFile(file, titles) {
     let st;
     try {
-      st = await stat2(file);
+      st = await stat4(file);
     } catch {
       return null;
     }
@@ -409,17 +827,20 @@ function createClaudeReader(o) {
     if (!entry || entry.size !== st.size || entry.mtimeMs !== st.mtimeMs) {
       let text;
       try {
-        text = await readFile(file, "utf8");
+        text = await readFile3(file, "utf8");
       } catch {
         return null;
       }
       let cwd = null;
       let custom = null;
       let ai = null;
-      for (const line of text.split("\n")) {
+      let first;
+      const lines2 = text.split("\n");
+      for (const line of lines2) {
         const wantCwd = cwd === null && line.includes('"cwd"');
         const wantTitle = line.includes('-title"');
-        if (!wantCwd && !wantTitle) continue;
+        const wantPrompt = first === void 0 && line.includes('"user"');
+        if (!wantCwd && !wantTitle && !wantPrompt) continue;
         let r;
         try {
           r = JSON.parse(line);
@@ -430,11 +851,26 @@ function createClaudeReader(o) {
         if (wantCwd && typeof r.cwd === "string") cwd = r.cwd;
         if (r.type === "custom-title" && typeof r.customTitle === "string") custom = r.customTitle;
         if (r.type === "ai-title" && typeof r.aiTitle === "string") ai = r.aiTitle;
+        if (wantPrompt && r.type === "user" && r.isMeta !== true && r.isSidechain !== true && r.isCompactSummary !== true && isObj(r.message)) {
+          first = cleanPrompt(blockText(r.message.content)) ?? void 0;
+        }
+      }
+      for (let i = lines2.length - 1; i >= 0; i--) {
+        if (!lines2[i].includes('"cwd"')) continue;
+        try {
+          const r = JSON.parse(lines2[i]);
+          if (isObj(r) && typeof r.cwd === "string") {
+            cwd = r.cwd;
+            break;
+          }
+        } catch {
+        }
       }
+      cwd = await sessionFolder(cwd, first ?? null);
       entry = { size: st.size, mtimeMs: st.mtimeMs, cwd, fileTitle: custom ?? ai, ref: null };
       cache.set(file, entry);
     }
-    const id = basename(file, ".jsonl");
+    const id = basename3(file, ".jsonl");
     const title = entry.fileTitle ?? (titles ?? await loadDesktopTitles(indexDir)).get(id) ?? null;
     if (!entry.ref || entry.ref.title !== title) entry.ref = { tool: "claude-code", id, file, cwd: entry.cwd, title, lastActivityAt: st.mtime };
     return entry.ref;
@@ -443,7 +879,7 @@ function createClaudeReader(o) {
     tool: "claude-code",
     root,
     isSessionFile,
-    idFromPath: (file) => isSessionFile(file) ? basename(file, ".jsonl") : null,
+    idFromPath: (file) => isSessionFile(file) ? basename3(file, ".jsonl") : null,
     refForFile: (file) => refForFile(file),
     async listSessions(limit = 20) {
       const files = await listSessionFiles(root, isSessionFile);
@@ -457,7 +893,7 @@ function createClaudeReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await readFile(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await readFile3(ref.file, "utf8"));
       return normalizeClaude(records, ref, invalid);
     },
     detect(record) {
@@ -470,11 +906,21 @@ function createClaudeReader(o) {
 }
 
 // ../core/src/sources/codex.ts
-import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
-import { basename as basename2, join as join4, sep as sep2 } from "node:path";
+import { readFile as readFile4, stat as stat5 } from "node:fs/promises";
+import { basename as basename4, join as join5, sep as sep2 } from "node:path";
 var OUTPUT_TAIL2 = 2e4;
 var ROLLOUT_ID_RE = /-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
 var KIND = { add: "create", update: "modify", delete: "delete" };
+function diffSides(diff) {
+  const before = [];
+  const after = [];
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("---") || line.startsWith("+++")) continue;
+    if (line.startsWith("-")) before.push(line.slice(1));
+    else if (line.startsWith("+")) after.push(line.slice(1));
+  }
+  return { before: before.join("\n"), after: after.join("\n") };
+}
 function codexCommand(command) {
   if (typeof command === "string") return command;
   if (!Array.isArray(command)) return "";
@@ -542,7 +988,8 @@ function normalizeCodex(records, ref, invalid = 0) {
       } else if (it.type === "FileChange" && isObj(it.changes)) {
         for (const [path, change] of Object.entries(it.changes)) {
           const t = isObj(change) ? str(change.type) : null;
-          timeline.push({ kind: "edit", edit: { path, kind: t && KIND[t] || "modify" } });
+          const diff = isObj(change) ? str(change.unified_diff) : null;
+          timeline.push({ kind: "edit", edit: { path, kind: t && KIND[t] || "modify", ...diff ? diffSides(diff) : {} } });
         }
       }
     } else if (p.type === "user_message") {
@@ -573,11 +1020,25 @@ function parseSessionMeta(line) {
   const id = str(p.id);
   return id ? { id, cwd: str(p.cwd) } : null;
 }
+function typedPrompt(line) {
+  if (!line.includes('"user_message"') && !line.includes('"UserMessage"')) return null;
+  let r;
+  try {
+    r = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isObj(r) || r.type !== "event_msg" || !isObj(r.payload)) return null;
+  const p = r.payload;
+  if (p.type === "user_message") return typeof p.message === "string" ? cleanPrompt(p.message) : null;
+  if (p.type === "item_completed" && isObj(p.item) && p.item.type === "UserMessage") return cleanPrompt(blockText(p.item.content));
+  return null;
+}
 async function loadTitles(file) {
   const out = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = await readFile2(file, "utf8");
+    text = await readFile4(file, "utf8");
   } catch {
     return out;
   }
@@ -587,28 +1048,34 @@ async function loadTitles(file) {
   return out;
 }
 function createCodexReader(o) {
-  const root = join4(o.home, ".codex", "sessions");
-  const indexFile = join4(o.home, ".codex", "session_index.jsonl");
-  const isSessionFile = (file) => file.startsWith(root + sep2) && basename2(file).startsWith("rollout-") && file.endsWith(".jsonl");
+  const root = join5(o.home, ".codex", "sessions");
+  const indexFile = join5(o.home, ".codex", "session_index.jsonl");
+  const isSessionFile = (file) => file.startsWith(root + sep2) && basename4(file).startsWith("rollout-") && file.endsWith(".jsonl");
   const cache = /* @__PURE__ */ new Map();
   async function refForFile(file, titles) {
     let st;
     try {
-      st = await stat3(file);
+      st = await stat5(file);
     } catch {
       return null;
     }
     let entry = cache.get(file);
     if (!entry || entry.size !== st.size || entry.mtimeMs !== st.mtimeMs) {
-      let first;
+      let meta = null;
+      let first = null;
+      let lines2 = 0;
       try {
-        first = await readFirstLine(file);
+        await eachLine(file, (line) => {
+          if (lines2++ === 0) return (meta = parseSessionMeta(line)) === null;
+          first = typedPrompt(line);
+          return first !== null;
+        });
       } catch {
         return null;
       }
-      const meta = first ? parseSessionMeta(first) : null;
       if (!meta) return null;
-      entry = { size: st.size, mtimeMs: st.mtimeMs, ...meta, ref: null };
+      const { id, cwd } = meta;
+      entry = { size: st.size, mtimeMs: st.mtimeMs, id, cwd: await sessionFolder(cwd, first), ref: null };
       cache.set(file, entry);
     }
     const title = (titles ?? await loadTitles(indexFile)).get(entry.id) ?? null;
@@ -619,7 +1086,7 @@ function createCodexReader(o) {
     tool: "codex",
     root,
     isSessionFile,
-    idFromPath: (file) => isSessionFile(file) ? ROLLOUT_ID_RE.exec(basename2(file))?.[1] ?? null : null,
+    idFromPath: (file) => isSessionFile(file) ? ROLLOUT_ID_RE.exec(basename4(file))?.[1] ?? null : null,
     refForFile: (file) => refForFile(file),
     async listSessions(limit = 20) {
       const files = await listSessionFiles(root, isSessionFile);
@@ -633,7 +1100,7 @@ function createCodexReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await readFile2(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await readFile4(ref.file, "utf8"));
       return normalizeCodex(records, ref, invalid);
     },
     detect(record) {
@@ -658,21 +1125,21 @@ function createCodexReader(o) {
 }
 
 // ../core/src/sources/cursor.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat4 } from "node:fs/promises";
-import { join as join5, relative as relative2, sep as sep3 } from "node:path";
+import { readdir as readdir3, readFile as readFile5, stat as stat6 } from "node:fs/promises";
+import { join as join6, relative as relative2, sep as sep3 } from "node:path";
 var norm = (name) => name.replace(/[^A-Za-z0-9]/g, "-");
 async function resolveCursorSlug(slug, rootDir = "/") {
   if (!slug || /^\d+$/.test(slug)) return null;
   async function walk(dir, rest, depth) {
     if (depth > 16) return null;
-    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => null);
+    const entries = await readdir3(dir, { withFileTypes: true }).catch(() => null);
     if (!entries) return null;
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const n = norm(e.name);
-      if (rest === n) return join5(dir, e.name);
+      if (rest === n) return join6(dir, e.name);
       if (rest.startsWith(n + "-")) {
-        const found = await walk(join5(dir, e.name), rest.slice(n.length + 1), depth + 1);
+        const found = await walk(join6(dir, e.name), rest.slice(n.length + 1), depth + 1);
         if (found) return found;
       }
     }
@@ -720,7 +1187,13 @@ function normalizeCursor(records, ref, invalid = 0) {
       const input = isObj(b.input) ? b.input : {};
       if (b.name === "StrReplace" || b.name === "Write") {
         const paths = [str(input.path), ...Array.isArray(input.paths) ? input.paths.map(str) : []].filter((x) => !!x);
-        for (const path of paths) timeline.push({ kind: "edit", edit: { path, kind: "modify" } });
+        const before = b.name === "StrReplace" ? str(input.old_string) : null;
+        const after = b.name === "StrReplace" ? str(input.new_string) : null;
+        const sides = before !== null && after !== null && paths.length === 1 ? { before, after } : {};
+        for (const path of paths) timeline.push({ kind: "edit", edit: { path, kind: "modify", ...sides } });
+      } else if (b.name === "Read") {
+        const path = str(input.path) ?? str(input.file_path);
+        if (path) timeline.push({ kind: "read", path });
       } else if (b.name === "Shell") {
         const cmd = str(input.command);
         if (cmd) timeline.push({ kind: "command", run: { cmd, exitCode: null, output: "" } });
@@ -732,7 +1205,7 @@ function normalizeCursor(records, ref, invalid = 0) {
   return { ref, model: null, timeline, todos: todos ? [...todos.values()] : null, halt, usage: null, unknownRecords: unknown };
 }
 function createCursorReader(o) {
-  const root = join5(o.home, ".cursor", "projects");
+  const root = join6(o.home, ".cursor", "projects");
   const slugCache = /* @__PURE__ */ new Map();
   const cwdFor = (slug) => {
     let p = slugCache.get(slug);
@@ -753,7 +1226,7 @@ function createCursorReader(o) {
     const parts = relative2(root, file).split(sep3);
     let st;
     try {
-      st = await stat4(file);
+      st = await stat6(file);
     } catch {
       return null;
     }
@@ -761,14 +1234,16 @@ function createCursorReader(o) {
     if (hit && hit.size === st.size && hit.mtimeMs === st.mtimeMs) return hit.ref;
     let text;
     try {
-      text = await readFile3(file, "utf8");
+      text = await readFile5(file, "utf8");
     } catch {
       return null;
     }
     let title = null;
+    let first = null;
     for (const r of parseJsonLines(text).records) {
       if (isObj(r) && r.role === "user" && isObj(r.message)) {
         const p = cleanPrompt(blockText(r.message.content));
+        first ??= p;
         const rest = p ? splitHandoffPrompt(p).rest : "";
         if (rest) {
           title = oneLine(rest, 60);
@@ -776,7 +1251,8 @@ function createCursorReader(o) {
         }
       }
     }
-    const ref = { tool: "cursor", id: parts[2], file, cwd: await cwdFor(parts[0]), title, lastActivityAt: st.mtime };
+    const cwd = await sessionFolder(await cwdFor(parts[0]), first);
+    const ref = { tool: "cursor", id: parts[2], file, cwd, title, lastActivityAt: st.mtime };
     cache.set(file, { size: st.size, mtimeMs: st.mtimeMs, ref });
     return ref;
   }
@@ -797,7 +1273,7 @@ function createCursorReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await readFile3(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await readFile5(ref.file, "utf8"));
       return normalizeCursor(records, ref, invalid);
     },
     detect(record) {
@@ -811,7 +1287,7 @@ function createCursorReader(o) {
 
 // ../core/src/git/snapshot.ts
 import { execFile as execFile2 } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { promisify as promisify2 } from "node:util";
 var pexec2 = promisify2(execFile2);
 var MAX_DIFF_CHARS = 2e6;
@@ -886,150 +1362,31 @@ async function takeGitSnapshot(cwd) {
     }
   }
   let diff = await git(root, ["diff", base, "--no-renames", "--no-color", "--no-ext-diff", "--no-textconv", "--src-prefix=a/", "--dst-prefix=b/"]);
-  const diffSha = createHash("sha256").update(diff).digest("hex");
+  const diffSha = createHash2("sha256").update(diff).digest("hex");
   if (diff.length > MAX_DIFF_CHARS) diff = diff.slice(0, MAX_DIFF_CHARS) + "\n[diff truncated by Harlay]\n";
   return { root, branch, head, files, diff, diffSha };
 }
 
-// ../core/src/redact/redact.ts
-var mark = (kind) => `[REDACTED:${kind}]`;
-var whole = (kind) => () => mark(kind);
-var ENV_KEY = String.raw`(?<![A-Za-z0-9_])((?:export\s+)?(?=[A-Z][A-Z0-9_]*\s*[=:])(?:[A-Z][A-Z0-9_]*)?(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?)[A-Z0-9_]*\s*[=:]\s*)`;
-var CONFIG_KEY = String.raw`(?<![A-Za-z0-9_.-])((["']?)[A-Za-z0-9_.-]*?(?:password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key)\2[ \t]*[=:][ \t]*)`;
-var NOT_A_VALUE = String.raw`(?:true|false|null|none|undefined|await|new|this|self|string|number|boolean|object|unknown|bool)\b`;
-var RULES = [
-  { kind: "private_key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, replace: whole("private_key") },
-  { kind: "anthropic_key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}/g, replace: whole("anthropic_key") },
-  { kind: "openai_key", re: /\bsk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}/g, replace: whole("openai_key") },
-  { kind: "github_token", re: /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{22,})/g, replace: whole("github_token") },
-  { kind: "aws_access_key", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, replace: whole("aws_access_key") },
-  { kind: "stripe_key", re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}/g, replace: whole("stripe_key") },
-  { kind: "slack_token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, replace: whole("slack_token") },
-  { kind: "google_api_key", re: /\bAIza[0-9A-Za-z_-]{35}\b/g, replace: whole("google_api_key") },
-  { kind: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, replace: whole("jwt") },
-  { kind: "bearer", re: /\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/g, replace: (_m, g) => `${g[0]}${mark("bearer")}` },
-  // Env rules run before config rules so an uppercase env line is counted once, as env_secret.
-  {
-    kind: "env_secret",
-    re: new RegExp(String.raw`${ENV_KEY}(["'])(?!\[REDACTED:)[^\n"']{4,}\2`, "g"),
-    replace: (_m, g) => `${g[0]}${g[1]}${mark("env_secret")}${g[1]}`
-  },
-  {
-    kind: "env_secret",
-    re: new RegExp(String.raw`${ENV_KEY}(?!["']|\[REDACTED:)[^\s"']{4,}`, "g"),
-    replace: (_m, g) => `${g[0]}${mark("env_secret")}`
-  },
-  {
-    kind: "config_secret",
-    re: new RegExp(String.raw`${CONFIG_KEY}(["'${"`"}])(?!\[REDACTED:)(?:\\.|(?!\3)[^\n\\]){4,}\3`, "gi"),
-    replace: (_m, g) => `${g[0]}${g[2]}${mark("config_secret")}${g[2]}`
-  },
-  {
-    // The value is matched atomically (lookahead + backreference) so a call like `token = sign(x)` cannot
-    // backtrack into a shorter match.
-    kind: "config_secret",
-    re: new RegExp(String.raw`${CONFIG_KEY}(?!${NOT_A_VALUE})(?=([^\s"'${"`"},;(){}\[\]<>]{4,}))\3(?![(\[<])`, "gi"),
-    replace: (_m, g) => `${g[0]}${mark("config_secret")}`
-  },
-  {
-    kind: "url_credentials",
-    re: /\b([a-z][a-z0-9+.-]{0,30}:\/\/[^\s:/@]+:)(?!\[REDACTED:)[^\s/@]+(?=@)/gi,
-    replace: (_m, g) => `${g[0]}${mark("url_credentials")}`
-  }
-];
-function shannon(s) {
-  const freq = /* @__PURE__ */ new Map();
-  for (const c of s) freq.set(c, (freq.get(c) ?? 0) + 1);
-  let h = 0;
-  for (const n of freq.values()) {
-    const p = n / s.length;
-    h -= p * Math.log2(p);
-  }
-  return h;
-}
-var Redactor = class {
-  counts = {};
-  bump(kind) {
-    this.counts[kind] = (this.counts[kind] ?? 0) + 1;
-  }
-  apply(text) {
-    let out = text;
-    for (const rule of RULES) {
-      out = out.replace(rule.re, (match, ...rest) => {
-        this.bump(rule.kind);
-        const groups = rest.filter((x) => typeof x === "string");
-        return rule.replace(match, groups);
-      });
-    }
-    out = out.replace(/[A-Za-z0-9_\-+=]{32,}/g, (m) => {
-      if (!/\d/.test(m) || !/[a-z]/.test(m) || !/[A-Z]/.test(m) || shannon(m) < 4.3) return m;
-      this.bump("high_entropy");
-      return mark("high_entropy");
-    });
-    return out;
-  }
-};
-
 // ../core/src/extract/extract.ts
-import { basename as basename3, isAbsolute, relative as relative3 } from "node:path";
+import { basename as basename5, isAbsolute, relative as relative3 } from "node:path";
 
 // ../core/src/extract/recent.ts
-var RECENT = { budgetTokens: 450, min: 2, max: 6, words: 120 };
-function pickRecentMessages(prompts) {
-  const out = [];
-  let used = 0;
-  for (let i = prompts.length - 1; i >= 0 && out.length < RECENT.max; i--) {
-    const m = clipWords(prompts[i], RECENT.words);
-    if (!m) continue;
-    const cost = Math.ceil(m.length / CHARS_PER_TOKEN);
-    if (out.length >= RECENT.min && used + cost > RECENT.budgetTokens) break;
-    out.unshift(m);
-    used += cost;
-  }
-  return out;
-}
-
-// ../core/src/extract/rules.ts
-var RULES2 = { maxRules: 10, budgetTokens: 300, words: 40, pastedWords: 400 };
-var DIRECTIVE_RE = /\b(never|always|don['’]?t|do not|must|make sure|prefer|avoid|no need to|instead of|from now on|going forward|remember|stop|only)\b/i;
-var norm2 = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
-function findPinnedRules(prompts, recent) {
-  const recentText = norm2(recent.join("\n"));
-  const found = [];
-  prompts.forEach((p, message) => {
-    if (wordCount(p) > RULES2.pastedWords) return;
-    for (const sentence of splitSentences(p)) {
-      if (sentence.endsWith("?") || sentence.endsWith(":") || !DIRECTIVE_RE.test(sentence)) continue;
-      if (recentText.includes(norm2(sentence))) continue;
-      found.push({ text: clipWords(sentence, RULES2.words), message });
-    }
-  });
-  return capRules(latestCopies(found));
-}
-function mergePinnedRules(older, newer, recent) {
-  const recentText = norm2(recent.join("\n"));
-  const all = [...older.map((r) => ({ text: r.text, message: -1 })), ...newer].filter((r) => !recentText.includes(norm2(r.text)));
-  return capRules(latestCopies(all));
-}
-function latestCopies(rules) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const r of rules) {
-    const key = norm2(r.text);
-    byKey.delete(key);
-    byKey.set(key, r);
-  }
-  return [...byKey.values()];
-}
-function capRules(all) {
-  const kept = [];
-  let used = 0;
-  for (let i = all.length - 1; i >= 0 && kept.length < RULES2.maxRules; i--) {
-    const cost = Math.ceil(all[i].text.length / CHARS_PER_TOKEN);
-    if (used + cost > RULES2.budgetTokens) break;
-    kept.unshift(all[i]);
-    used += cost;
-  }
-  return { rules: kept, more: all.length - kept.length };
+var USER_MESSAGES = { budgetChars: 16e3, messageChars: 1500 };
+var CLIPPED = " \u2026(clipped)";
+function clipMessage(m) {
+  const t = m.trim();
+  return t.length <= USER_MESSAGES.messageChars ? t : t.slice(0, USER_MESSAGES.messageChars - CLIPPED.length).trimEnd() + CLIPPED;
+}
+function pickUserMessages(prompts) {
+  const all = prompts.map(clipMessage).filter((m) => m.length > 0);
+  if (all.reduce((n, m) => n + m.length, 0) <= USER_MESSAGES.budgetChars) return { messages: all, omitted: 0 };
+  const newest = [];
+  let used = all[0].length;
+  for (let i = all.length - 1; i >= 1 && used + all[i].length <= USER_MESSAGES.budgetChars; i--) {
+    newest.unshift(all[i]);
+    used += all[i].length;
+  }
+  return { messages: [all[0], ...newest], omitted: all.length - 1 - newest.length };
 }
 
 // ../core/src/extract/extract.ts
@@ -1070,28 +1427,90 @@ var PROBES = /* @__PURE__ */ new Set([
   "pwd"
 ]);
 var GIT_PROBES = /* @__PURE__ */ new Set(["diff", "grep", "show", "log", "status", "rev-parse", "ls-files", "branch"]);
-var LEADING_CD_RE = /^\s*cd\s+(?:"[^"]*"|'[^']*'|[^\s;&]+)\s*(?:&&|;)\s*/;
-function isProbeCommand(cmd) {
-  let s = cmd;
-  for (let m = LEADING_CD_RE.exec(s); m; m = LEADING_CD_RE.exec(s)) s = s.slice(m[0].length);
-  const words = s.trim().split(/\s+/);
-  const first = basename3(words[0] ?? "");
+function splitShell(cmd, pipes = false) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < cmd.length; i++) {
+    const c = cmd[i];
+    if (quote) {
+      cur += c;
+      if (c === "\\" && quote === '"' && i + 1 < cmd.length) cur += cmd[++i];
+      else if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      cur += c;
+    } else if (c === ";" || c === "&" && cmd[i + 1] === "&" || c === "|" && cmd[i + 1] === "|") {
+      out.push(cur);
+      cur = "";
+      if (c !== ";") i++;
+    } else if (c === "|" && pipes) {
+      out.push(cur);
+      cur = "";
+    } else cur += c;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+var isCd = (s) => /^cd(\s|$)/.test(s);
+function isProbeStage(stage) {
+  const words = stage.trim().split(/\s+/);
+  const first = basename5(words[0] ?? "");
   if (first !== "git") return PROBES.has(first);
   let i = 1;
   while (i < words.length && words[i].startsWith("-")) i += words[i] === "-C" || words[i] === "-c" ? 2 : 1;
   return GIT_PROBES.has(words[i] ?? "");
 }
+function isProbeCommand(cmd) {
+  const stages = splitShell(cmd, true).filter((s) => !isCd(s));
+  return stages.length > 0 && stages.every(isProbeStage);
+}
 var FAILURE_WINDOW = 5;
 function findLastFailure(cmds) {
   const real = cmds.filter((c) => !isProbeCommand(c.cmd));
   for (let i = real.length - 1; i >= Math.max(0, real.length - FAILURE_WINDOW); i--) {
     const c = real[i];
     if (c.exitCode === null || c.exitCode === 0) continue;
-    if (real.slice(i + 1).some((d) => d.cmd === c.cmd && d.exitCode === 0)) continue;
+    const check = checkOf(c.cmd);
+    if (check?.piped) continue;
+    const later = (d) => {
+      const k = checkOf(d.cmd);
+      return d.cmd === c.cmd || !!check && !!k && k.key === check.key;
+    };
+    if (real.slice(i + 1).some((d) => later(d) && (d.exitCode === 0 || d.exitCode === null || checkOf(d.cmd)?.piped))) continue;
     return { cmd: c.cmd, exitCode: c.exitCode, output: dropPartialLine(c.output) };
   }
   return null;
 }
+var RESULTS_MAX = 12;
+var REFERENCES_MAX = 15;
+var REDIRECT_RE = /\s+(?:\d?>>?|&>)\s*(?:&\d|\/dev\/null)/g;
+function checkOf(cmd) {
+  let piped = false;
+  const parts = splitShell(cmd).filter((s) => !isCd(s) && !isProbeCommand(s)).map((s) => {
+    const stages = splitShell(s, true);
+    if (stages.length > 1) piped = true;
+    return stages[0].replace(REDIRECT_RE, "").trim();
+  });
+  return parts.length ? { key: parts.join(" && "), piped } : null;
+}
+function commandResults(cmds) {
+  const by = /* @__PURE__ */ new Map();
+  for (const c of cmds) {
+    const check = checkOf(c.cmd);
+    if (!check) continue;
+    const r = by.get(check.key) ?? { cmd: check.key, runs: 0, failed: 0, last: "unknown" };
+    by.delete(check.key);
+    r.runs++;
+    const known = c.exitCode !== null && !check.piped;
+    if (known && c.exitCode !== 0) r.failed++;
+    r.last = !known ? "unknown" : c.exitCode === 0 ? "passed" : "failed";
+    by.set(check.key, r);
+  }
+  return [...by.values()].slice(-RESULTS_MAX);
+}
 function dropPartialLine(output) {
   if (!output.startsWith("\u2026")) return output;
   const nl = output.indexOf("\n");
@@ -1099,19 +1518,19 @@ function dropPartialLine(output) {
 }
 function buildTranscript(s, title, rel, redactor) {
   const r = (x) => redactor.apply(x);
-  const lines = [`# Condensed transcript: ${title}`, "", `Source: ${TOOL_LABEL[s.ref.tool]} session \`${s.ref.id}\``, ""];
+  const lines2 = [`# Condensed transcript: ${title}`, "", `Source: ${TOOL_LABEL[s.ref.tool]} session \`${s.ref.id}\``, ""];
   for (const t of s.timeline) {
     if (t.kind === "user") {
       const { handoff, rest } = splitHandoffPrompt(t.text);
-      if (handoff) lines.push("**Harlay handoff prompt** (from the previous agent; context is in the brief)", "");
-      if (rest) lines.push("**User:**", r(rest), "");
+      if (handoff) lines2.push("**Harlay handoff prompt** (the task came from the previous agent in a .harlay file)", "");
+      if (rest) lines2.push("**User:**", r(rest), "");
     } else if (t.kind === "assistant") {
       const text = r(t.text);
-      lines.push("**Agent:**", text.length > 600 ? text.slice(0, 599) + "\u2026" : text, "");
-    } else if (t.kind === "command") lines.push(`\`$ ${oneLine(r(t.run.cmd), 200)}\`${t.run.exitCode === null ? "" : ` \u2192 exit ${t.run.exitCode}`}`, "");
-    else lines.push(`Edited \`${r(rel(t.edit.path))}\` (${t.edit.kind})`, "");
+      lines2.push("**Agent:**", text.length > 600 ? text.slice(0, 599) + "\u2026" : text, "");
+    } else if (t.kind === "command") lines2.push(`\`$ ${oneLine(r(t.run.cmd), 200)}\`${t.run.exitCode === null ? "" : ` \u2192 exit ${t.run.exitCode}`}`, "");
+    else if (t.kind === "edit") lines2.push(`Edited \`${r(rel(t.edit.path))}\` (${t.edit.kind})`, "");
   }
-  const out = lines.join("\n");
+  const out = lines2.join("\n");
   if (out.length <= TRANSCRIPT_MAX) return out;
   const cut = out.slice(out.length - TRANSCRIPT_MAX);
   const nl = cut.indexOf("\n");
@@ -1134,23 +1553,30 @@ function extractHandoff(s, git2, o) {
   const redactor = new Redactor();
   const realPrompts = prompts.filter((p) => !isSlashCommand(p)).map((p) => redactor.apply(p));
   const prev = o.previous;
-  const fromPrev = prev ? split.some((p) => p.handoff && (p.id === null || p.id === prev.id)) : false;
+  const started = split.some((p) => p.handoff);
+  const startedFrom = [...s.handoffIds ?? [], ...split.flatMap((p) => p.id ? [p.id] : [])][0] ?? (started ? cmds.map((c) => /\.harlay\b/.test(c.cmd) ? handoffIdIn(c.output) : null).find((id) => id !== null) ?? null : null);
+  const sameTarget = !prev?.target || prev.target === s.ref.tool;
+  const fromPrev = prev ? started && (startedFrom === null ? sameTarget : startedFrom === prev.id) : false;
   const carried = prev && prev.goal !== null && fromPrev ? prev : null;
-  const carriedRecent = carried ? carried.recentUserMessages.map((m) => redactor.apply(m)) : [];
-  const recentUserMessages = pickRecentMessages([...carriedRecent, ...realPrompts]);
-  let { rules: pinnedRules, more: moreRules } = findPinnedRules(realPrompts, recentUserMessages);
-  if (carried) {
-    const older = [...carried.pinnedRules.map((r) => ({ ...r, text: redactor.apply(r.text) })), ...findPinnedRules(carriedRecent, []).rules];
-    const merged = mergePinnedRules(older, pinnedRules, recentUserMessages);
-    moreRules += merged.more + carried.moreRules;
-    pinnedRules = merged.rules;
-  }
+  const carriedMessages = carried ? carried.userMessages.map((m) => redactor.apply(m)) : [];
+  const picked = pickUserMessages([...carriedMessages, ...realPrompts]);
+  const userMessages = picked.messages;
+  const omittedMessages = picked.omitted + (carried?.omittedMessages ?? 0);
   const originalGoal = carried ? carried.goal === null ? null : redactor.apply(carried.goal) : realPrompts.find(isSubstantive) ?? realPrompts[0] ?? null;
   const todos = (s.todos ?? []).filter((t) => t.status !== "cancelled");
   const lastAgent = agentTexts.length ? agentTexts[agentTexts.length - 1] : null;
   const whereItStopped = lastAgent === null ? null : clipWords(redactor.apply(lastAgent), 150);
   const openTodos = todos.flatMap((t) => t.status === "in_progress" || t.status === "pending" ? [{ text: redactor.apply(t.text).replace(/\s+/g, " ").trim(), status: t.status }] : []).slice(0, 8);
   const failure = findLastFailure(cmds);
+  const results = commandResults(cmds).map((r) => ({ ...r, cmd: redactor.apply(r.cmd) }));
+  const references = { read: [], attached: [], urls: [] };
+  for (const t of s.timeline) {
+    if (t.kind !== "read") continue;
+    const list = t.how === "fetched" ? references.urls : t.how === "attached" ? references.attached : references.read;
+    const p = redactor.apply(t.how === "fetched" ? t.path : rel(t.path));
+    if (!list.includes(p)) list.push(p);
+  }
+  for (const k of ["read", "attached", "urls"]) references[k] = references[k].slice(-REFERENCES_MAX);
   const lastFailure = failure ? { ...failure, cmd: redactor.apply(failure.cmd), output: redactor.apply(failure.output) } : null;
   const filesTouched = [];
   for (const e of [...edits].reverse()) {
@@ -1177,11 +1603,13 @@ function extractHandoff(s, git2, o) {
     workdir,
     git: git2,
     originalGoal,
-    recentUserMessages,
-    pinnedRules,
-    moreRules,
+    userMessages,
+    omittedMessages,
     whereItStopped,
+    lastRequest: userMessages.at(-1) ?? null,
     todos: openTodos,
+    results,
+    references,
     filesTouched,
     lastFailure,
     transcript: buildTranscript(s, title, rel, redactor),
@@ -1191,235 +1619,9 @@ function extractHandoff(s, git2, o) {
   };
 }
 
-// ../core/src/brief/write.ts
-import { access, appendFile, mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join6 } from "node:path";
-
-// ../core/src/brief/prompt.ts
-var TIER_MAX = { full: 6e3, compact: 3e3 };
-var REASON_TEXT = {
-  usage_limit: "it hit a usage limit",
-  crash: "it stopped with an error",
-  manual: "the user handed it off"
-};
-var OUR_TAGS = /<(\/?)(handoff|original_goal|rules_from_user|recent_user_messages|where_it_stopped|files|last_failure)\b/gi;
-function safe(s) {
-  return s.replace(OUR_TAGS, "\u2039$1$2");
-}
-var attr = (s) => safe(s).replace(/"/g, "'").replace(/\s+/g, " ").trim();
-var norm3 = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
-function goalIsRecent(goal, recent) {
-  const g = norm3(goal.replace(/\s…$/, ""));
-  return recent.some((m) => norm3(m).startsWith(g));
-}
-function renderPrompt(rec, tier) {
-  const full = tier === "full";
-  const from = TOOL_LABEL[rec.from.tool];
-  const dir = `.harlay/handoffs/${rec.id}`;
-  const out = [
-    `<handoff from="${from}" reason="${rec.from.reason}" task="${attr(rec.task.title)}">`,
-    `You are taking over a coding session that ${from} could not finish (${REASON_TEXT[rec.from.reason]}). What you need to start is below; don't re-read the repo to rebuild it.`
-  ];
-  const goal = rec.task.originalGoal;
-  const noRecent = rec.task.recentUserMessages.length === 0;
-  if (goal && (full ? !goalIsRecent(goal, rec.task.recentUserMessages) : noRecent)) out.push("", "<original_goal>", safe(goal), "</original_goal>");
-  if (rec.task.pinnedRules.length) {
-    out.push("", "<rules_from_user>", ...rec.task.pinnedRules.map((r) => `- ${safe(r.text)}`));
-    if (rec.task.moreRules) out.push(`(${rec.task.moreRules} more in the transcript)`);
-    out.push("</rules_from_user>");
-  }
-  const recent = full ? rec.task.recentUserMessages : rec.task.recentUserMessages.slice(-2);
-  if (recent.length) out.push("", '<recent_user_messages oldest_first="true">', ...recent.map((m) => `- ${safe(m)}`), "</recent_user_messages>");
-  const where = rec.state.whereItStopped === null ? null : full ? rec.state.whereItStopped : clipWords(rec.state.whereItStopped, 60);
-  const todos = rec.state.todos.map((t) => `[${t.status === "in_progress" ? "in progress" : "pending"}] ${safe(t.text)}`);
-  if (where || todos.length) {
-    out.push("", "<where_it_stopped>");
-    if (where) out.push(safe(where));
-    if (todos.length) out.push(`Open todos: ${todos.join("; ")}`);
-    out.push("</where_it_stopped>");
-  }
-  if (full && (rec.files.touched.length || rec.files.uncommitted.length)) {
-    out.push("", "<files>");
-    if (rec.files.touched.length) out.push(`Touched: ${rec.files.touched.map(safe).join(", ")}`);
-    if (rec.files.uncommitted.length) {
-      const list = rec.files.uncommitted.map((f) => `${safe(f.path)} (${f.status}${f.added !== null && f.removed !== null ? `, +${f.added} -${f.removed}` : ""})`);
-      out.push(`Uncommitted: ${list.join(", ")}${rec.files.moreUncommitted ? `, and ${rec.files.moreUncommitted} more` : ""}`);
-    }
-    out.push("</files>");
-  }
-  if (rec.lastFailure) {
-    out.push("", "<last_failure>", `$ ${safe(rec.lastFailure.cmd)} (exit ${rec.lastFailure.exitCode})`);
-    if (full) out.push(safe(rec.lastFailure.outputTail));
-    out.push("</last_failure>");
-  }
-  const more = [`${dir}/transcript.md (search it, don't read it all)`];
-  if (rec.details.diff) more.push(`${dir}/diff.patch`);
-  const next = noRecent ? "Continue from where it stopped." : "Continue from the most recent user message.";
-  out.push("", `Only if you need more: ${more.join(" and ")}.`, "</handoff>", "", `${next} Start with the next concrete step.`);
-  return wellFormed(out.join("\n"));
-}
-function choosePrompt(rec, fits) {
-  for (const tier of ["full", "compact"]) {
-    const text = renderPrompt(rec, tier);
-    if (text.length <= TIER_MAX[tier] && fits(text)) return { tier, text };
-  }
-  return { tier: "pointer", text: HANDOFF_PROMPT };
-}
-
-// ../core/src/brief/record.ts
-var RECORD_SCHEMA = "harlay/handoff@2";
-var MAX_UNCOMMITTED = 15;
-function buildRecord(d, id, previousId, r) {
-  const a = (s) => r.apply(stripControl(s));
-  const files = d.git?.files ?? [];
-  return {
-    schema: RECORD_SCHEMA,
-    id,
-    createdAt: d.createdAt.toISOString(),
-    from: {
-      tool: d.from.tool,
-      model: d.from.model,
-      session: d.from.session,
-      reason: d.from.reason,
-      resetsAt: d.from.resetsAt ? d.from.resetsAt.toISOString() : null,
-      message: d.from.message === null ? null : a(d.from.message)
-    },
-    repo: { root: d.workdir, git: d.git !== null, branch: d.git?.branch ?? null, head: d.git?.head ?? null, dirtyFiles: files.length },
-    task: {
-      title: a(d.title),
-      originalGoal: d.originalGoal === null ? null : clipWords(a(d.originalGoal), 60),
-      recentUserMessages: d.recentUserMessages.map(a),
-      pinnedRules: d.pinnedRules.map((p) => ({ text: a(p.text), message: p.message })),
-      moreRules: d.moreRules
-    },
-    state: {
-      whereItStopped: d.whereItStopped === null ? null : a(d.whereItStopped),
-      todos: d.todos.map((t) => ({ text: oneLine(a(t.text), 200), status: t.status }))
-    },
-    files: {
-      touched: d.filesTouched.map(a),
-      uncommitted: files.slice(0, MAX_UNCOMMITTED).map((f) => ({ path: a(f.path), status: f.status, added: f.added, removed: f.removed })),
-      moreUncommitted: Math.max(0, files.length - MAX_UNCOMMITTED)
-    },
-    lastFailure: d.lastFailure ? { cmd: clipWords(a(d.lastFailure.cmd), 30), exitCode: d.lastFailure.exitCode, outputTail: a(d.lastFailure.output).split("\n").slice(-8).join("\n") } : null,
-    details: { transcript: "transcript.md", diff: d.git ? "diff.patch" : null, lastError: d.lastFailure ? "last-error.txt" : null },
-    previous: previousId ? { id: previousId } : null,
-    unknownRecords: d.unknownRecords
-  };
-}
-var isStr = (v) => typeof v === "string";
-var isObj2 = (v) => typeof v === "object" && v !== null;
-function validateRecord(raw) {
-  if (!isObj2(raw) || raw.schema !== RECORD_SCHEMA || !isStr(raw.id) || !isStr(raw.createdAt)) return null;
-  const { task, from } = raw;
-  if (!isObj2(from) || !isTool(from.tool)) return null;
-  if (!isObj2(task) || !isStr(task.title) || !(task.originalGoal === null || isStr(task.originalGoal))) return null;
-  if (!Array.isArray(task.recentUserMessages) || !task.recentUserMessages.every(isStr)) return null;
-  if (!Array.isArray(task.pinnedRules) || !task.pinnedRules.every((r) => isObj2(r) && isStr(r.text) && typeof r.message === "number")) return null;
-  return raw;
-}
-
-// ../core/src/brief/write.ts
-async function allocateHandoffId(handoffsDir, baseId) {
-  for (let i = 1; i < 1e3; i++) {
-    const id = i === 1 ? baseId : `${baseId}-${i}`;
-    try {
-      await access(join6(handoffsDir, id));
-    } catch {
-      return id;
-    }
-  }
-  throw new HarlayError(`Could not allocate a handoff folder for ${baseId}`);
-}
-async function ensureGitExclude(workdir) {
-  const p = (await git(workdir, ["rev-parse", "--git-path", "info/exclude"])).trim();
-  const file = isAbsolute2(p) ? p : join6(workdir, p);
-  let current = "";
-  try {
-    current = await readFile4(file, "utf8");
-  } catch {
-    current = "";
-  }
-  if (current.split("\n").some((l) => l.trim() === ".harlay/" || l.trim() === ".harlay")) return;
-  await mkdir2(dirname2(file), { recursive: true });
-  await appendFile(file, `${current && !current.endsWith("\n") ? "\n" : ""}.harlay/
-`);
-}
-async function readHandoffState(workdir) {
-  let raw;
-  try {
-    raw = JSON.parse(await readFile4(join6(workdir, ".harlay", "state.json"), "utf8"));
-  } catch {
-    return null;
-  }
-  if (typeof raw !== "object" || raw === null) return null;
-  const s = raw;
-  if (s.harlay !== 1 || typeof s.lastId !== "string" || typeof s.title !== "string") return null;
-  if (s.goal !== null && typeof s.goal !== "string") return null;
-  return { harlay: 1, lastId: s.lastId, goal: s.goal, title: s.title };
-}
-async function readIfExists(file) {
-  try {
-    return await readFile4(file, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function readPreviousHandoff(workdir) {
-  const raw = await readIfExists(join6(workdir, ".harlay", "handoff.json"));
-  if (raw !== null) {
-    let rec;
-    try {
-      rec = validateRecord(JSON.parse(raw));
-    } catch {
-      return null;
-    }
-    if (!rec) return null;
-    const { task } = rec;
-    return {
-      id: rec.id,
-      goal: task.originalGoal,
-      title: task.title,
-      recentUserMessages: task.recentUserMessages,
-      pinnedRules: task.pinnedRules,
-      moreRules: typeof task.moreRules === "number" ? task.moreRules : 0
-    };
-  }
-  const state = await readHandoffState(workdir);
-  return state ? { id: state.lastId, goal: state.goal, title: state.title, recentUserMessages: [], pinnedRules: [], moreRules: 0 } : null;
-}
-function addCounts(a, b) {
-  const out = { ...a };
-  for (const [k, n] of Object.entries(b)) out[k] = (out[k] ?? 0) + n;
-  return out;
-}
-async function writeHandoff(d, o) {
-  const harlayDir = join6(d.workdir, ".harlay");
-  const latestPath = join6(harlayDir, "HANDOFF.md");
-  const id = await allocateHandoffId(join6(harlayDir, "handoffs"), d.baseId);
-  const dir = join6(harlayDir, "handoffs", id);
-  await mkdir2(dir, { recursive: true });
-  const r = new Redactor();
-  const body = buildRecord(d, id, o.previousId, r);
-  const chosen = choosePrompt(body, (p) => promptFits(o.target, o.mode, p));
-  const record = { ...body, prompt: { target: o.target, tier: chosen.tier, chars: chosen.text.length } };
-  const json = JSON.stringify(record, null, 2) + "\n";
-  const recordPath = join6(dir, "handoff.json");
-  await writeFile2(recordPath, json);
-  await writeFile2(join6(dir, "prompt.md"), chosen.text + "\n");
-  await writeFile2(join6(dir, "transcript.md"), r.apply(stripControl(d.transcript)));
-  if (d.git) await writeFile2(join6(dir, "diff.patch"), r.apply(d.git.diff));
-  if (d.lastFailure) await writeFile2(join6(dir, "last-error.txt"), r.apply(stripControl(d.lastFailure.output)));
-  await writeFile2(latestPath, renderPrompt(body, "full") + "\n");
-  await writeFile2(join6(harlayDir, "handoff.json"), json);
-  if (d.git) await ensureGitExclude(d.workdir);
-  const redactions = addCounts(d.redactions ?? {}, r.counts);
-  return { id, dir, recordPath, latestPath, prompt: chosen.text, tier: chosen.tier, redactions };
-}
-
 // ../core/src/launch/resolve.ts
 import { constants } from "node:fs";
-import { access as access2, stat as stat5 } from "node:fs/promises";
+import { access, stat as stat7 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join as join7 } from "node:path";
 function defaultResolveOptions(env = process.env) {
@@ -1446,8 +1648,8 @@ function knownPaths(tool, o) {
 }
 async function isExecutable(p) {
   try {
-    if (!(await stat5(p)).isFile()) return false;
-    await access2(p, constants.X_OK);
+    if (!(await stat7(p)).isFile()) return false;
+    await access(p, constants.X_OK);
     return true;
   } catch {
     return false;
@@ -1529,46 +1731,93 @@ function parseSessionSpec(spec) {
 }
 
 // ../core/src/handoff.ts
-import { stat as stat6 } from "node:fs/promises";
+import { stat as stat8 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join8 } from "node:path";
+async function launchHandoff(o) {
+  const binaries = await resolveBinaries(o.resolve ?? defaultResolveOptions());
+  const plan = planLaunch({
+    target: o.target,
+    mode: o.mode,
+    cwd: o.cwd,
+    prompt: o.prompt,
+    scriptDir: join8(o.scriptDir ?? join8(tmpdir(), "harlay"), o.id),
+    binaries,
+    terminalApp: o.terminalApp ?? "Terminal"
+  });
+  await executeLaunch(plan, o.runner);
+  return plan;
+}
 async function runHandoff(o) {
   const cwd = o.session.cwd;
   if (!cwd) throw new HarlayError("This session has no known working directory, so Harlay cannot hand it off.");
   try {
-    if (!(await stat6(cwd)).isDirectory()) throw new Error("not a directory");
+    if (!(await stat8(cwd)).isDirectory()) throw new Error("not a directory");
   } catch {
     throw new HarlayError(`The session's folder no longer exists: ${cwd}`);
   }
   const session = await readerFor(o.readers, o.session.tool).readSession(o.session);
   const git2 = await takeGitSnapshot(cwd);
-  const previous = await readPreviousHandoff(git2?.root ?? cwd);
+  const previous = await readPreviousHandoff(o.store, git2?.root ?? cwd);
   const data = extractHandoff(session, git2, { now: o.now ?? /* @__PURE__ */ new Date(), reason: o.reason, previous });
-  const written = await writeHandoff(data, { target: o.target, mode: o.mode, previousId: data.carriedFrom });
+  const written = await writeHandoff(data, { target: o.target, mode: o.mode, previousId: data.carriedFrom, store: o.store });
   if (o.launch === false) return { written, plan: null, data };
   let plan;
   try {
-    const binaries = await resolveBinaries(o.resolve ?? defaultResolveOptions());
-    plan = planLaunch({
-      target: o.target,
-      mode: o.mode,
-      cwd: data.workdir,
-      prompt: written.prompt,
-      scriptDir: written.dir,
-      binaries,
-      terminalApp: o.terminalApp ?? "Terminal"
-    });
-    await executeLaunch(plan, o.runner);
+    plan = await launchHandoff({ ...o, cwd: data.workdir, id: written.id, prompt: written.prompt });
   } catch (e) {
     const reason = (e instanceof Error ? e.message : String(e)).trim().replace(/\.$/, "");
-    throw new LaunchError(`${reason}. The brief is ready at ${written.latestPath}`, written);
+    throw new LaunchError(`${reason}. The handoff is ready at ${written.path}`, written);
   }
   return { written, plan, data };
 }
 
+// ../core/src/delivery.ts
+var SLACK_MS = 2e3;
+function firstPrompt(s) {
+  const t = s.timeline.find((x) => x.kind === "user");
+  return t && t.kind === "user" ? cleanPrompt(t.text) ?? t.text : null;
+}
+function hasRead(s, h) {
+  if (s.handoffIds?.includes(h.id)) return true;
+  return s.timeline.some(
+    (t) => t.kind === "command" && /\.harlay\b/.test(t.run.cmd) && handoffIdIn(t.run.output) === h.id || t.kind === "read" && t.path === h.path
+  );
+}
+async function checkDelivery(readers, h) {
+  const reader = readerFor(readers, h.target);
+  const after = h.since.getTime() - SLACK_MS;
+  let sent = null;
+  for (const ref of await reader.listSessions(20)) {
+    if (ref.lastActivityAt.getTime() < after) continue;
+    let s;
+    try {
+      s = await reader.readSession(ref);
+    } catch {
+      continue;
+    }
+    const p = firstPrompt(s);
+    if (p === null || !splitHandoffPrompt(p).handoff || harlayFileIn(p) !== h.path) continue;
+    if (hasRead(s, h)) return { state: "read", session: ref };
+    sent ??= { state: "sent", session: ref };
+  }
+  return sent;
+}
+async function waitForDelivery(readers, h, o) {
+  const end = Date.now() + o.timeoutMs;
+  let last = null;
+  for (; ; ) {
+    last = await checkDelivery(readers, h) ?? last;
+    if (last?.state === "read" || Date.now() >= end) return last;
+    await new Promise((r) => setTimeout(r, Math.min(o.intervalMs ?? 2e3, Math.max(0, end - Date.now()))));
+  }
+}
+
 // ../core/src/watch/watcher.ts
 import { EventEmitter } from "node:events";
 import { watch } from "node:fs";
-import { open as open2, stat as stat7 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { open as open2, stat as stat9 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 var Watcher = class extends EventEmitter {
   constructor(readers, opts = {}) {
@@ -1592,14 +1841,14 @@ var Watcher = class extends EventEmitter {
     for (const r of this.readers) {
       for (const f of await listSessionFiles(r.root, r.isSessionFile)) {
         try {
-          this.offsets.set(f.path, (await stat7(f.path)).size);
+          this.offsets.set(f.path, (await stat9(f.path)).size);
         } catch {
         }
       }
       if (this.opts.fsWatch === false) continue;
       try {
         const w = watch(r.root, { recursive: true }, (_event, name) => {
-          if (name) this.schedule(join8(r.root, name.toString()));
+          if (name) this.schedule(join9(r.root, name.toString()));
         });
         w.on("error", (e) => this.emit("error", e));
         this.watchers.push(w);
@@ -1620,7 +1869,7 @@ var Watcher = class extends EventEmitter {
       for (const f of await listSessionFiles(r.root, r.isSessionFile)) {
         let size;
         try {
-          size = (await stat7(f.path)).size;
+          size = (await stat9(f.path)).size;
         } catch {
           continue;
         }
@@ -1677,7 +1926,7 @@ var Watcher = class extends EventEmitter {
     if (!reader) return [];
     let size;
     try {
-      size = (await stat7(file)).size;
+      size = (await stat9(file)).size;
     } catch {
       return [];
     }
@@ -1701,10 +1950,10 @@ var Watcher = class extends EventEmitter {
       decoder = new StringDecoder("utf8");
       this.decoders.set(file, decoder);
     }
-    const lines = ((this.partial.get(file) ?? "") + decoder.write(buf)).split("\n");
-    this.partial.set(file, lines.pop() ?? "");
+    const lines2 = ((this.partial.get(file) ?? "") + decoder.write(buf)).split("\n");
+    this.partial.set(file, lines2.pop() ?? "");
     const detected = [];
-    for (const line of lines) {
+    for (const line of lines2) {
       if (!line.trim()) continue;
       let rec;
       try {
@@ -1755,14 +2004,14 @@ var SAMPLE_MAX_AGE_MS = 30 * 24 * HOUR;
 var PACE_MS2 = 30 * 6e4;
 
 // ../core/src/usage/bridge.ts
-import { chmod as chmod2, mkdir as mkdir3, readFile as readFile5, rename, rm, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { chmod as chmod2, mkdir as mkdir3, readFile as readFile6, rename, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 var BRIDGE_MARKER = "# harlay-usage";
 function claudeSettingsPath(home) {
-  return join9(home, ".claude", "settings.json");
+  return join10(home, ".claude", "settings.json");
 }
-var previousJson = (dataDir) => join9(dataDir, "claude-statusline.previous.json");
-var previousCommand = (dataDir) => join9(dataDir, "claude-statusline.previous");
+var previousJson = (dataDir) => join10(dataDir, "claude-statusline.previous.json");
+var previousCommand = (dataDir) => join10(dataDir, "claude-statusline.previous");
 function isObj3(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -1772,7 +2021,7 @@ function isOurs(statusLine) {
 async function readSettings(path) {
   let text;
   try {
-    text = await readFile5(path, "utf8");
+    text = await readFile6(path, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return {};
     throw e;
@@ -1792,23 +2041,50 @@ async function removeBridge(home, dataDir) {
   if (!isOurs(s.statusLine)) return;
   let prev;
   try {
-    prev = JSON.parse(await readFile5(previousJson(dataDir), "utf8"));
+    prev = JSON.parse(await readFile6(previousJson(dataDir), "utf8"));
   } catch {
     prev = void 0;
   }
   if (prev === void 0) delete s.statusLine;
   else s.statusLine = prev;
   await writeAtomic(path, JSON.stringify(s, null, 2) + "\n");
-  await rm(previousJson(dataDir), { force: true });
-  await rm(previousCommand(dataDir), { force: true });
+  await rm2(previousJson(dataDir), { force: true });
+  await rm2(previousCommand(dataDir), { force: true });
 }
 
+// ../core/src/health/signals.ts
+var SIGNALS = {
+  /** Timeline items (messages, commands, edits, reads) looked at; about the last hour of a busy chat. */
+  recentItems: 80,
+  /** Recent real commands looked at for repeated failures. */
+  recentCommands: 15,
+  /** The same command failing this many times in a row, with no success since. */
+  repeatFailures: 3,
+  recentUserMessages: 6,
+  recentAgentMessages: 8,
+  churnEdits: 6,
+  /** No progress: at least this many steps and failures (across 2+ commands) since the last fix or commit. */
+  stuckSteps: 10,
+  stuckFailures: 4,
+  /** Reading the same file (or running the same lookup) this many times without changing it. */
+  rereads: 3,
+  /** Context sizes at which answers tend to get less reliable (the context rot research measures length, not %). */
+  longTokens: 1e5,
+  veryLongTokens: 22e4
+};
+
+// ../core/src/health/assess.ts
+var HEALTH = {
+  ...SIGNALS,
+  maxReasons: 3
+};
+
 // src/app.ts
 import { execFile as execFile3 } from "node:child_process";
 import { existsSync } from "node:fs";
-import { cp, mkdir as mkdir4, mkdtemp, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir3, tmpdir } from "node:os";
-import { dirname as dirname3, join as join10, resolve } from "node:path";
+import { cp, mkdir as mkdir4, mkdtemp, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname3, join as join11, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify as promisify3 } from "node:util";
 var run = promisify3(execFile3);
@@ -1817,19 +2093,19 @@ var APP_BUNDLE_ID = "com.corelabs.harlay";
 var APP_FILES = ["dist", "renderer", "assets"];
 function findAppSource(cliFile = fileURLToPath(import.meta.url)) {
   const pkg = resolve(dirname3(cliFile), "..");
-  for (const dir of [join10(pkg, "app"), resolve(pkg, "..", "..", "apps", "desktop")]) {
-    if (existsSync(join10(dir, "dist", "main.cjs")) && existsSync(join10(dir, "renderer", "popover.html")) && existsSync(join10(dir, "assets", "icon.png"))) return dir;
+  for (const dir of [join11(pkg, "app"), resolve(pkg, "..", "..", "apps", "desktop")]) {
+    if (existsSync(join11(dir, "dist", "main.cjs")) && existsSync(join11(dir, "renderer", "popover.html")) && existsSync(join11(dir, "assets", "icon.png"))) return dir;
   }
   return null;
 }
 async function makeIcns(png, work) {
-  const set = join10(work, "icon.iconset");
+  const set = join11(work, "icon.iconset");
   await mkdir4(set);
   for (const size of [16, 32, 128, 256, 512]) {
-    await run("sips", ["-z", String(size), String(size), png, "--out", join10(set, `icon_${size}x${size}.png`)]);
-    await run("sips", ["-z", String(size * 2), String(size * 2), png, "--out", join10(set, `icon_${size}x${size}@2x.png`)]);
+    await run("sips", ["-z", String(size), String(size), png, "--out", join11(set, `icon_${size}x${size}.png`)]);
+    await run("sips", ["-z", String(size * 2), String(size * 2), png, "--out", join11(set, `icon_${size}x${size}@2x.png`)]);
   }
-  const icns = join10(work, "icon.icns");
+  const icns = join11(work, "icon.icns");
   await run("iconutil", ["-c", "icns", set, "-o", icns]);
   return icns;
 }
@@ -1848,7 +2124,7 @@ async function quitRunningApp() {
   }
 }
 function harlayDataDir(home = homedir3()) {
-  return join10(home, "Library", "Application Support", "Harlay");
+  return join11(home, "Library", "Application Support", "Harlay");
 }
 async function uninstallApp(opts) {
   await quitRunningApp();
@@ -1859,7 +2135,7 @@ async function uninstallApp(opts) {
     opts.log(`Left ~/.claude/settings.json unchanged: ${e instanceof Error ? e.message : String(e)}
 `);
   }
-  const app = join10(opts.dir, "Harlay.app");
+  const app = join11(opts.dir, "Harlay.app");
   if (!existsSync(app)) {
     opts.log(`No Harlay.app in ${opts.dir}.
 `);
@@ -1873,21 +2149,21 @@ async function installApp(opts) {
   if (process.platform !== "darwin") throw new Error("The Harlay app is macOS only; the CLI works without it.");
   const source = findAppSource();
   if (!source) throw new Error("App files are missing from this install. Reinstall with `npm install -g harlay`.");
-  const work = await mkdtemp(join10(tmpdir(), "harlay-app-"));
+  const work = await mkdtemp(join11(tmpdir2(), "harlay-app-"));
   try {
-    const appSrc = join10(work, "src");
-    for (const f of APP_FILES) await cp(join10(source, f), join10(appSrc, f), { recursive: true });
+    const appSrc = join11(work, "src");
+    for (const f of APP_FILES) await cp(join11(source, f), join11(appSrc, f), { recursive: true });
     await writeFile4(
-      join10(appSrc, "package.json"),
+      join11(appSrc, "package.json"),
       JSON.stringify({ name: "harlay-desktop", productName: "Harlay", version: opts.version, main: "dist/main.cjs" }, null, 2)
     );
-    const icon = await makeIcns(join10(source, "assets", "icon.png"), work);
+    const icon = await makeIcns(join11(source, "assets", "icon.png"), work);
     opts.log(`Building Harlay.app (Electron ${ELECTRON_VERSION}; the first install downloads it, about 100 MB)\u2026
 `);
     const { packager } = await import("@electron/packager");
     const [outDir] = await packager({
       dir: appSrc,
-      out: join10(work, "out"),
+      out: join11(work, "out"),
       name: "Harlay",
       platform: "darwin",
       arch: process.arch === "arm64" ? "arm64" : "x64",
@@ -1902,29 +2178,29 @@ async function installApp(opts) {
       quiet: true,
       extendInfo: { LSUIElement: true, NSUserNotificationAlertStyle: "alert" }
     });
-    const built = join10(outDir, "Harlay.app");
+    const built = join11(outDir, "Harlay.app");
     await run("codesign", ["--force", "--deep", "--sign", "-", built]);
-    const dest = join10(opts.dir, "Harlay.app");
+    const dest = join11(opts.dir, "Harlay.app");
     await quitRunningApp();
     await mkdir4(opts.dir, { recursive: true });
-    await rm2(dest, { recursive: true, force: true });
+    await rm3(dest, { recursive: true, force: true });
     await run("ditto", [built, dest]);
     opts.log(`Installed ${dest}
 `);
     if (opts.open) await run("open", [dest]);
     return dest;
   } finally {
-    await rm2(work, { recursive: true, force: true });
+    await rm3(work, { recursive: true, force: true });
   }
 }
 
 // src/main.ts
-var VERSION = "0.1.3";
+var VERSION = "0.2.1";
 var HELP = `harlay ${VERSION} \u2014 hand off a stalled AI coding session to another agent
 
 Usage:
   harlay sessions [--limit N] [--json]
-  harlay handoff --to <claude|codex|cursor> [--session <tool>:<id>] [--mode app|terminal] [--no-launch] [--terminal <App>]
+  harlay handoff --to <claude|codex|cursor> [--session <tool>:<id>] [--mode app|terminal] [--no-launch] [--terminal <App>] [--wait]
   harlay watch [--auto <claude|codex|cursor>] [--mode app|terminal] [--threshold N]
   harlay app install [--dir <folder>] [--no-open]   install or update the macOS menu bar app (default folder: /Applications)
   harlay app uninstall [--dir <folder>]             quit it, restore Claude Code's status line, move it to the Trash
@@ -1984,7 +2260,8 @@ async function cmdHandoff(args, readers, ctx) {
       session: { type: "string" },
       mode: { type: "string" },
       "no-launch": { type: "boolean" },
-      terminal: { type: "string" }
+      terminal: { type: "string" },
+      wait: { type: "boolean" }
     },
     strict: true
   });
@@ -1992,23 +2269,21 @@ async function cmdHandoff(args, readers, ctx) {
   const target = parseTool(values.to);
   const mode = parseMode(values.mode, target);
   const session = await pickSession(readers, values.session, ctx.cwd, ctx.env.HARLAY_HOME ?? homedir4());
+  const since = /* @__PURE__ */ new Date();
   const res = await runHandoff({
     session,
     target,
     mode,
     readers,
+    store: handoffStore(ctx.env.HARLAY_HOME ?? homedir4()),
     launch: !values["no-launch"],
     terminalApp: values.terminal ?? "Terminal",
     runner: ctx.runner,
     resolve: defaultResolveOptions(ctx.env)
   });
-  ctx.out(`Brief: ${res.written.latestPath}
-Archived: ${res.written.dir}
+  ctx.out(`Handoff: ${res.written.path}
+Prompt: ${res.written.prompt}
 `);
-  ctx.out(
-    res.written.tier === "pointer" ? "Prompt: pointer to the brief (too long to send inline)\n" : `Prompt: ${res.written.tier} brief inline (${res.written.prompt.length} chars)
-`
-  );
   const kinds = Object.keys(res.written.redactions);
   if (kinds.length) {
     const total = Object.values(res.written.redactions).reduce((a, b) => a + b, 0);
@@ -2017,8 +2292,29 @@ Archived: ${res.written.dir}
   }
   ctx.out(res.plan ? `Continuing in ${TOOL_LABEL[target]} (${mode}).
 ` : "Not launched (--no-launch).\n");
-  return 0;
+  if (!values.wait) return 0;
+  const seconds = Number(ctx.env.HARLAY_WAIT_SECONDS ?? WAIT_SECONDS);
+  ctx.out(`Waiting for ${TOOL_LABEL[target]} to read it (up to ${seconds} s)\u2026
+`);
+  const h = { id: res.written.id, path: res.written.path, target, since };
+  const got = await waitForDelivery(readers, h, { timeoutMs: seconds * 1e3 });
+  const took = `${Math.round((Date.now() - since.getTime()) / 1e3)} s`;
+  if (got?.state === "read") {
+    ctx.out(`${TOOL_LABEL[target]} read the handoff (chat ${got.session.id.slice(0, 8)}, ${took}).
+`);
+    return 0;
+  }
+  if (got) {
+    ctx.out(`${TOOL_LABEL[target]} got the prompt (chat ${got.session.id.slice(0, 8)}, ${took}); its log doesn't show reading the file yet.
+`);
+    return 0;
+  }
+  ctx.err(`${TOOL_LABEL[target]} hasn't picked up the handoff after ${seconds} s. Press Enter where the prompt is typed, or paste it into any chat:
+${res.written.prompt}
+`);
+  return 3;
 }
+var WAIT_SECONDS = 180;
 async function cmdWatch(args, readers, ctx) {
   const { values } = parseArgs({
     args,
@@ -2029,6 +2325,7 @@ async function cmdWatch(args, readers, ctx) {
   const mode = auto ? parseMode(values.mode, auto) : "app";
   const threshold = values.threshold ? Number(values.threshold) : 90;
   if (!(threshold > 0 && threshold <= 100)) throw new UsageError("--threshold must be between 1 and 100");
+  const store = handoffStore(ctx.env.HARLAY_HOME ?? homedir4());
   const watcher = new Watcher(readers, { usageThreshold: threshold });
   watcher.on("error", (e) => ctx.err(`harlay: watcher error: ${e instanceof Error ? e.message : String(e)}
 `));
@@ -2043,7 +2340,7 @@ async function cmdWatch(args, readers, ctx) {
     ctx.out(`[${when}] ${name}: stopped \u2014 ${ev.event.halt.message}
 `);
     if (auto && auto !== ev.ref.tool) {
-      runHandoff({ session: ev.ref, target: auto, mode, readers, runner: ctx.runner, resolve: defaultResolveOptions(ctx.env) }).then((r) => ctx.out(`  \u2192 handed off to ${TOOL_LABEL[auto]}; brief at ${r.written.latestPath}
+      runHandoff({ session: ev.ref, target: auto, mode, readers, store, runner: ctx.runner, resolve: defaultResolveOptions(ctx.env) }).then((r) => ctx.out(`  \u2192 handed off to ${TOOL_LABEL[auto]}; handoff at ${r.written.path}
 `)).catch((e) => ctx.err(`  \u2192 handoff failed: ${e instanceof Error ? e.message : String(e)}
 `));
     }