harlay 0.1.2 → 0.2.0

package/app/dist/main.cjs

@@ -2,9 +2,9 @@
 
 // src/main.ts
 var import_electron = require("electron");
-var import_promises16 = require("node:fs/promises");
-var import_node_os2 = require("node:os");
-var import_node_path18 = require("node:path");
+var import_promises19 = require("node:fs/promises");
+var import_node_os3 = require("node:os");
+var import_node_path19 = require("node:path");
 
 // ../../packages/core/src/types.ts
 var TOOLS = ["claude-code", "codex", "cursor"];
@@ -31,30 +31,93 @@ var LaunchError = class extends HarlayError {
 
 // ../../packages/core/src/util/text.ts
 var CHARS_PER_TOKEN = 4;
-function clip(s, maxTokens, pointer) {
-  const max = maxTokens * CHARS_PER_TOKEN;
-  if (s.length <= max) return s;
-  const note = pointer ? ` \u2026 (truncated, see ${pointer})` : " \u2026 (truncated)";
-  return s.slice(0, Math.max(0, max - note.length)).trimEnd() + note;
-}
+var isHigh = (c) => c >= 55296 && c <= 56319;
+var isLow = (c) => c >= 56320 && c <= 57343;
 function tail(s, maxChars) {
-  return s.length <= maxChars ? s : "\u2026" + s.slice(s.length - maxChars + 1);
+  if (s.length <= maxChars) return s;
+  let start = s.length - maxChars + 1;
+  if (start < s.length && isLow(s.charCodeAt(start))) start++;
+  return "\u2026" + s.slice(start);
+}
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+function wellFormed(s) {
+  return s.replace(LONE_SURROGATE, "\uFFFD");
 }
 function oneLine(s, max = 120) {
   const t = s.replace(/\s+/g, " ").trim();
-  return t.length <= max ? t : t.slice(0, max - 1) + "\u2026";
+  if (t.length <= max) return t;
+  let end = max - 1;
+  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);
+  if (start !== -1 && end > start) {
+    const before = p.slice(0, start).trim();
+    const after = p.slice(end + HANDOFF_END.length).replace(CLOSING_RE, "").trim();
+    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() === 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 };
+}
 function isHandoffPrompt(p) {
-  return p.length <= 300 && p.includes(".harlay/HANDOFF.md");
+  const { handoff: handoff2, rest } = splitHandoffPrompt(p);
+  return handoff2 && rest === "";
+}
+var OSC_RE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+var CSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+var CONTROL_RE = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+function stripControl(s) {
+  return s.replace(OSC_RE, "").replace(CSI_RE, "").replace(CONTROL_RE, "");
 }
 function slugify(s, max = 40) {
   const slug = s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/, "");
@@ -62,12 +125,14 @@ function slugify(s, max = 40) {
 }
 
 // ../../packages/core/src/sources/claude.ts
-var import_promises2 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
+var import_promises5 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
 
 // ../../packages/core/src/util/files.ts
+var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
+var import_node_readline = require("node:readline");
 async function listSessionFiles(root, accept) {
   let names;
   try {
@@ -87,27 +152,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 (0, import_promises.open)(file, "r");
+async function eachLine(file, each, maxBytes = 8 * 1024 * 1024) {
+  const input = (0, import_node_fs.createReadStream)(file, { encoding: "utf8", end: maxBytes - 1 });
+  const lines2 = (0, import_node_readline.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();
   }
 }
 
@@ -140,6 +192,445 @@ function blockText(content) {
   return parts.join("\n");
 }
 
+// ../../packages/core/src/sources/folder.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+
+// ../../packages/core/src/brief/write.ts
+var import_node_crypto = require("node:crypto");
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+
+// ../../packages/core/src/launch/launchers.ts
+var import_node_child_process = require("node:child_process");
+var import_promises2 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var import_node_util = require("node:util");
+var pexec = (0, import_node_util.promisify)(import_node_child_process.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 (0, import_promises2.mkdir)((0, import_node_path2.dirname)(path), { recursive: true });
+    await (0, import_promises2.writeFile)(path, content, { mode: 493 });
+    await (0, import_promises2.chmod)(path, 493);
+  },
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, 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 = (0, import_node_path2.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);
+  }
+}
+
+// ../../packages/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;
+  }
+};
+
+// ../../packages/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
+  };
+}
+
+// ../../packages/core/src/brief/write.ts
+function handoffStore(home2) {
+  return (0, import_node_path3.join)(home2, "Library", "Application Support", "Harlay", "handoffs");
+}
+function repoFolder(store, root) {
+  return (0, import_node_path3.join)(store, `${slugify((0, import_node_path3.basename)(root), 30)}-${(0, import_node_crypto.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 (0, import_promises3.readFile)((0, import_node_path3.join)(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 (0, import_promises3.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 (0, import_promises3.readdir)(dir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of names) {
+    if (!name.endsWith(".harlay") || name.startsWith(".")) continue;
+    const file = (0, import_node_path3.join)(dir, name);
+    try {
+      const at = (await (0, import_promises3.stat)(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] : [(0, import_node_path3.join)(workdir, LEGACY_FILE), (0, import_node_path3.join)(workdir, ".harlay", "handoff.json")]) {
+    const raw = await readIfExists(file);
+    if (raw === null) continue;
+    const rec = parseRecord(raw);
+    return rec ? toPrevious(rec) : null;
+  }
+  const state2 = await readHandoffState(workdir);
+  return state2 ? { id: state2.lastId, goal: state2.goal, title: state2.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 run = (writing.get(dir) ?? Promise.resolve()).catch(() => void 0).then(() => write(d, o, dir));
+  writing.set(dir, run);
+  void run.finally(() => {
+    if (writing.get(dir) === run) writing.delete(dir);
+  }).catch(() => void 0);
+  return run;
+}
+async function exists(file) {
+  try {
+    await (0, import_promises3.stat)(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function write(d, o, dir) {
+  await (0, import_promises3.mkdir)(dir, { recursive: true });
+  const tmp = (0, import_node_path3.join)(dir, `.tmp-${process.pid}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}.harlay`);
+  try {
+    for (let n = 1; ; n++) {
+      const id = n === 1 ? d.baseId : `${d.baseId}-${n}`;
+      const path = (0, import_node_path3.join)(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 (0, import_promises3.writeFile)(tmp, JSON.stringify(record, null, 2) + "\n");
+      try {
+        await (0, import_promises3.link)(tmp, path);
+      } catch (e) {
+        if (e.code === "EEXIST") continue;
+        throw e;
+      }
+      return { id, path, prompt, redactions: addCounts(d.redactions ?? {}, r.counts) };
+    }
+  } finally {
+    await (0, import_promises3.rm)(tmp, { force: true });
+  }
+}
+
+// ../../packages/core/src/sources/folder.ts
+async function isDir(p) {
+  try {
+    return (await (0, import_promises4.stat)(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function handoffRepo(file) {
+  let raw = null;
+  try {
+    raw = await (0, import_promises4.readFile)(file, "utf8");
+  } catch {
+  }
+  const root = raw === null ? null : parseRecord(raw)?.root;
+  if (root && await isDir(root)) return root;
+  return (0, import_node_path4.basename)(file) === LEGACY_FILE && await isDir((0, import_node_path4.dirname)(file)) ? (0, import_node_path4.dirname)(file) : null;
+}
+async function sessionFolder(opened, firstPrompt2) {
+  const file = firstPrompt2 === null ? null : harlayFileIn(firstPrompt2);
+  return (file && await handoffRepo(file)) ?? opened;
+}
+
 // ../../packages/core/src/sources/todos.ts
 var STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "cancelled"]);
 function applyTodoWrite(current2, input) {
@@ -160,6 +651,14 @@ function applyTodoWrite(current2, input) {
 
 // ../../packages/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;
@@ -172,16 +671,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) {
@@ -205,15 +720,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": {
@@ -221,7 +752,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;
           }
@@ -247,6 +778,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);
@@ -256,6 +792,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;
@@ -268,14 +808,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) => (0, import_node_path2.basename)(f).startsWith("local_") && f.endsWith(".json"));
+  const files = await listSessionFiles(dir, (f) => (0, import_node_path5.basename)(f).startsWith("local_") && f.endsWith(".json"));
   for (const f of files) {
     try {
-      const d = JSON.parse(await (0, import_promises2.readFile)(f.path, "utf8"));
+      const d = JSON.parse(await (0, import_promises5.readFile)(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);
       }
@@ -285,14 +825,14 @@ async function loadDesktopTitles(dir) {
   return out;
 }
 function createClaudeReader(o) {
-  const root = (0, import_node_path2.join)(o.home, ".claude", "projects");
-  const indexDir = (0, import_node_path2.join)(o.home, "Library", "Application Support", "Claude", "claude-code-sessions");
-  const isSessionFile = (file) => file.startsWith(root + import_node_path2.sep) && file.endsWith(".jsonl") && (0, import_node_path2.relative)(root, file).split(import_node_path2.sep).length === 2;
+  const root = (0, import_node_path5.join)(o.home, ".claude", "projects");
+  const indexDir = (0, import_node_path5.join)(o.home, "Library", "Application Support", "Claude", "claude-code-sessions");
+  const isSessionFile = (file) => file.startsWith(root + import_node_path5.sep) && file.endsWith(".jsonl") && (0, import_node_path5.relative)(root, file).split(import_node_path5.sep).length === 2;
   const cache = /* @__PURE__ */ new Map();
   async function refForFile(file, titles) {
     let st;
     try {
-      st = await (0, import_promises2.stat)(file);
+      st = await (0, import_promises5.stat)(file);
     } catch {
       return null;
     }
@@ -300,17 +840,20 @@ function createClaudeReader(o) {
     if (!entry || entry.size !== st.size || entry.mtimeMs !== st.mtimeMs) {
       let text;
       try {
-        text = await (0, import_promises2.readFile)(file, "utf8");
+        text = await (0, import_promises5.readFile)(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);
@@ -321,11 +864,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 = (0, import_node_path2.basename)(file, ".jsonl");
+    const id = (0, import_node_path5.basename)(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;
@@ -334,7 +892,7 @@ function createClaudeReader(o) {
     tool: "claude-code",
     root,
     isSessionFile,
-    idFromPath: (file) => isSessionFile(file) ? (0, import_node_path2.basename)(file, ".jsonl") : null,
+    idFromPath: (file) => isSessionFile(file) ? (0, import_node_path5.basename)(file, ".jsonl") : null,
     refForFile: (file) => refForFile(file),
     async listSessions(limit = 20) {
       const files = await listSessionFiles(root, isSessionFile);
@@ -348,7 +906,7 @@ function createClaudeReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await (0, import_promises2.readFile)(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await (0, import_promises5.readFile)(ref.file, "utf8"));
       return normalizeClaude(records, ref, invalid);
     },
     detect(record) {
@@ -361,11 +919,21 @@ function createClaudeReader(o) {
 }
 
 // ../../packages/core/src/sources/codex.ts
-var import_promises3 = require("node:fs/promises");
-var import_node_path3 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path6 = require("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 "";
@@ -433,7 +1001,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") {
@@ -464,11 +1033,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 (0, import_promises3.readFile)(file, "utf8");
+    text = await (0, import_promises6.readFile)(file, "utf8");
   } catch {
     return out;
   }
@@ -478,28 +1061,34 @@ async function loadTitles(file) {
   return out;
 }
 function createCodexReader(o) {
-  const root = (0, import_node_path3.join)(o.home, ".codex", "sessions");
-  const indexFile = (0, import_node_path3.join)(o.home, ".codex", "session_index.jsonl");
-  const isSessionFile = (file) => file.startsWith(root + import_node_path3.sep) && (0, import_node_path3.basename)(file).startsWith("rollout-") && file.endsWith(".jsonl");
+  const root = (0, import_node_path6.join)(o.home, ".codex", "sessions");
+  const indexFile = (0, import_node_path6.join)(o.home, ".codex", "session_index.jsonl");
+  const isSessionFile = (file) => file.startsWith(root + import_node_path6.sep) && (0, import_node_path6.basename)(file).startsWith("rollout-") && file.endsWith(".jsonl");
   const cache = /* @__PURE__ */ new Map();
   async function refForFile(file, titles) {
     let st;
     try {
-      st = await (0, import_promises3.stat)(file);
+      st = await (0, import_promises6.stat)(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;
@@ -510,7 +1099,7 @@ function createCodexReader(o) {
     tool: "codex",
     root,
     isSessionFile,
-    idFromPath: (file) => isSessionFile(file) ? ROLLOUT_ID_RE.exec((0, import_node_path3.basename)(file))?.[1] ?? null : null,
+    idFromPath: (file) => isSessionFile(file) ? ROLLOUT_ID_RE.exec((0, import_node_path6.basename)(file))?.[1] ?? null : null,
     refForFile: (file) => refForFile(file),
     async listSessions(limit = 20) {
       const files = await listSessionFiles(root, isSessionFile);
@@ -524,7 +1113,7 @@ function createCodexReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await (0, import_promises3.readFile)(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await (0, import_promises6.readFile)(ref.file, "utf8"));
       return normalizeCodex(records, ref, invalid);
     },
     detect(record) {
@@ -549,21 +1138,21 @@ function createCodexReader(o) {
 }
 
 // ../../packages/core/src/sources/cursor.ts
-var import_promises4 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path7 = require("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 (0, import_promises4.readdir)(dir, { withFileTypes: true }).catch(() => null);
+    const entries = await (0, import_promises7.readdir)(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 (0, import_node_path4.join)(dir, e.name);
+      if (rest === n) return (0, import_node_path7.join)(dir, e.name);
       if (rest.startsWith(n + "-")) {
-        const found = await walk((0, import_node_path4.join)(dir, e.name), rest.slice(n.length + 1), depth + 1);
+        const found = await walk((0, import_node_path7.join)(dir, e.name), rest.slice(n.length + 1), depth + 1);
         if (found) return found;
       }
     }
@@ -611,7 +1200,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: "" } });
@@ -623,7 +1218,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 = (0, import_node_path4.join)(o.home, ".cursor", "projects");
+  const root = (0, import_node_path7.join)(o.home, ".cursor", "projects");
   const slugCache = /* @__PURE__ */ new Map();
   const cwdFor = (slug) => {
     let p = slugCache.get(slug);
@@ -634,17 +1229,17 @@ function createCursorReader(o) {
     return p;
   };
   const isSessionFile = (file) => {
-    if (!file.startsWith(root + import_node_path4.sep) || !file.endsWith(".jsonl")) return false;
-    const parts = (0, import_node_path4.relative)(root, file).split(import_node_path4.sep);
+    if (!file.startsWith(root + import_node_path7.sep) || !file.endsWith(".jsonl")) return false;
+    const parts = (0, import_node_path7.relative)(root, file).split(import_node_path7.sep);
     return parts.length === 4 && parts[1] === "agent-transcripts" && parts[3] === `${parts[2]}.jsonl`;
   };
   const cache = /* @__PURE__ */ new Map();
   async function refForFile(file) {
     if (!isSessionFile(file)) return null;
-    const parts = (0, import_node_path4.relative)(root, file).split(import_node_path4.sep);
+    const parts = (0, import_node_path7.relative)(root, file).split(import_node_path7.sep);
     let st;
     try {
-      st = await (0, import_promises4.stat)(file);
+      st = await (0, import_promises7.stat)(file);
     } catch {
       return null;
     }
@@ -652,21 +1247,25 @@ function createCursorReader(o) {
     if (hit && hit.size === st.size && hit.mtimeMs === st.mtimeMs) return hit.ref;
     let text;
     try {
-      text = await (0, import_promises4.readFile)(file, "utf8");
+      text = await (0, import_promises7.readFile)(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));
-        if (p && !isHandoffPrompt(p)) {
-          title = oneLine(p, 60);
+        first ??= p;
+        const rest = p ? splitHandoffPrompt(p).rest : "";
+        if (rest) {
+          title = oneLine(rest, 60);
           break;
         }
       }
     }
-    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;
   }
@@ -674,7 +1273,7 @@ function createCursorReader(o) {
     tool: "cursor",
     root,
     isSessionFile,
-    idFromPath: (file) => isSessionFile(file) ? (0, import_node_path4.relative)(root, file).split(import_node_path4.sep)[2] : null,
+    idFromPath: (file) => isSessionFile(file) ? (0, import_node_path7.relative)(root, file).split(import_node_path7.sep)[2] : null,
     refForFile,
     async listSessions(limit = 20) {
       const files = await listSessionFiles(root, isSessionFile);
@@ -687,7 +1286,7 @@ function createCursorReader(o) {
       return refs;
     },
     async readSession(ref) {
-      const { records, invalid } = parseJsonLines(await (0, import_promises4.readFile)(ref.file, "utf8"));
+      const { records, invalid } = parseJsonLines(await (0, import_promises7.readFile)(ref.file, "utf8"));
       return normalizeCursor(records, ref, invalid);
     },
     detect(record) {
@@ -700,14 +1299,14 @@ function createCursorReader(o) {
 }
 
 // ../../packages/core/src/git/snapshot.ts
-var import_node_child_process = require("node:child_process");
-var import_node_crypto = require("node:crypto");
-var import_node_util = require("node:util");
-var pexec = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_util2 = require("node:util");
+var pexec2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
 var MAX_DIFF_CHARS = 2e6;
 var MAX_FILES = 500;
 async function git(cwd, args) {
-  const { stdout } = await pexec("git", args, {
+  const { stdout } = await pexec2("git", args, {
     cwd,
     maxBuffer: 64 * 1024 * 1024,
     env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" }
@@ -776,97 +1375,42 @@ 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 = (0, import_node_crypto.createHash)("sha256").update(diff).digest("hex");
+  const diffSha = (0, import_node_crypto2.createHash)("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 };
 }
 
-// ../../packages/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;
+// ../../packages/core/src/extract/extract.ts
+var import_node_path8 = require("node:path");
+
+// ../../packages/core/src/extract/recent.ts
+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 };
 }
-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;
-  }
-};
 
 // ../../packages/core/src/extract/extract.ts
-var import_node_path5 = require("node:path");
-var DECISION_RE = /\b(don['’]t|do not|never|must|always|keep|avoid|make sure|without|instead of)\b/i;
 var TRANSCRIPT_MAX = 2e5;
+var SLASH_COMMAND_RE = /^\/[a-z][\w-]*(\s|$)/i;
+function isSlashCommand(p) {
+  return SLASH_COMMAND_RE.test(p.trim());
+}
 function isSubstantive(p) {
   const t = p.trim();
-  return !t.startsWith("/") && t.split(/\s+/).length >= 3;
+  return !isSlashCommand(t) && t.split(/\s+/).length >= 3;
 }
 var PROBES = /* @__PURE__ */ new Set([
   "rg",
@@ -896,401 +1440,203 @@ 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 = (0, import_node_path5.basename)(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 = (0, import_node_path8.basename)(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 findBlocker(cmds) {
-  for (let i = cmds.length - 1; i >= 0; i--) {
-    const c = cmds[i];
-    if (c.exitCode === null || c.exitCode === 0 || isProbeCommand(c.cmd)) continue;
-    if (!cmds.slice(i + 1).some((d) => d.cmd === c.cmd && d.exitCode === 0)) return c;
+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;
+    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;
 }
-function findDeadEnds(cmds, blocker) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  cmds.forEach((c, i) => {
-    if (c.exitCode === null || c.exitCode === 0 || seen.has(c.cmd) || isProbeCommand(c.cmd)) return;
-    if (blocker && c.cmd === blocker.cmd) return;
-    if (cmds.slice(i + 1).some((d) => d.cmd === c.cmd && d.exitCode === 0)) return;
-    seen.add(c.cmd);
-    out.push({ cmd: c.cmd, exitCode: c.exitCode });
+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 out.slice(-5);
-}
-function findDecisions(prompts) {
-  const out = [];
-  for (const p of prompts) {
-    for (const s of p.split(/(?<=[.!?])\s+|\n+/)) {
-      const t = s.trim();
-      if (t.length >= 8 && t.length <= 300 && DECISION_RE.test(t) && !out.includes(t)) out.push(t);
-    }
-  }
-  return out.slice(-8);
-}
-function buildTranscript(s, title, rel) {
-  const lines = [`# Condensed transcript: ${title}`, "", `Source: ${TOOL_LABEL[s.ref.tool]} session \`${s.ref.id}\``, ""];
+  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");
+  return nl === -1 ? "" : output.slice(nl + 1);
+}
+function buildTranscript(s, title, rel, redactor) {
+  const r = (x) => redactor.apply(x);
+  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") lines.push("**User:**", t.text, "");
-    else if (t.kind === "assistant") lines.push("**Agent:**", t.text.length > 600 ? t.text.slice(0, 599) + "\u2026" : t.text, "");
-    else if (t.kind === "command") lines.push(`\`$ ${oneLine(t.run.cmd, 200)}\`${t.run.exitCode === null ? "" : ` \u2192 exit ${t.run.exitCode}`}`, "");
-    else lines.push(`Edited \`${rel(t.edit.path)}\` (${t.edit.kind})`, "");
-  }
-  const out = lines.join("\n");
-  return out.length > TRANSCRIPT_MAX ? "\u2026(earlier transcript truncated)\n" + out.slice(out.length - TRANSCRIPT_MAX) : out;
+    if (t.kind === "user") {
+      const { handoff: handoff2, rest } = splitHandoffPrompt(t.text);
+      if (handoff2) 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);
+      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 = lines2.join("\n");
+  if (out.length <= TRANSCRIPT_MAX) return out;
+  const cut = out.slice(out.length - TRANSCRIPT_MAX);
+  const nl = cut.indexOf("\n");
+  return "\u2026(earlier transcript truncated)\n" + (nl === -1 ? cut : cut.slice(nl + 1));
 }
 function extractHandoff(s, git2, o) {
   const cwd = s.ref.cwd;
   if (!cwd) throw new HarlayError("This session has no known working directory, so Harlay cannot hand it off.");
   const workdir = git2?.root ?? cwd;
   const rel = (p) => {
-    if (!(0, import_node_path5.isAbsolute)(p)) return p;
-    const r = (0, import_node_path5.relative)(workdir, p);
-    return r.startsWith("..") || (0, import_node_path5.isAbsolute)(r) ? p : r;
+    if (!(0, import_node_path8.isAbsolute)(p)) return p;
+    const r = (0, import_node_path8.relative)(workdir, p);
+    return r.startsWith("..") || (0, import_node_path8.isAbsolute)(r) ? p : r;
   };
-  const allPrompts = s.timeline.flatMap((t) => t.kind === "user" ? [t.text] : []);
-  const prompts = allPrompts.filter((p) => !isHandoffPrompt(p));
+  const split = s.timeline.flatMap((t) => t.kind === "user" ? [splitHandoffPrompt(t.text)] : []);
+  const prompts = split.flatMap((p) => p.rest ? [p.rest] : []);
   const agentTexts = s.timeline.flatMap((t) => t.kind === "assistant" ? [t.text] : []);
   const cmds = s.timeline.flatMap((t) => t.kind === "command" ? [t.run] : []);
   const edits = s.timeline.flatMap((t) => t.kind === "edit" ? [t.edit] : []);
-  const carried = o.previous && o.previous.goal !== null && prompts.length < allPrompts.length ? o.previous : null;
-  const goal = carried ? carried.goal : prompts.find(isSubstantive) ?? prompts[0] ?? null;
-  const last = carried ? [...prompts].reverse().find(isSubstantive) ?? null : prompts.length ? prompts[prompts.length - 1] : null;
-  const latestInstruction = last !== null && last !== goal && isSubstantive(last) ? last : null;
+  const redactor = new Redactor();
+  const realPrompts = prompts.filter((p) => !isSlashCommand(p)).map((p) => redactor.apply(p));
+  const prev = o.previous;
+  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 carriedMessages = carried ? carried.userMessages.map((m) => redactor.apply(m)) : [];
+  const picked = pickUserMessages([...carriedMessages, ...realPrompts]);
+  const userMessages2 = 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 nextTodo = todos.find((t) => t.status === "in_progress") ?? todos.find((t) => t.status === "pending");
   const lastAgent = agentTexts.length ? agentTexts[agentTexts.length - 1] : null;
-  const nextStep = nextTodo ? { text: nextTodo.text, source: "todo" } : lastAgent ? { text: lastAgent, source: "agent" } : null;
-  const blocker = findBlocker(cmds);
-  const editedFiles = [];
-  const counts = /* @__PURE__ */ new Map();
-  for (const e of edits) {
+  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()) {
     const r = rel(e.path);
-    if (!editedFiles.includes(r)) editedFiles.push(r);
-    counts.set(r, (counts.get(r) ?? 0) + 1);
-  }
-  const readFirst = [...editedFiles].sort((a, b) => (counts.get(b) ?? 0) - (counts.get(a) ?? 0)).slice(0, 3);
-  const progress = todos.length ? todos.map((t) => ({ text: t.text, done: t.status === "completed" })) : editedFiles.map((f) => ({ text: `\`${f}\``, done: true }));
-  const progressSource = todos.length ? "todos" : editedFiles.length ? "edits" : "none";
-  const redactor = new Redactor();
-  const title = carried ? carried.title : s.ref.title ?? (goal ? oneLine(redactor.apply(goal), 60) : "Untitled task");
-  const pad = (n2) => String(n2).padStart(2, "0");
-  const n = o.now;
-  const baseId = `${pad(n.getMonth() + 1)}${pad(n.getDate())}-${pad(n.getHours())}${pad(n.getMinutes())}-${slugify(redactor.apply(title))}`;
-  return {
-    baseId,
-    title,
-    status: "in_progress",
-    createdAt: o.now,
-    from: {
-      tool: s.ref.tool,
-      model: s.model,
-      session: s.ref.id,
-      reason: o.reason ?? s.halt?.reason ?? "manual",
-      resetsAt: s.halt?.resetsAt ?? null,
-      message: s.halt?.message ?? null
-    },
-    workdir,
-    git: git2,
-    goal,
-    latestInstruction,
-    nextStep,
-    blocker: blocker && blocker.exitCode !== null ? { cmd: blocker.cmd, exitCode: blocker.exitCode, output: blocker.output } : null,
-    progress,
-    progressSource,
-    editedFiles,
-    decisions: findDecisions(prompts),
-    deadEnds: findDeadEnds(cmds, blocker),
-    readFirst,
-    transcript: buildTranscript(s, title, rel),
-    unknownRecords: s.unknownRecords
-  };
-}
-
-// ../../packages/core/src/brief/render.ts
-var BUDGET = { goal: 150, latest: 100, next: 200, blocker: 250, progress: 300, files: 300, decisions: 250, deadEnds: 200 };
-var REASON_TEXT = {
-  usage_limit: "it hit a usage limit",
-  crash: "it stopped with an error",
-  manual: "the user handed it off"
-};
-var j = (v) => JSON.stringify(v ?? null);
-function quote(s) {
-  return s.split("\n").map((l) => l.trim() ? `> ${l}` : ">").join("\n");
-}
-function listWithin(lines, maxTokens, pointer) {
-  const max = maxTokens * CHARS_PER_TOKEN;
-  const out = [];
-  let used = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (out.length > 0 && used + line.length + 1 > max) {
-      out.push(`- \u2026 ${lines.length - i} more (see \`${pointer}\`)`);
-      break;
-    }
-    out.push(line);
-    used += line.length + 1;
-  }
-  return out;
-}
-function tailWithin(s, maxTokens) {
-  const max = maxTokens * CHARS_PER_TOKEN;
-  const t = s.trimEnd();
-  if (t.length <= max) return t;
-  const cut = t.slice(t.length - max);
-  const nl = cut.indexOf("\n");
-  return "\u2026\n" + (nl >= 0 ? cut.slice(nl + 1) : cut);
-}
-function fenceFor(body) {
-  const longest = Math.max(0, ...(body.match(/`+/g) ?? []).map((r) => r.length));
-  return "`".repeat(Math.max(3, longest + 1));
-}
-function fileLine(f) {
-  const counts = f.added !== null && f.removed !== null ? `, +${f.added} -${f.removed}` : "";
-  return `- \`${f.path}\` (${f.status}${counts})`;
-}
-function renderBrief(d, id, opts = {}) {
-  const dir = `.harlay/handoffs/${id}`;
-  const transcript = `${dir}/transcript.md`;
-  const front = [
-    "---",
-    "harlay: 1",
-    `id: ${j(id)}`,
-    `status: ${j(d.status)}`,
-    `created: ${j(d.createdAt.toISOString())}`,
-    "from:",
-    `  tool: ${j(d.from.tool)}`,
-    `  model: ${j(d.from.model)}`,
-    `  session: ${j(d.from.session)}`,
-    `  reason: ${j(d.from.reason)}`,
-    `  resets_at: ${j(d.from.resetsAt ? d.from.resetsAt.toISOString() : null)}`,
-    "repo:",
-    `  path: ${j(d.workdir)}`,
-    ...d.git ? [`  branch: ${j(d.git.branch)}`, `  base_commit: ${j(d.git.head)}`, `  dirty_files: ${d.git.files.length}`, `  diff_sha: ${j(d.git.diffSha.slice(0, 12))}`] : ["  git: false"],
-    "---"
-  ];
-  const header = [
-    `# Continue: ${d.title}`,
-    "",
-    `> You are continuing a coding task that another AI agent (${TOOL_LABEL[d.from.tool]}) started but could not finish (${REASON_TEXT[d.from.reason]}).`,
-    "> This brief was extracted from its session log and the repo.",
-    d.git ? '> First run `git status` and check it matches "Changed files". Do not redo finished work.' : "> Check the files listed below before editing. Do not redo finished work."
-  ];
-  const goal = ["## 1. Goal (user's words)", d.goal ? quote(clip(d.goal, BUDGET.goal, transcript)) : "Not recorded. See the transcript."];
-  if (d.latestInstruction) goal.push("", "Latest instruction:", quote(clip(d.latestInstruction, BUDGET.latest, transcript)));
-  const next = ["## 2. Next step"];
-  if (!d.nextStep) next.push("Not recorded. Re-read the goal and the changed files, then decide.");
-  else if (d.nextStep.source === "todo") next.push(clip(oneLine(d.nextStep.text, 200), BUDGET.next));
-  else next.push("From the agent's last message:", quote(clip(d.nextStep.text, BUDGET.next)));
-  const blocker = ["## 3. Blocker"];
-  if (d.blocker) {
-    const body = tailWithin(d.blocker.output, BUDGET.blocker);
-    const fence = fenceFor(body);
-    blocker.push(`\`${oneLine(d.blocker.cmd, 200)}\` failed (exit ${d.blocker.exitCode}):`, `${fence}text`, body, fence, `Full output: \`${dir}/last-error.txt\``);
-  } else {
-    blocker.push("No failing command recorded.");
-  }
-  const progress = ["## 4. Progress"];
-  if (d.progressSource === "none") progress.push("Nothing recorded yet.");
-  else {
-    if (d.progressSource === "edits") progress.push("No task list was recorded. Files the agent edited:");
-    progress.push(...listWithin(d.progress.map((p) => `- [${p.done ? "x" : " "}] ${oneLine(p.text, 200)}`), BUDGET.progress, transcript));
-  }
-  const files = [];
-  if (d.git) {
-    files.push("## 5. Changed files (uncommitted)");
-    if (d.git.files.length === 0) files.push("Working tree is clean.");
-    else files.push(...listWithin(d.git.files.map(fileLine), BUDGET.files, `${dir}/diff.patch`), `Full diff: \`${dir}/diff.patch\``);
-  } else {
-    files.push("## 5. Changed files", "Not a git repository." + (d.editedFiles.length ? " Files the agent edited:" : ""));
-    files.push(...listWithin(d.editedFiles.map((f) => `- \`${f}\``), BUDGET.files, transcript));
-  }
-  const decisions = [
-    "## 6. Decisions and constraints",
-    ...d.decisions.length ? listWithin(d.decisions.map((s) => `- "${oneLine(s, 300)}"`), BUDGET.decisions, transcript) : ["None recorded."]
-  ];
-  const deadEnds = [
-    "## 7. Dead ends (don't retry)",
-    ...d.deadEnds.length ? listWithin(d.deadEnds.map((e) => `- \`${oneLine(e.cmd, 160)}\` failed (exit ${e.exitCode})`), BUDGET.deadEnds, transcript) : ["None recorded."]
-  ];
-  const more = ["## 8. Read more", `- Condensed transcript: \`${transcript}\``];
-  if (opts.previousBrief) more.push(`- Previous brief (as last updated by the previous agent): \`${dir}/previous-HANDOFF.md\``);
-  if (d.readFirst.length) more.push(`- Read these first: ${d.readFirst.map((f) => `\`${f}\``).join(", ")}`);
-  const stop = ["## 9. When you stop", "Before ending your turn, update sections 2\u20134 and `status:` in this file so the next agent can continue."];
-  return [front, header, goal, next, blocker, progress, files, decisions, deadEnds, more, stop].map((s) => s.join("\n")).join("\n\n") + "\n";
-}
-
-// ../../packages/core/src/brief/write.ts
-var import_promises5 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
-async function allocateHandoffId(handoffsDir, baseId) {
-  for (let i = 1; i < 1e3; i++) {
-    const id = i === 1 ? baseId : `${baseId}-${i}`;
-    try {
-      await (0, import_promises5.access)((0, import_node_path6.join)(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 = (0, import_node_path6.isAbsolute)(p) ? p : (0, import_node_path6.join)(workdir, p);
-  let current2 = "";
-  try {
-    current2 = await (0, import_promises5.readFile)(file, "utf8");
-  } catch {
-    current2 = "";
-  }
-  if (current2.split("\n").some((l) => l.trim() === ".harlay/" || l.trim() === ".harlay")) return;
-  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(file), { recursive: true });
-  await (0, import_promises5.appendFile)(file, `${current2 && !current2.endsWith("\n") ? "\n" : ""}.harlay/
-`);
-}
-async function readHandoffState(workdir) {
-  let raw;
-  try {
-    raw = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path6.join)(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 (0, import_promises5.readFile)(file, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function writeHandoff(d) {
-  const harlayDir = (0, import_node_path6.join)(d.workdir, ".harlay");
-  const latestPath = (0, import_node_path6.join)(harlayDir, "HANDOFF.md");
-  const id = await allocateHandoffId((0, import_node_path6.join)(harlayDir, "handoffs"), d.baseId);
-  const dir = (0, import_node_path6.join)(harlayDir, "handoffs", id);
-  await (0, import_promises5.mkdir)(dir, { recursive: true });
-  const r = new Redactor();
-  const previous = await readIfExists(latestPath);
-  if (previous !== null) await (0, import_promises5.writeFile)((0, import_node_path6.join)(dir, "previous-HANDOFF.md"), r.apply(previous));
-  const brief = r.apply(renderBrief(d, id, { previousBrief: previous !== null }));
-  const briefPath = (0, import_node_path6.join)(dir, "HANDOFF.md");
-  await (0, import_promises5.writeFile)(briefPath, brief);
-  await (0, import_promises5.writeFile)((0, import_node_path6.join)(dir, "transcript.md"), r.apply(d.transcript));
-  if (d.git) await (0, import_promises5.writeFile)((0, import_node_path6.join)(dir, "diff.patch"), r.apply(d.git.diff));
-  if (d.blocker) await (0, import_promises5.writeFile)((0, import_node_path6.join)(dir, "last-error.txt"), r.apply(d.blocker.output));
-  const from = {
-    ...d.from,
-    message: d.from.message === null ? null : r.apply(d.from.message),
-    resetsAt: d.from.resetsAt ? d.from.resetsAt.toISOString() : null
-  };
-  const goal = d.goal === null ? null : r.apply(d.goal);
-  const title = r.apply(d.title);
-  const meta = {
-    harlay: 1,
-    id,
-    createdAt: d.createdAt.toISOString(),
-    title,
-    goal,
-    from,
-    workdir: d.workdir,
-    unknownRecords: d.unknownRecords,
-    git: d.git ? { branch: d.git.branch, head: d.git.head, files: d.git.files.length, diffSha: d.git.diffSha } : null,
-    redactions: { ...r.counts }
-  };
-  await (0, import_promises5.writeFile)((0, import_node_path6.join)(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
-  await (0, import_promises5.writeFile)(latestPath, brief);
-  const state2 = { harlay: 1, lastId: id, goal, title };
-  await (0, import_promises5.writeFile)((0, import_node_path6.join)(harlayDir, "state.json"), JSON.stringify(state2, null, 2) + "\n");
-  if (d.git) await ensureGitExclude(d.workdir);
-  return { id, dir, briefPath, latestPath, redactions: { ...r.counts } };
-}
-
-// ../../packages/core/src/launch/launchers.ts
-var import_node_child_process2 = require("node:child_process");
-var import_promises6 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
-var import_node_util2 = require("node:util");
-var pexec2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
-var HANDOFF_PROMPT = "Read .harlay/HANDOFF.md and continue the task.";
-var DEFAULT_MODES = { "claude-code": "app", codex: "app", cursor: "app" };
-var defaultRunner = {
-  async open(args) {
-    await pexec2("/usr/bin/open", args);
-  },
-  async writeExecutable(path, content) {
-    await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path), { recursive: true });
-    await (0, import_promises6.writeFile)(path, content, { mode: 493 });
-    await (0, import_promises6.chmod)(path, 493);
-  },
-  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, 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)}`] }
-          ]
-        };
-    }
+    if (!(0, import_node_path8.isAbsolute)(r) && !filesTouched.includes(r)) filesTouched.push(r);
+    if (filesTouched.length === 12) break;
   }
-  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 = (0, import_node_path7.join)(o.scriptDir, `continue-${o.target}.command`);
-  const content = `#!/bin/zsh -l
-cd -- ${shq(o.cwd)} || exit 1
-exec ${argv.map(shq).join(" ")}
-`;
+  const title = carried ? carried.title : s.ref.title ?? (originalGoal ? oneLine(redactor.apply(originalGoal), 60) : "Untitled task");
+  const pad = (n2) => String(n2).padStart(2, "0");
+  const n = o.now;
+  const baseId = `${pad(n.getMonth() + 1)}${pad(n.getDate())}-${pad(n.getHours())}${pad(n.getMinutes())}-${slugify(redactor.apply(title))}`;
   return {
-    target: o.target,
-    mode: o.mode,
-    steps: [
-      { kind: "script", path, content },
-      { kind: "open", args: ["-a", o.terminalApp, path] }
-    ]
+    baseId,
+    title,
+    createdAt: o.now,
+    from: {
+      tool: s.ref.tool,
+      model: s.model,
+      session: s.ref.id,
+      reason: o.reason ?? s.halt?.reason ?? "manual",
+      resetsAt: s.halt?.resetsAt ?? null,
+      message: s.halt?.message ?? null
+    },
+    workdir,
+    git: git2,
+    originalGoal,
+    userMessages: userMessages2,
+    omittedMessages,
+    whereItStopped,
+    lastRequest: userMessages2.at(-1) ?? null,
+    todos: openTodos,
+    results,
+    references,
+    filesTouched,
+    lastFailure,
+    transcript: buildTranscript(s, title, rel, redactor),
+    unknownRecords: s.unknownRecords,
+    redactions: { ...redactor.counts },
+    carriedFrom: carried ? carried.id : null
   };
 }
-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);
-  }
-}
 
 // ../../packages/core/src/launch/resolve.ts
-var import_node_fs = require("node:fs");
-var import_promises7 = require("node:fs/promises");
+var import_node_fs2 = require("node:fs");
+var import_promises8 = require("node:fs/promises");
 var import_node_os = require("node:os");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 function defaultResolveOptions(env = process.env) {
   return {
     home: env.HARLAY_HOME ?? (0, import_node_os.homedir)(),
@@ -1304,28 +1650,28 @@ var APP_BUNDLES = { "claude-code": ["Claude.app"], codex: ["ChatGPT.app", "Codex
 function knownPaths(tool, o) {
   switch (tool) {
     case "claude-code":
-      return [(0, import_node_path8.join)(o.home, ".local", "bin", "claude")];
+      return [(0, import_node_path9.join)(o.home, ".local", "bin", "claude")];
     case "codex":
       return [
-        (0, import_node_path8.join)(o.applicationsDir, "ChatGPT.app", "Contents", "Resources", "codex-cli", "bin", "codex"),
-        (0, import_node_path8.join)(o.applicationsDir, "Codex.app", "Contents", "Resources", "codex-cli", "bin", "codex")
+        (0, import_node_path9.join)(o.applicationsDir, "ChatGPT.app", "Contents", "Resources", "codex-cli", "bin", "codex"),
+        (0, import_node_path9.join)(o.applicationsDir, "Codex.app", "Contents", "Resources", "codex-cli", "bin", "codex")
       ];
     case "cursor":
-      return [(0, import_node_path8.join)(o.home, ".local", "bin", "cursor-agent")];
+      return [(0, import_node_path9.join)(o.home, ".local", "bin", "cursor-agent")];
   }
 }
 async function isExecutable(p) {
   try {
-    if (!(await (0, import_promises7.stat)(p)).isFile()) return false;
-    await (0, import_promises7.access)(p, import_node_fs.constants.X_OK);
+    if (!(await (0, import_promises8.stat)(p)).isFile()) return false;
+    await (0, import_promises8.access)(p, import_node_fs2.constants.X_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function exists(p) {
+async function exists2(p) {
   try {
-    await (0, import_promises7.access)(p);
+    await (0, import_promises8.access)(p);
     return true;
   } catch {
     return false;
@@ -1334,7 +1680,7 @@ async function exists(p) {
 async function resolveBinary(tool, o) {
   const dirs = [...(o.pathEnv ?? "").split(":").filter(Boolean), ...o.systemDirs];
   for (const d of dirs) {
-    const p = (0, import_node_path8.join)(d, BIN_NAME[tool]);
+    const p = (0, import_node_path9.join)(d, BIN_NAME[tool]);
     if (await isExecutable(p)) return p;
   }
   for (const p of knownPaths(tool, o)) if (await isExecutable(p)) return p;
@@ -1353,7 +1699,7 @@ async function availableTargets(o) {
   const out = {};
   for (const t of TOOLS) {
     let app2 = false;
-    for (const b of APP_BUNDLES[t]) if (await exists((0, import_node_path8.join)(o.applicationsDir, b))) app2 = true;
+    for (const b of APP_BUNDLES[t]) if (await exists2((0, import_node_path9.join)(o.applicationsDir, b))) app2 = true;
     out[t] = { app: app2, terminal: bins[t] !== void 0 };
   }
   return out;
@@ -1368,53 +1714,109 @@ function readerFor(readers2, tool) {
   if (!r) throw new HarlayError(`No reader for ${tool}`);
   return r;
 }
-async function listAllSessions(readers2, limit = 20) {
-  const all = (await Promise.all(readers2.map((r) => r.listSessions(limit)))).flat();
-  return all.sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime()).slice(0, limit);
+async function findSessionById(readers2, tool, id) {
+  const reader = readerFor(readers2, tool);
+  const files = (await listSessionFiles(reader.root, reader.isSessionFile)).map((f) => ({ path: f.path, id: reader.idFromPath(f.path) }));
+  const exact = files.filter((f) => f.id === id);
+  const prefix = files.filter((f) => f.id !== null && f.id !== id && f.id.startsWith(id));
+  for (const f of [...exact, ...prefix]) {
+    const ref = await reader.refForFile(f.path);
+    if (ref) return ref;
+  }
+  return null;
+}
+function parseTool(name) {
+  const n = name.trim().toLowerCase();
+  if (n === "claude" || n === "claude-code" || n === "cc") return "claude-code";
+  if (n === "codex") return "codex";
+  if (n === "cursor") return "cursor";
+  throw new HarlayError(`Unknown tool "${name}". Use claude, codex or cursor.`);
+}
+function parseSessionSpec(spec) {
+  const i = spec.indexOf(":");
+  if (i <= 0 || i === spec.length - 1) throw new HarlayError(`Invalid --session "${spec}". Use <tool>:<id>, for example codex:019a\u2026`);
+  return { tool: parseTool(spec.slice(0, i)), id: spec.slice(i + 1) };
 }
 
 // ../../packages/core/src/handoff.ts
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
+var import_node_os2 = require("node:os");
+var import_node_path10 = require("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: (0, import_node_path10.join)(o.scriptDir ?? (0, import_node_path10.join)((0, import_node_os2.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 (0, import_promises8.stat)(cwd)).isDirectory()) throw new Error("not a directory");
+    if (!(await (0, import_promises9.stat)(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 state2 = await readHandoffState(git2?.root ?? cwd);
-  const previous = state2 ? { id: state2.lastId, goal: state2.goal, title: state2.title } : null;
+  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);
+  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: HANDOFF_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 };
 }
 
+// ../../packages/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(readers2, h) {
+  const reader = readerFor(readers2, 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;
+}
+
 // ../../packages/core/src/watch/watcher.ts
 var import_node_events = require("node:events");
-var import_node_fs2 = require("node:fs");
-var import_promises9 = require("node:fs/promises");
-var import_node_path9 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_promises10 = require("node:fs/promises");
+var import_node_path11 = require("node:path");
 var import_node_string_decoder = require("node:string_decoder");
 var Watcher = class extends import_node_events.EventEmitter {
   constructor(readers2, opts = {}) {
@@ -1438,14 +1840,14 @@ var Watcher = class extends import_node_events.EventEmitter {
     for (const r of this.readers) {
       for (const f of await listSessionFiles(r.root, r.isSessionFile)) {
         try {
-          this.offsets.set(f.path, (await (0, import_promises9.stat)(f.path)).size);
+          this.offsets.set(f.path, (await (0, import_promises10.stat)(f.path)).size);
         } catch {
         }
       }
       if (this.opts.fsWatch === false) continue;
       try {
-        const w = (0, import_node_fs2.watch)(r.root, { recursive: true }, (_event, name) => {
-          if (name) this.schedule((0, import_node_path9.join)(r.root, name.toString()));
+        const w = (0, import_node_fs3.watch)(r.root, { recursive: true }, (_event, name) => {
+          if (name) this.schedule((0, import_node_path11.join)(r.root, name.toString()));
         });
         w.on("error", (e) => this.emit("error", e));
         this.watchers.push(w);
@@ -1466,7 +1868,7 @@ var Watcher = class extends import_node_events.EventEmitter {
       for (const f of await listSessionFiles(r.root, r.isSessionFile)) {
         let size;
         try {
-          size = (await (0, import_promises9.stat)(f.path)).size;
+          size = (await (0, import_promises10.stat)(f.path)).size;
         } catch {
           continue;
         }
@@ -1523,7 +1925,7 @@ var Watcher = class extends import_node_events.EventEmitter {
     if (!reader) return [];
     let size;
     try {
-      size = (await (0, import_promises9.stat)(file)).size;
+      size = (await (0, import_promises10.stat)(file)).size;
     } catch {
       return [];
     }
@@ -1535,7 +1937,7 @@ var Watcher = class extends import_node_events.EventEmitter {
     }
     if (size === offset) return [];
     const buf = Buffer.alloc(size - offset);
-    const fh = await (0, import_promises9.open)(file, "r");
+    const fh = await (0, import_promises10.open)(file, "r");
     try {
       await fh.read(buf, 0, buf.length, offset);
     } finally {
@@ -1547,10 +1949,10 @@ var Watcher = class extends import_node_events.EventEmitter {
       decoder = new import_node_string_decoder.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 {
@@ -1612,8 +2014,8 @@ function fullestWindow(s) {
 
 // ../../packages/core/src/usage/codex.ts
 var import_node_child_process3 = require("node:child_process");
-var import_promises10 = require("node:fs/promises");
-var import_node_path10 = require("node:path");
+var import_promises11 = require("node:fs/promises");
+var import_node_path12 = require("node:path");
 var PACE_MS = 60 * 6e4;
 var TAIL_BYTES = 1024 * 1024;
 function num(x) {
@@ -1638,7 +2040,7 @@ function planOf(rl) {
   return typeof p === "string" ? p : null;
 }
 async function readTail(file, bytes) {
-  const fh = await (0, import_promises10.open)(file, "r");
+  const fh = await (0, import_promises11.open)(file, "r");
   try {
     const { size } = await fh.stat();
     const start = Math.max(0, size - bytes);
@@ -1651,7 +2053,7 @@ async function readTail(file, bytes) {
   }
 }
 async function readCodexReadings(home2, files = 8) {
-  const logs = (await listSessionFiles((0, import_node_path10.join)(home2, ".codex", "sessions"), (f) => f.endsWith(".jsonl"))).slice(0, files);
+  const logs = (await listSessionFiles((0, import_node_path12.join)(home2, ".codex", "sessions"), (f) => f.endsWith(".jsonl"))).slice(0, files);
   const out = [];
   for (const { path } of logs) {
     let text;
@@ -1755,8 +2157,8 @@ function queryCodexUsage(codexBin, timeoutMs = 15e3) {
 }
 
 // ../../packages/core/src/usage/claude.ts
-var import_promises11 = require("node:fs/promises");
-var import_node_path11 = require("node:path");
+var import_promises12 = require("node:fs/promises");
+var import_node_path13 = require("node:path");
 var HOUR = 36e5;
 var SAMPLE_MAX_AGE_MS = 30 * 24 * HOUR;
 var DISPROVE_FACTOR = 1.15;
@@ -1782,18 +2184,18 @@ var ClaudeUsageLog = class {
   replies = /* @__PURE__ */ new Map();
   hits = /* @__PURE__ */ new Map();
   async refresh(now = /* @__PURE__ */ new Date(), maxAgeMs = 8 * 24 * HOUR) {
-    const root = (0, import_node_path11.join)(this.home, ".claude", "projects");
+    const root = (0, import_node_path13.join)(this.home, ".claude", "projects");
     let names;
     try {
-      names = await (0, import_promises11.readdir)(root, { recursive: true });
+      names = await (0, import_promises12.readdir)(root, { recursive: true });
     } catch {
       return;
     }
     for (const name of names) {
       if (!name.endsWith(".jsonl")) continue;
-      const path = (0, import_node_path11.join)(root, name);
+      const path = (0, import_node_path13.join)(root, name);
       try {
-        const s = await (0, import_promises11.stat)(path);
+        const s = await (0, import_promises12.stat)(path);
         if (now.getTime() - s.mtimeMs > maxAgeMs) continue;
         await this.readFrom(path, s.size);
       } catch {
@@ -1807,15 +2209,15 @@ var ClaudeUsageLog = class {
     const st = this.files.get(path) ?? { offset: 0, partial: "" };
     if (size < st.offset) Object.assign(st, { offset: 0, partial: "" });
     if (size === st.offset) return;
-    const fh = await (0, import_promises11.open)(path, "r");
+    const fh = await (0, import_promises12.open)(path, "r");
     try {
       const buf = Buffer.alloc(size - st.offset);
       await fh.read(buf, 0, buf.length, st.offset);
       st.offset = size;
       const text = st.partial + buf.toString("utf8");
-      const lines = text.split("\n");
-      st.partial = lines.pop() ?? "";
-      for (const line of lines) this.ingest(line);
+      const lines2 = text.split("\n");
+      st.partial = lines2.pop() ?? "";
+      for (const line of lines2) this.ingest(line);
     } finally {
       await fh.close();
       this.files.set(path, st);
@@ -2010,18 +2412,18 @@ function claudeSnapshot({ entries, hits, exact, samples, now }) {
 }
 
 // ../../packages/core/src/usage/bridge.ts
-var import_promises12 = require("node:fs/promises");
-var import_node_path12 = require("node:path");
+var import_promises13 = require("node:fs/promises");
+var import_node_path14 = require("node:path");
 var BRIDGE_MARKER = "# harlay-usage";
 function claudeSettingsPath(home2) {
-  return (0, import_node_path12.join)(home2, ".claude", "settings.json");
+  return (0, import_node_path14.join)(home2, ".claude", "settings.json");
 }
 function claudeStatusFile(dataDir2) {
-  return (0, import_node_path12.join)(dataDir2, "claude-status.json");
+  return (0, import_node_path14.join)(dataDir2, "claude-status.json");
 }
-var scriptPath = (dataDir2) => (0, import_node_path12.join)(dataDir2, "claude-statusline.sh");
-var previousJson = (dataDir2) => (0, import_node_path12.join)(dataDir2, "claude-statusline.previous.json");
-var previousCommand = (dataDir2) => (0, import_node_path12.join)(dataDir2, "claude-statusline.previous");
+var scriptPath = (dataDir2) => (0, import_node_path14.join)(dataDir2, "claude-statusline.sh");
+var previousJson = (dataDir2) => (0, import_node_path14.join)(dataDir2, "claude-statusline.previous.json");
+var previousCommand = (dataDir2) => (0, import_node_path14.join)(dataDir2, "claude-statusline.previous");
 var BRIDGE_SCRIPT = `#!/bin/sh
 # Harlay's Claude Code status line. Saves Claude Code's status line input (it includes your exact usage)
 # for Harlay, then shows your previous status line, or a short usage summary if you had none.
@@ -2047,28 +2449,28 @@ function bridgeCommand(dataDir2) {
   const q = `'${scriptPath(dataDir2).replace(/'/g, `'\\''`)}'`;
   return `${q} ${BRIDGE_MARKER}`;
 }
-function isObj2(x) {
+function isObj3(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
 function isOurs(statusLine) {
-  return isObj2(statusLine) && typeof statusLine.command === "string" && statusLine.command.includes(BRIDGE_MARKER);
+  return isObj3(statusLine) && typeof statusLine.command === "string" && statusLine.command.includes(BRIDGE_MARKER);
 }
 async function readSettings(path) {
   let text;
   try {
-    text = await (0, import_promises12.readFile)(path, "utf8");
+    text = await (0, import_promises13.readFile)(path, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return {};
     throw e;
   }
   const parsed = JSON.parse(text);
-  if (!isObj2(parsed)) throw new Error(`${path} is not a JSON object`);
+  if (!isObj3(parsed)) throw new Error(`${path} is not a JSON object`);
   return parsed;
 }
 async function writeAtomic(path, text) {
   const tmp = `${path}.harlay-tmp`;
-  await (0, import_promises12.writeFile)(tmp, text);
-  await (0, import_promises12.rename)(tmp, path);
+  await (0, import_promises13.writeFile)(tmp, text);
+  await (0, import_promises13.rename)(tmp, path);
 }
 async function bridgeState(home2) {
   try {
@@ -2080,21 +2482,21 @@ async function bridgeState(home2) {
 async function installBridge(home2, dataDir2) {
   const path = claudeSettingsPath(home2);
   const s = await readSettings(path);
-  await (0, import_promises12.mkdir)(dataDir2, { recursive: true });
-  await (0, import_promises12.writeFile)(scriptPath(dataDir2), BRIDGE_SCRIPT);
-  await (0, import_promises12.chmod)(scriptPath(dataDir2), 493);
+  await (0, import_promises13.mkdir)(dataDir2, { recursive: true });
+  await (0, import_promises13.writeFile)(scriptPath(dataDir2), BRIDGE_SCRIPT);
+  await (0, import_promises13.chmod)(scriptPath(dataDir2), 493);
   if (isOurs(s.statusLine)) return;
   const prev = s.statusLine;
   if (prev !== void 0) {
     await writeAtomic(previousJson(dataDir2), JSON.stringify(prev, null, 2) + "\n");
-    const cmd = isObj2(prev) && typeof prev.command === "string" ? prev.command : "";
+    const cmd = isObj3(prev) && typeof prev.command === "string" ? prev.command : "";
     await writeAtomic(previousCommand(dataDir2), cmd);
   } else {
-    await (0, import_promises12.rm)(previousJson(dataDir2), { force: true });
-    await (0, import_promises12.rm)(previousCommand(dataDir2), { force: true });
+    await (0, import_promises13.rm)(previousJson(dataDir2), { force: true });
+    await (0, import_promises13.rm)(previousCommand(dataDir2), { force: true });
   }
-  s.statusLine = { ...isObj2(prev) ? prev : {}, type: "command", command: bridgeCommand(dataDir2) };
-  await (0, import_promises12.mkdir)((0, import_node_path12.join)(home2, ".claude"), { recursive: true });
+  s.statusLine = { ...isObj3(prev) ? prev : {}, type: "command", command: bridgeCommand(dataDir2) };
+  await (0, import_promises13.mkdir)((0, import_node_path14.join)(home2, ".claude"), { recursive: true });
   await writeAtomic(path, JSON.stringify(s, null, 2) + "\n");
 }
 async function removeBridge(home2, dataDir2) {
@@ -2103,25 +2505,435 @@ async function removeBridge(home2, dataDir2) {
   if (!isOurs(s.statusLine)) return;
   let prev;
   try {
-    prev = JSON.parse(await (0, import_promises12.readFile)(previousJson(dataDir2), "utf8"));
+    prev = JSON.parse(await (0, import_promises13.readFile)(previousJson(dataDir2), "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 (0, import_promises12.rm)(previousJson(dataDir2), { force: true });
-  await (0, import_promises12.rm)(previousCommand(dataDir2), { force: true });
+  await (0, import_promises13.rm)(previousJson(dataDir2), { force: true });
+  await (0, import_promises13.rm)(previousCommand(dataDir2), { force: true });
+}
+
+// ../../packages/core/src/health/context.ts
+var import_promises14 = require("node:fs/promises");
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+function parse(line) {
+  try {
+    const v = JSON.parse(line);
+    return isObj(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function scanLine(tool, line, s) {
+  if (tool === "claude-code") {
+    if (line.includes('"compact_boundary"') && parse(line)?.subtype === "compact_boundary") s.boundaries++;
+    else if (line.includes('"isCompactSummary":true')) s.summaries++;
+    else if (line.includes('"type":"assistant"') && line.includes('"usage"')) {
+      const rec = parse(line);
+      if (!rec || rec.type !== "assistant" || rec.isSidechain === true || !isObj(rec.message) || !isObj(rec.message.usage)) return;
+      const u = rec.message.usage;
+      const tokens = num2(u.input_tokens) + num2(u.cache_creation_input_tokens) + num2(u.cache_read_input_tokens);
+      if (tokens > 0) s.info.tokens = tokens;
+    }
+    s.info.compactions = Math.max(s.boundaries, s.summaries);
+  } else if (tool === "codex") {
+    if (line.includes('"type":"compacted"') && parse(line)?.type === "compacted") s.info.compactions++;
+    else if (line.includes('"token_count"')) {
+      const p = parse(line)?.payload;
+      if (!isObj(p) || p.type !== "token_count" || !isObj(p.info)) return;
+      const last = isObj(p.info.last_token_usage) ? num2(p.info.last_token_usage.input_tokens) : 0;
+      if (last > 0) s.info.tokens = last;
+      if (num2(p.info.model_context_window) > 0) s.info.window = num2(p.info.model_context_window);
+    }
+  }
+}
+async function readFrom(file, start, end) {
+  const fh = await (0, import_promises14.open)(file, "r");
+  try {
+    const buf = Buffer.alloc(end - start);
+    const { bytesRead } = await fh.read(buf, 0, buf.length, start);
+    return buf.subarray(0, bytesRead);
+  } finally {
+    await fh.close();
+  }
+}
+var ContextTracker = class {
+  scans = /* @__PURE__ */ new Map();
+  async read(ref) {
+    if (ref.tool === "cursor") return null;
+    let size;
+    try {
+      size = (await (0, import_promises14.stat)(ref.file)).size;
+    } catch {
+      return null;
+    }
+    let s = this.scans.get(ref.file);
+    if (!s || size < s.size) s = { size: 0, rest: Buffer.alloc(0), info: { tokens: null, window: null, compactions: 0 }, boundaries: 0, summaries: 0 };
+    if (size > s.size) {
+      const buf = Buffer.concat([s.rest, await readFrom(ref.file, s.size, size)]);
+      const end = buf.lastIndexOf(10);
+      for (const line of end === -1 ? [] : buf.subarray(0, end).toString("utf8").split("\n")) scanLine(ref.tool, line, s);
+      s.rest = end === -1 ? buf : Buffer.from(buf.subarray(end + 1));
+      s.size = size;
+    }
+    this.scans.set(ref.file, s);
+    return { ...s.info };
+  }
+  forget(file) {
+    this.scans.delete(file);
+  }
+};
+
+// ../../packages/core/src/health/tail.ts
+var import_promises15 = require("node:fs/promises");
+var TAIL_BYTES2 = 15e5;
+async function readSessionTail(ref, maxBytes = TAIL_BYTES2) {
+  const fh = await (0, import_promises15.open)(ref.file, "r");
+  let text;
+  try {
+    const { size } = await fh.stat();
+    const start = Math.max(0, size - maxBytes);
+    const buf = Buffer.alloc(size - start);
+    const { bytesRead } = await fh.read(buf, 0, buf.length, start);
+    let body = buf.subarray(0, bytesRead);
+    if (start > 0) body = body.subarray(body.indexOf(10) + 1);
+    text = body.toString("utf8");
+  } finally {
+    await fh.close();
+  }
+  const { records, invalid } = parseJsonLines(text);
+  if (ref.tool === "claude-code") return normalizeClaude(records, ref, invalid);
+  if (ref.tool === "codex") return normalizeCodex(records, ref, invalid);
+  return normalizeCursor(records, ref, invalid);
+}
+
+// ../../packages/core/src/health/signals.ts
+var import_node_path15 = require("node:path");
+
+// ../../packages/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 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 };
+}
+
+// ../../packages/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
+};
+var LEADING_CD_RE = /^\s*cd\s+(?:"[^"]*"|'[^']*'|[^\s;&]+)\s*(?:&&|;)\s*/;
+var ENV_RE = /^(?:[A-Z_][A-Z0-9_]*=\S*\s+)+/;
+function bare(cmd) {
+  return cmd.replace(LEADING_CD_RE, "").replace(ENV_RE, "").replace(/^sudo\s+/, "").trim();
+}
+function signature(cmd) {
+  return bare(cmd).split(/\s+/).slice(0, 3).join(" ");
+}
+var failed = (r) => r.exitCode !== null && r.exitCode !== 0;
+var norm3 = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+var realRuns = (t) => t.filter((i) => i.kind === "command" && !isProbeCommand(i.run.cmd));
+var clipQuote = (s, max = 40) => s.length > max ? `${s.slice(0, max - 1).trimEnd()}\u2026` : s;
+var PUSHBACK_RE = /\b(still (not|isn'?t|doesn'?t|didn'?t|broken|failing|wrong|the same)|(is|are|it'?s)? ?not working|doesn'?t work|didn'?t (work|fix)|same (error|issue|problem|bug)|that'?s (not|wrong)|you (already|keep|still|broke)|i (said|told you|asked you)|why (did|are|would) you|undo (that|this|it)|revert (that|this|it)|wrong again|not what i (asked|wanted|said|meant)|(it|that|this) broke|nothing (changed|happened|works)|wtf|what the (hell|heck|fuck)|are you (kidding|serious)|come on|seriously|ugh+|nope|bro|brother|dude)\b/i;
+var SHOUT_RE = /(?:\b[A-Z]{3,}\b.*){3,}|[!?]{2,}/;
+function userMessages(t) {
+  return t.filter((i) => i.kind === "user").map((i) => i.text).filter((x) => !isSlashCommand(x) && !isHandoffPrompt(x));
+}
+function pushbackSignals(t) {
+  const msgs = userMessages(t).slice(-SIGNALS.recentUserMessages);
+  let pushback = msgs.filter((m) => PUSHBACK_RE.test(m) || SHOUT_RE.test(m)).length;
+  for (let i = 1; i < msgs.length; i++) if (norm3(msgs[i]).length > 12 && norm3(msgs[i]) === norm3(msgs[i - 1])) pushback++;
+  if (pushback >= 2) return [{ weight: 2, behavior: true, text: `You pushed back ${pushback} times in your last ${msgs.length} messages` }];
+  if (pushback === 1) return [{ weight: 1, behavior: true, text: "You pushed back on a recent answer" }];
+  return [];
+}
+var CLAIM_RE = /\b(fixed|(that|this) (should|will) (fix|work|solve)|should (now )?(work|pass)|works now|now works|it'?s working|(is|are) working now|all (the )?tests pass|tests (now )?pass|(build|tests?) (is|are) (now )?(green|passing)|resolved|all set|problem solved)\b/i;
+function falseFixSignals(t) {
+  const failing = /* @__PURE__ */ new Set();
+  let claim = null;
+  let hits = 0;
+  let example = null;
+  for (const i of t) {
+    if (i.kind === "assistant") {
+      if (CLAIM_RE.test(i.text)) claim = { failing: new Set(failing) };
+    } else if (i.kind === "command" && !isProbeCommand(i.run.cmd)) {
+      const sig = signature(i.run.cmd);
+      if (failed(i.run)) {
+        if (claim?.failing.has(sig)) {
+          hits++;
+          example ??= sig;
+          claim = null;
+        }
+        failing.add(sig);
+      } else {
+        failing.delete(sig);
+        claim?.failing.delete(sig);
+      }
+    } else if (i.kind === "user" && claim) {
+      if (PUSHBACK_RE.test(i.text) || SHOUT_RE.test(i.text)) hits++;
+      claim = null;
+    }
+  }
+  if (!hits) return [];
+  if (hits === 1) return [{ weight: 1, behavior: true, text: example ? `Said it was fixed, but \`${oneLine(example, 40)}\` failed again` : "Said it was fixed, but it wasn\u2019t" }];
+  return [{ weight: 2, behavior: true, text: `Said it was fixed ${hits} times, but it wasn\u2019t` }];
+}
+var APOLOGY_RE = /\b(you'?re (absolutely |completely |totally )?right|i apologi[sz]e|my apologies|sorry about|my mistake|i was wrong)\b/i;
+var SWITCH_RE = /\b(let me try (a different|another|something else)|(a )?different approach|another approach|alternative approach|let me take a step back|let'?s try something else)\b/i;
+function flipFlopSignals(t) {
+  const n = t.filter((i) => i.kind === "assistant").slice(-SIGNALS.recentAgentMessages).filter((i) => APOLOGY_RE.test(i.text) || SWITCH_RE.test(i.text)).length;
+  return n >= 2 ? [{ weight: 1, behavior: true, text: `It apologized or changed course ${n} times recently` }] : [];
+}
+function repeatFailureSignals(t) {
+  const streak = /* @__PURE__ */ new Map();
+  for (const { run } of realRuns(t).slice(-SIGNALS.recentCommands)) {
+    const key = signature(run.cmd);
+    streak.set(key, failed(run) ? (streak.get(key) ?? 0) + 1 : 0);
+  }
+  const [worst, times] = [...streak].reduce((best, cur) => cur[1] > best[1] ? cur : best, ["", 0]);
+  return times >= SIGNALS.repeatFailures ? [{ weight: 2, behavior: true, text: `\`${oneLine(worst, 40)}\` failed ${times} times in a row` }] : [];
+}
+function noProgressSignals(t) {
+  const everFailed = /* @__PURE__ */ new Set();
+  let since = { steps: 0, failures: 0, failing: /* @__PURE__ */ new Set() };
+  for (const i of t) {
+    if (i.kind === "edit") since.steps++;
+    if (i.kind !== "command" || isProbeCommand(i.run.cmd)) continue;
+    since.steps++;
+    const sig = signature(i.run.cmd);
+    if (failed(i.run)) {
+      everFailed.add(sig);
+      since.failures++;
+      since.failing.add(sig);
+    } else if (i.run.exitCode === 0 && (everFailed.has(sig) || /^git commit\b/.test(bare(i.run.cmd)))) {
+      since = { steps: 0, failures: 0, failing: /* @__PURE__ */ new Set() };
+    }
+  }
+  if (since.steps < SIGNALS.stuckSteps || since.failures < SIGNALS.stuckFailures || since.failing.size < 2) return [];
+  return [{ weight: since.failures >= 2 * SIGNALS.stuckFailures ? 2 : 1, behavior: true, text: `No progress in its last ${since.steps} steps (${since.failures} failures)` }];
+}
+var DISCARD_FILES_RE = /^git\s+(?:checkout\s+(?:\S+\s+)?--|restore)\s+(.+)$/;
+var DISCARD_ALL_RE = /^git\s+(?:reset\s+--hard|stash(?:\s+(?:push|save))?\s*$)/;
+function discardsOwnWork(cmd, edited) {
+  const c = bare(cmd).split("\n")[0].split(/\s*(?:;|&&|\|\|)\s*/)[0];
+  if (DISCARD_ALL_RE.test(c)) return edited.length > 0;
+  const m = DISCARD_FILES_RE.exec(c);
+  if (!m) return false;
+  const files = m[1].split(/\s+/).filter((x) => x && !x.startsWith("-") && x !== ".");
+  return files.some((f) => edited.some((p) => p === f || p.endsWith(`/${f.replace(/^\.\//, "")}`)));
+}
+function undoSignals(t) {
+  const earlier = [];
+  const edited = [];
+  let undone = 0;
+  for (const i of t) {
+    if (i.kind === "command" && i.run.exitCode !== null && !failed(i.run) && discardsOwnWork(i.run.cmd, edited)) undone++;
+    if (i.kind === "edit") edited.push(i.edit.path);
+    if (i.kind !== "edit" || i.edit.before === void 0 || i.edit.after === void 0) continue;
+    const e = i.edit;
+    const swap = earlier.some((p) => p.path === e.path && norm3(p.after ?? "") === norm3(e.before ?? "") && norm3(p.before ?? "") === norm3(e.after ?? "") && norm3(e.before ?? "") !== norm3(e.after ?? ""));
+    if (swap) undone++;
+    earlier.push(e);
+  }
+  if (undone >= 2) return [{ weight: 2, behavior: true, text: `Undid its own changes ${undone} times` }];
+  return undone === 1 ? [{ weight: 1, behavior: true, text: "Undid one of its own changes" }] : [];
+}
+function rereadSignals(t, cwd = null) {
+  const reads = /* @__PURE__ */ new Map();
+  const lookups = /* @__PURE__ */ new Map();
+  const shown = /* @__PURE__ */ new Map();
+  for (const i of t) {
+    if (i.kind === "read" && !i.how) {
+      if (!cwd || i.path.startsWith(cwd.endsWith("/") ? cwd : `${cwd}/`)) reads.set(i.path, (reads.get(i.path) ?? 0) + 1);
+    } else if (i.kind === "edit") reads.delete(i.edit.path);
+    else if (i.kind === "command" && isProbeCommand(i.run.cmd)) {
+      const key = norm3(bare(i.run.cmd));
+      lookups.set(key, (lookups.get(key) ?? 0) + 1);
+      if (!shown.has(key)) shown.set(key, bare(i.run.cmd));
+    }
+  }
+  const [path, n] = [...reads].reduce((best, cur) => cur[1] > best[1] ? cur : best, ["", 0]);
+  if (n >= SIGNALS.rereads) return [{ weight: 1, behavior: true, text: `Re-read ${(0, import_node_path15.basename)(path)} ${n} times without changing it` }];
+  const [cmd, m] = [...lookups].reduce((best, cur) => cur[1] > best[1] ? cur : best, ["", 0]);
+  return m >= SIGNALS.rereads ? [{ weight: 1, behavior: true, text: `Ran \`${oneLine(shown.get(cmd) ?? cmd, 40)}\` ${m} times` }] : [];
+}
+function churnSignals(t) {
+  if (!t.some((i) => i.kind === "command" && failed(i.run))) return [];
+  const edits = /* @__PURE__ */ new Map();
+  for (const i of t) if (i.kind === "edit") edits.set(i.edit.path, (edits.get(i.edit.path) ?? 0) + 1);
+  const [path, n] = [...edits].reduce((best, cur) => cur[1] > best[1] ? cur : best, ["", 0]);
+  return n >= SIGNALS.churnEdits ? [{ weight: 1, behavior: true, text: `Edited ${(0, import_node_path15.basename)(path)} ${n} times while things kept failing` }] : [];
+}
+var NEGATIVE_RE = /\b(never|don'?t|do not|avoid|stop|no)\b/i;
+var JS_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var PY_MANAGERS = ["pip", "pip3", "uv", "poetry"];
+var PATH_RE = /`([^`]+)`|((?:[\w.-]+\/)+[\w.-]+|\.env\b|\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|json|md|py|go|rs|yml|yaml|toml|lock|css|html|sh|sql|env))/g;
+function managerOf(cmd) {
+  const first = bare(cmd).split(/\s+/)[0] ?? "";
+  const m = first === "npx" ? "npm" : first === "python" && /-m pip\b/.test(cmd) ? "pip" : first;
+  return [...JS_MANAGERS, ...PY_MANAGERS].includes(m) ? m : null;
+}
+function ruleCheck(rule) {
+  const r = rule.toLowerCase();
+  const negative = NEGATIVE_RE.test(r);
+  const ran = (i) => i.kind === "command" ? `ran \`${oneLine(bare(i.run.cmd), 30)}\`` : null;
+  const named = [...JS_MANAGERS, ...PY_MANAGERS].filter((m) => new RegExp(`\\b${m}\\b`).test(r));
+  if (named.length === 1) {
+    const m = named[0];
+    const family = JS_MANAGERS.includes(m) ? JS_MANAGERS : PY_MANAGERS;
+    const banned = negative ? [m] : /\b(use|only|always|prefer|stick (to|with)|switch to)\b/.test(r) ? family.filter((x) => x !== m) : [];
+    if (banned.length) return (i) => i.kind === "command" && banned.includes(managerOf(i.run.cmd) ?? "") ? ran(i) : null;
+  }
+  if (!negative) return null;
+  if (/force[- ]?push|push\s+(--force|-f\b)/.test(r)) return (i) => i.kind === "command" && /^git\s+push\b.*(\s-f\b|--force)/.test(bare(i.run.cmd)) ? ran(i) : null;
+  if (/\bpush\b/.test(r)) {
+    const toMain = /\b(main|master)\b/.test(r);
+    return (i) => {
+      if (i.kind !== "command") return null;
+      const c = bare(i.run.cmd);
+      if (!/^git\s+push\b/.test(c)) return null;
+      return !toMain || /\b(main|master)\b/.test(c) || /^git\s+push(\s+-\S+)*(\s+origin)?\s*$/.test(c) ? ran(i) : null;
+    };
+  }
+  if (/\bcommit\b/.test(r)) return (i) => i.kind === "command" && /^git\s+commit\b/.test(bare(i.run.cmd)) ? ran(i) : null;
+  const targets = [...rule.matchAll(PATH_RE)].map((m) => (m[1] ?? m[2]).trim()).filter((x) => x.length > 1);
+  if (/\b(edit|touch|modify|change|delete|remove|rename|overwrite)\b/.test(r) && targets.some((x) => /[./]/.test(x))) {
+    const files = targets.filter((x) => /[./]/.test(x));
+    return (i) => i.kind === "edit" && files.some((f) => i.edit.path.endsWith(f) || i.edit.path.includes(`/${f}`)) ? `edited ${(0, import_node_path15.basename)(i.edit.path)}` : null;
+  }
+  const quoted = [...rule.matchAll(/`([^`]+)`/g)].map((m) => m[1].trim());
+  if (quoted.length && /\b(run|use|call|execute)\b/.test(r)) return (i) => i.kind === "command" && quoted.some((q) => bare(i.run.cmd).startsWith(q)) ? ran(i) : null;
+  return null;
+}
+function ruleSignals(t) {
+  const users = t.map((i, at) => ({ i, at })).filter((x) => x.i.kind === "user");
+  const { rules } = findPinnedRules(users.map((u) => u.i.text), []);
+  const broken = [];
+  for (const rule of rules) {
+    const check = ruleCheck(rule.text);
+    const from = users[rule.message]?.at;
+    if (!check || from === void 0) continue;
+    for (const i of t.slice(from + 1)) {
+      const how = check(i);
+      if (how) {
+        broken.push({ rule: rule.text, how });
+        break;
+      }
+    }
+  }
+  if (!broken.length) return [];
+  const first = broken[0];
+  const text = broken.length === 1 ? `Broke your rule \u201C${clipQuote(first.rule)}\u201D (${first.how})` : `Broke ${broken.length} of your rules, like \u201C${clipQuote(first.rule)}\u201D`;
+  return [{ weight: 2, behavior: true, text }];
+}
+function formatTokens(n) {
+  return n >= 1e6 ? `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M` : `${Math.round(n / 1e3)}K`;
+}
+function contextSignals(c) {
+  if (!c) return [];
+  const out = [];
+  if (c.tokens !== null && c.tokens >= SIGNALS.longTokens) {
+    const pct = c.window ? ` (${Math.round(c.tokens / c.window * 100)}% of its window)` : "";
+    const very = c.tokens >= SIGNALS.veryLongTokens;
+    out.push({ weight: very ? 2 : 1, behavior: false, text: `Long context: ${formatTokens(c.tokens)} tokens${pct}` });
+  }
+  if (c.compactions >= 2) out.push({ weight: 2, behavior: false, text: `Compacted ${c.compactions} times, so early details are summaries` });
+  else if (c.compactions === 1) out.push({ weight: 1, behavior: false, text: "Compacted once" });
+  return out;
+}
+function allSignals(timeline, context, cwd = null) {
+  const t = timeline.slice(-SIGNALS.recentItems);
+  return [
+    ...falseFixSignals(t),
+    ...ruleSignals(t),
+    ...repeatFailureSignals(t),
+    ...undoSignals(t),
+    ...pushbackSignals(t),
+    ...noProgressSignals(t),
+    ...rereadSignals(t, cwd),
+    ...flipFlopSignals(t),
+    ...churnSignals(t),
+    ...contextSignals(context)
+  ];
+}
+
+// ../../packages/core/src/health/assess.ts
+var HEALTH = {
+  ...SIGNALS,
+  maxReasons: 3
+};
+function assessHealth(s, context) {
+  const signals = allSignals(s.timeline, context, s.ref.cwd);
+  const points = signals.reduce((sum, x) => sum + x.weight, 0);
+  const circling = signals.filter((x) => x.behavior).reduce((sum, x) => sum + x.weight, 0);
+  const state2 = points >= 3 && circling >= 2 ? "struggling" : points >= 1 ? "long" : "fresh";
+  const reasons = [...signals].sort((a, b) => b.weight - a.weight || Number(b.behavior) - Number(a.behavior)).slice(0, HEALTH.maxReasons).map((x) => x.text);
+  return { state: state2, reasons, context };
 }
 
 // src/menu.ts
-var import_node_path14 = require("node:path");
+var import_node_path17 = require("node:path");
 
 // src/settings.ts
-var import_promises13 = require("node:fs/promises");
-var import_node_path13 = require("node:path");
+var import_promises16 = require("node:fs/promises");
+var import_node_path16 = require("node:path");
 var THEMES = ["system", "light", "dark"];
 var isTheme = (x) => THEMES.includes(x);
+var MAX_PINNED = 12;
+function isPinnedKey(x) {
+  if (typeof x !== "string") return false;
+  const i = x.indexOf(":");
+  return i > 0 && i < x.length - 1 && isTool(x.slice(0, i));
+}
 var DEFAULT_SETTINGS = {
   defaultTarget: "codex",
   autoContinue: false,
@@ -2130,17 +2942,19 @@ var DEFAULT_SETTINGS = {
   terminalApp: "Terminal",
   openAtLogin: true,
   theme: "system",
-  claudeBridgeAsked: false
+  claudeBridgeAsked: false,
+  pinned: []
 };
 async function loadSettings(file) {
   let raw = {};
   try {
-    raw = JSON.parse(await (0, import_promises13.readFile)(file, "utf8"));
+    raw = JSON.parse(await (0, import_promises16.readFile)(file, "utf8"));
   } catch {
     raw = {};
   }
   const r = typeof raw === "object" && raw !== null ? raw : {};
-  const s = { ...DEFAULT_SETTINGS, modes: { ...DEFAULT_SETTINGS.modes } };
+  const s = { ...DEFAULT_SETTINGS, modes: { ...DEFAULT_SETTINGS.modes }, pinned: [] };
+  if (Array.isArray(r.pinned)) s.pinned = [...new Set(r.pinned.filter(isPinnedKey))].slice(0, MAX_PINNED);
   if (isTool(r.defaultTarget)) s.defaultTarget = r.defaultTarget;
   if (typeof r.autoContinue === "boolean") s.autoContinue = r.autoContinue;
   if (typeof r.openAtLogin === "boolean") s.openAtLogin = r.openAtLogin;
@@ -2157,12 +2971,23 @@ async function loadSettings(file) {
   return s;
 }
 async function saveSettings(file, s) {
-  await (0, import_promises13.mkdir)((0, import_node_path13.dirname)(file), { recursive: true });
-  await (0, import_promises13.writeFile)(file, JSON.stringify(s, null, 2) + "\n");
+  await (0, import_promises16.mkdir)((0, import_node_path16.dirname)(file), { recursive: true });
+  await (0, import_promises16.writeFile)(file, JSON.stringify(s, null, 2) + "\n");
 }
 
 // src/state.ts
-var import_promises14 = require("node:fs/promises");
+var MISSED_MS = 3 * 6e4;
+var DELIVERY_WATCH_MS = 30 * 6e4;
+var DELIVERY_TEXT = {
+  waiting: (a, mode) => mode === "app" ? `press Enter in ${a} to send it` : `waiting for ${a} to start`,
+  sent: (a) => `${a} has the prompt`,
+  read: (a) => `${a} read it`,
+  missed: (a) => `${a} hasn't picked it up`
+};
+function deliveryDetail(d) {
+  const agent = TOOL_LABEL[d.target];
+  return `Handed off to ${agent} \xB7 ${DELIVERY_TEXT[d.state](agent, d.mode)}`;
+}
 var DEFAULT_LIMIT_MS = 60 * 6e4;
 var sessionKey = (ref) => `${ref.tool}:${ref.id}`;
 function createState() {
@@ -2173,7 +2998,7 @@ function seedSessions(state2, refs) {
     const k = sessionKey(ref);
     const t = state2.sessions.get(k);
     if (!t) {
-      state2.sessions.set(k, { ref, status: "idle", detail: "Idle", updatedAt: ref.lastActivityAt, briefPath: null });
+      state2.sessions.set(k, { ref, status: "idle", detail: "Idle", updatedAt: ref.lastActivityAt });
       continue;
     }
     if (t.status !== "idle" && ref.lastActivityAt.getTime() > t.updatedAt.getTime() + 6e4) {
@@ -2189,7 +3014,7 @@ function clock(d) {
 }
 function applyWatchEvent(state2, ev, now) {
   const k = sessionKey(ev.ref);
-  const t = state2.sessions.get(k) ?? { ref: ev.ref, status: "idle", detail: "Idle", updatedAt: now, briefPath: null };
+  const t = state2.sessions.get(k) ?? { ref: ev.ref, status: "idle", detail: "Idle", updatedAt: now };
   t.ref = ev.ref;
   t.updatedAt = now;
   if (ev.event.kind === "halt") {
@@ -2204,17 +3029,41 @@ function applyWatchEvent(state2, ev, now) {
   state2.sessions.set(k, t);
   return t;
 }
-function markHandedOff(state2, key, target, now) {
+function markHandedOff(state2, key, target, now, delivery) {
   const t = state2.sessions.get(key);
   if (!t) return null;
   t.status = "handed_off";
-  t.detail = `Handed off to ${TOOL_LABEL[target]}`;
   t.updatedAt = now;
+  t.delivery = delivery ? { ...delivery, target, sentAt: now, state: "waiting" } : void 0;
+  t.detail = t.delivery ? deliveryDetail(t.delivery) : `Handed off to ${TOOL_LABEL[target]}`;
   return t;
 }
+function pendingDeliveries(state2, now) {
+  return [...state2.sessions.values()].filter(
+    (t) => t.status === "handed_off" && t.delivery && t.delivery.state !== "read" && now.getTime() - t.delivery.since.getTime() < DELIVERY_WATCH_MS
+  );
+}
+function applyDelivery(t, got, now) {
+  const d = t.delivery;
+  if (!d) return { changed: false, becameMissed: false };
+  const before = d.state;
+  if (got) d.state = got.state;
+  else if (d.state !== "sent" && now.getTime() - d.sentAt.getTime() >= MISSED_MS) d.state = "missed";
+  t.detail = deliveryDetail(d);
+  return { changed: d.state !== before, becameMissed: d.state === "missed" && before !== "missed" };
+}
+function markResent(t, now) {
+  if (!t.delivery) return;
+  t.delivery.sentAt = now;
+  t.delivery.state = "waiting";
+  t.detail = deliveryDetail(t.delivery);
+}
 var RANK = { limit: 0, warning: 1, idle: 2, handed_off: 2 };
+function byAttention(a, b) {
+  return RANK[a.status] - RANK[b.status] || b.updatedAt.getTime() - a.updatedAt.getTime();
+}
 function recentSessions(state2, limit = 8) {
-  return [...state2.sessions.values()].sort((a, b) => RANK[a.status] - RANK[b.status] || b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, limit);
+  return [...state2.sessions.values()].sort(byAttention).slice(0, limit);
 }
 function latestSession(state2) {
   let best = null;
@@ -2224,15 +3073,6 @@ function latestSession(state2) {
   }
   return best;
 }
-async function existingBrief(t) {
-  if (!t?.briefPath) return null;
-  try {
-    await (0, import_promises14.access)(t.briefPath);
-    return t.briefPath;
-  } catch {
-    return null;
-  }
-}
 
 // src/menu.ts
 var HOTKEY = { accelerator: "Alt+H", label: "\u2325H" };
@@ -2240,7 +3080,7 @@ var DOT = { limit: "\u25CF", warning: "\u25D0", idle: "\u25CB", handed_off: "\u2
 var MODES = ["app", "terminal"];
 var THEME_LABEL = { system: "System", light: "Light", dark: "Dark" };
 function sessionTitle(t) {
-  return t.ref.title ?? (t.ref.cwd ? (0, import_node_path14.basename)(t.ref.cwd) : t.ref.id.slice(0, 8));
+  return t.ref.title ?? (t.ref.cwd ? (0, import_node_path17.basename)(t.ref.cwd) : t.ref.id.slice(0, 8));
 }
 function buildMenuModel(sessions, settings2, available2) {
   const nodes = [
@@ -2257,9 +3097,7 @@ function buildMenuModel(sessions, settings2, available2) {
         { type: "separator" },
         ...TOOLS.filter((x) => x !== t.ref.tool).map(
           (x) => ({ label: `Hand off to ${TOOL_LABEL[x]}`, enabled: available2[x][settings2.modes[x]], action: { type: "handoff", key, target: x } })
-        ),
-        { type: "separator" },
-        { label: "Preview brief", action: { type: "previewBrief", key } }
+        )
       ]
     });
   }
@@ -2293,30 +3131,51 @@ function buildMenuModel(sessions, settings2, available2) {
     { label: "Auto-continue when an agent stops", type: "checkbox", checked: settings2.autoContinue, action: { type: "toggleAuto" } },
     { label: "Open at login", type: "checkbox", checked: settings2.openAtLogin, action: { type: "toggleLogin" } },
     { type: "separator" },
-    { label: `Hotkey ${HOTKEY.label} hands off the latest session`, enabled: false },
+    { label: `Hotkey ${HOTKEY.label} routes your latest chat`, enabled: false },
     { label: "Quit Harlay", action: { type: "quit" } }
   );
   return nodes;
 }
 
-// src/notifications.ts
-var import_node_path15 = require("node:path");
-function haltNotificationBody(t, first) {
-  const what = t.ref.cwd ? `${t.detail} \xB7 ${(0, import_node_path15.basename)(t.ref.cwd)}` : t.detail;
-  return first ? `${what}. Click to continue in ${TOOL_LABEL[first]}.` : `${what}. No other agent is available.`;
-}
+// src/health.ts
+var import_promises17 = require("node:fs/promises");
+var HealthMonitor = class {
+  context = new ContextTracker();
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.cache.get(key)?.health ?? null;
+  }
+  /** Reads the given chats (one at a time, to stay light) and returns those whose state changed. */
+  async update(refs) {
+    const changes = [];
+    for (const ref of refs) {
+      const key = sessionKey(ref);
+      try {
+        const st = await (0, import_promises17.stat)(ref.file);
+        const cached = this.cache.get(key);
+        if (cached && cached.size === st.size && cached.mtimeMs === st.mtimeMs) continue;
+        const health2 = assessHealth(await readSessionTail(ref), await this.context.read(ref));
+        this.cache.set(key, { size: st.size, mtimeMs: st.mtimeMs, health: health2 });
+        if (cached?.health.state !== health2.state) changes.push({ ref, before: cached?.health.state ?? null, after: health2 });
+      } catch {
+        this.cache.delete(key);
+      }
+    }
+    return changes;
+  }
+};
 
 // src/popover.ts
-var import_node_path16 = require("node:path");
 var POPOVER_WIDTH = 392;
+var PER_AGENT = 3;
 function timeAgo(d, now) {
   const s = Math.max(0, Math.floor((now.getTime() - d.getTime()) / 1e3));
   if (s < 60) return "now";
   const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m ago`;
+  if (m < 60) return `${m}m`;
   const h = Math.floor(m / 60);
-  if (h < 24) return `${h}h ago`;
-  return `${Math.floor(h / 24)}d ago`;
+  if (h < 24) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
 }
 function resetsText(d, now) {
   if (!d) return null;
@@ -2355,28 +3214,47 @@ function buildUsageRows(snapshots, available2, bridge, now) {
   }
   return rows;
 }
-function buildPopoverModel(sessions, settings2, available2, busy, now, usage2 = [], claudeBridge2 = "off", askClaudeBridge = false) {
+function shownByAgent(sessions, settings2) {
+  const pinned = new Set(settings2.pinned);
+  const out = {};
+  for (const tool of TOOLS) {
+    const mine = sessions.filter((t) => t.ref.tool === tool).sort(byAttention);
+    out[tool] = [...mine.slice(0, PER_AGENT), ...mine.slice(PER_AGENT).filter((t) => pinned.has(sessionKey(t.ref)))];
+  }
+  return out;
+}
+function buildPopoverModel(sessions, settings2, available2, busy, now, usage2 = [], claudeBridge2 = "off", askClaudeBridge = false, icons = {}, health2 = () => null) {
+  const pinned = new Set(settings2.pinned);
   const order = [settings2.defaultTarget, ...TOOLS.filter((t) => t !== settings2.defaultTarget)];
+  const toSession = (t) => {
+    const key = sessionKey(t.ref);
+    return {
+      key,
+      title: sessionTitle(t),
+      status: t.status,
+      detail: t.detail,
+      cwd: t.ref.cwd ?? null,
+      ago: timeAgo(t.updatedAt, now),
+      busy: busy.has(key),
+      pinned: pinned.has(key),
+      targets: order.filter((x) => x !== t.ref.tool && available2[x][settings2.modes[x]]).map((x) => ({ tool: x, label: TOOL_LABEL[x], mode: settings2.modes[x] })),
+      health: health2(key),
+      canStartFresh: available2[t.ref.tool][settings2.modes[t.ref.tool]],
+      delivery: t.status === "handed_off" ? t.delivery?.state ?? null : null
+    };
+  };
+  const shown = shownByAgent(sessions, settings2);
+  const groups = [];
+  for (const tool of TOOLS) {
+    if (!shown[tool].length && !available2[tool].app && !available2[tool].terminal) continue;
+    groups.push({ tool, label: TOOL_LABEL[tool], sessions: shown[tool].map(toSession) });
+  }
   return {
-    sessions: sessions.map((t) => {
-      const key = sessionKey(t.ref);
-      return {
-        key,
-        title: sessionTitle(t),
-        toolLabel: TOOL_LABEL[t.ref.tool],
-        status: t.status,
-        detail: t.detail,
-        cwd: t.ref.cwd ?? null,
-        repo: t.ref.cwd ? (0, import_node_path16.basename)(t.ref.cwd) : null,
-        ago: timeAgo(t.updatedAt, now),
-        busy: busy.has(key),
-        targets: order.filter((x) => x !== t.ref.tool).map((x) => ({ tool: x, label: TOOL_LABEL[x], enabled: available2[x][settings2.modes[x]], isDefault: x === settings2.defaultTarget }))
-      };
-    }),
+    groups,
     usage: usage2,
+    icons,
     askClaudeBridge,
-    settings: { defaultTarget: settings2.defaultTarget, autoContinue: settings2.autoContinue, openAtLogin: settings2.openAtLogin, theme: settings2.theme, claudeBridge: claudeBridge2 },
-    tools: TOOLS.map((x) => ({ tool: x, label: TOOL_LABEL[x], mode: settings2.modes[x], ...available2[x] })),
+    settings: { autoContinue: settings2.autoContinue, openAtLogin: settings2.openAtLogin, theme: settings2.theme, claudeBridge: claudeBridge2 },
     hotkey: HOTKEY.label
   };
 }
@@ -2386,9 +3264,10 @@ function isMenuAction(x) {
   switch (a.type) {
     case "handoff":
       return typeof a.key === "string" && isTool(a.target);
-    case "previewBrief":
-    case "copyBrief":
-    case "openBrief":
+    case "unpinChat":
+    case "freshStart":
+    case "resendHandoff":
+    case "copyPrompt":
       return typeof a.key === "string";
     case "setTheme":
       return isTheme(a.theme);
@@ -2396,10 +3275,10 @@ function isMenuAction(x) {
       return isTool(a.target);
     case "setMode":
       return isTool(a.target) && (a.mode === "app" || a.mode === "terminal");
-    case "toggleAuto":
-    case "toggleLogin":
     case "answerClaudeBridge":
       return typeof a.allow === "boolean";
+    case "toggleAuto":
+    case "toggleLogin":
     case "toggleClaudeBridge":
     case "openCursorUsage":
     case "quit":
@@ -2408,6 +3287,12 @@ function isMenuAction(x) {
       return false;
   }
 }
+function panelPosition(icon, iconArea, userArea, width) {
+  const same = iconArea.x === userArea.x && iconArea.y === userArea.y && iconArea.width === userArea.width && iconArea.height === userArea.height;
+  if (!same) return { x: userArea.x + userArea.width - width - 8, y: userArea.y };
+  const x = Math.min(Math.max(icon.x + icon.width / 2 - width / 2, userArea.x), userArea.x + userArea.width - width);
+  return { x, y: icon.y + icon.height };
+}
 
 // src/targets.ts
 function pickTargets(source, defaultTarget, available2, modes, limitedUntil = {}, now = /* @__PURE__ */ new Date()) {
@@ -2417,9 +3302,9 @@ function pickTargets(source, defaultTarget, available2, modes, limitedUntil = {}
 
 // src/usage.ts
 var import_node_events2 = require("node:events");
-var import_node_fs3 = require("node:fs");
-var import_promises15 = require("node:fs/promises");
-var import_node_path17 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_promises18 = require("node:fs/promises");
+var import_node_path18 = require("node:path");
 var CODEX_STALE_MS = 30 * 6e4;
 var CODEX_QUERY_GAP_MS = 30 * 6e4;
 var DEBOUNCE_MS = 2e3;
@@ -2450,22 +3335,22 @@ var UsageMonitor = class extends import_node_events2.EventEmitter {
     return claudeStatusFile(this.opts.dataDir);
   }
   get samplesFile() {
-    return (0, import_node_path17.join)(this.opts.dataDir, "usage-calibration.json");
+    return (0, import_node_path18.join)(this.opts.dataDir, "usage-calibration.json");
   }
   current() {
     return this.snapshots;
   }
   async start() {
-    await (0, import_promises15.mkdir)(this.opts.dataDir, { recursive: true });
+    await (0, import_promises18.mkdir)(this.opts.dataDir, { recursive: true });
     try {
-      const raw = JSON.parse(await (0, import_promises15.readFile)(this.samplesFile, "utf8"));
+      const raw = JSON.parse(await (0, import_promises18.readFile)(this.samplesFile, "utf8"));
       if (Array.isArray(raw)) this.samples = raw.filter((s) => typeof s?.capacity === "number" && typeof s?.at === "number" && typeof s?.kind === "string");
     } catch {
       this.samples = [];
     }
     const watchDir = (dir, tool, recursive) => {
       try {
-        const w = (0, import_node_fs3.watch)(dir, { recursive }, (_e, name) => {
+        const w = (0, import_node_fs4.watch)(dir, { recursive }, (_e, name) => {
           if (!name || String(name).endsWith(".jsonl") || String(name).startsWith("claude-status")) this.schedule(tool);
         });
         w.on("error", () => void 0);
@@ -2473,8 +3358,8 @@ var UsageMonitor = class extends import_node_events2.EventEmitter {
       } catch {
       }
     };
-    watchDir((0, import_node_path17.join)(this.opts.home, ".codex", "sessions"), "codex", true);
-    watchDir((0, import_node_path17.join)(this.opts.home, ".claude", "projects"), "claude-code", true);
+    watchDir((0, import_node_path18.join)(this.opts.home, ".codex", "sessions"), "codex", true);
+    watchDir((0, import_node_path18.join)(this.opts.home, ".claude", "projects"), "claude-code", true);
     watchDir(this.opts.dataDir, "claude-code", false);
     await Promise.all([this.update("codex"), this.update("claude-code")]);
     void this.topUpCodex();
@@ -2531,8 +3416,8 @@ var UsageMonitor = class extends import_node_events2.EventEmitter {
     await this.claudeLog.refresh(now);
     let exact = null;
     try {
-      const s = await (0, import_promises15.stat)(this.statusFile);
-      exact = parseClaudeStatusline(JSON.parse(await (0, import_promises15.readFile)(this.statusFile, "utf8")), s.mtimeMs);
+      const s = await (0, import_promises18.stat)(this.statusFile);
+      exact = parseClaudeStatusline(JSON.parse(await (0, import_promises18.readFile)(this.statusFile, "utf8")), s.mtimeMs);
     } catch {
       exact = null;
     }
@@ -2541,7 +3426,7 @@ var UsageMonitor = class extends import_node_events2.EventEmitter {
     const merged = mergeSamples(this.samples, capacitySamples(entries, hits, exact), now);
     if (JSON.stringify(merged) !== JSON.stringify(this.samples)) {
       this.samples = merged;
-      await (0, import_promises15.writeFile)(this.samplesFile, JSON.stringify(merged)).catch(() => void 0);
+      await (0, import_promises18.writeFile)(this.samplesFile, JSON.stringify(merged)).catch(() => void 0);
     }
     return claudeSnapshot({ entries, hits, exact, samples: this.samples, now });
   }
@@ -2575,7 +3460,7 @@ var UsageMonitor = class extends import_node_events2.EventEmitter {
 // src/main.ts
 var MAX_LIVE_NOTIFICATIONS = 50;
 var AUTO_HANDOFF_COOLDOWN_MS = 2 * 6e4;
-var home = process.env.HARLAY_HOME ?? (0, import_node_os2.homedir)();
+var home = process.env.HARLAY_HOME ?? (0, import_node_os3.homedir)();
 var readers = createReaders({ home });
 var state = createState();
 var liveNotifications = /* @__PURE__ */ new Set();
@@ -2590,7 +3475,8 @@ var watcher = null;
 var usage = null;
 var claudeBridge = "off";
 var lastAutoHandoffAt = 0;
-var previewedBriefs = /* @__PURE__ */ new Map();
+var agentIcons = {};
+var health = new HealthMonitor();
 var errorMessage = (e) => e instanceof Error ? e.message : String(e);
 function toElectron(nodes) {
   return nodes.map((n) => {
@@ -2612,7 +3498,8 @@ function refreshUi() {
   const rows = buildUsageRows(usage?.current() ?? {}, available, claudeBridge, now);
   const claudeInstalled = available["claude-code"].app || available["claude-code"].terminal;
   const ask = !settings.claudeBridgeAsked && claudeBridge === "off" && claudeInstalled;
-  popover.webContents.send("harlay:model", buildPopoverModel(recentSessions(state, 8), settings, available, handoffsInFlight, now, rows, claudeBridge, ask));
+  const model = buildPopoverModel([...state.sessions.values()], settings, available, handoffsInFlight, now, rows, claudeBridge, ask, agentIcons, (k) => health.get(k));
+  popover.webContents.send("harlay:model", model);
 }
 function nativeMenu() {
   return import_electron.Menu.buildFromTemplate(toElectron(buildMenuModel(recentSessions(state, 8), settings, available)));
@@ -2639,52 +3526,65 @@ async function handoff(ref, target) {
   if (handoffsInFlight.has(key)) return;
   handoffsInFlight.add(key);
   refreshUi();
+  const since = /* @__PURE__ */ new Date();
   try {
     const res = await runHandoff({
       session: ref,
       target,
       mode: settings.modes[target],
       readers,
+      store: handoffStore(home),
       terminalApp: settings.terminalApp,
       resolve: defaultResolveOptions()
     });
-    const tracked = markHandedOff(state, key, target, /* @__PURE__ */ new Date());
-    if (tracked) tracked.briefPath = res.written.latestPath;
-    notify(`Continuing in ${TOOL_LABEL[target]}`, `Brief written to ${res.written.latestPath}`);
+    const mode = settings.modes[target];
+    const { id, path, prompt } = res.written;
+    markHandedOff(state, key, target, /* @__PURE__ */ new Date(), { id, path, prompt, mode, cwd: res.data.workdir, since });
+    closeResolvedAlert();
+    notify(`Continuing in ${TOOL_LABEL[target]}`, mode === "app" ? "The prompt is typed in: press Enter there to send it." : "It picks up where this chat left off.");
   } catch (e) {
-    const tracked = state.sessions.get(key);
-    if (e instanceof LaunchError && tracked) tracked.briefPath = e.written.latestPath;
     notify("Harlay could not hand off", errorMessage(e));
   } finally {
     handoffsInFlight.delete(key);
   }
   refreshUi();
 }
-async function previewBrief(ref) {
-  const key = sessionKey(ref);
-  const tracked = state.sessions.get(key);
-  const title = tracked ? sessionTitle(tracked) : ref.id;
-  const send = (brief) => {
-    if (popover && !popover.isDestroyed()) popover.webContents.send("harlay:brief", { key, title, ...brief });
-  };
-  if (!popover?.isVisible()) revealPopover();
-  send({ loading: true });
+var DELIVERY_CHECK_MS = 3e3;
+var checkingDeliveries = false;
+async function checkDeliveries() {
+  if (checkingDeliveries) return;
+  checkingDeliveries = true;
   try {
-    let path = await existingBrief(tracked);
-    if (!path) {
-      const target = settings.defaultTarget;
-      const res = await runHandoff({ session: ref, target, mode: settings.modes[target], readers, launch: false });
-      path = res.written.latestPath;
-    }
-    previewedBriefs.set(key, path);
-    send({ path, text: await (0, import_promises16.readFile)(path, "utf8") });
-  } catch (e) {
-    send({ error: errorMessage(e) });
+    for (const t of pendingDeliveries(state, /* @__PURE__ */ new Date())) {
+      const d = t.delivery;
+      const got = await checkDelivery(readers, { id: d.id, path: d.path, target: d.target, since: d.since }).catch(() => null);
+      const { changed, becameMissed } = applyDelivery(t, got, /* @__PURE__ */ new Date());
+      if (changed) refreshUi();
+      if (becameMissed) {
+        const n = new import_electron.Notification({
+          title: `${TOOL_LABEL[d.target]} hasn't picked up the handoff`,
+          body: d.mode === "app" ? `Press Enter where the prompt is typed in ${TOOL_LABEL[d.target]}, or open Harlay to send it again.` : "Open Harlay to send it again."
+        });
+        keep(n);
+        n.on("click", () => revealPopover());
+        n.show();
+      }
+    }
+  } finally {
+    checkingDeliveries = false;
   }
 }
-async function copyBrief(key) {
-  const path = previewedBriefs.get(key);
-  if (path) import_electron.clipboard.writeText(await (0, import_promises16.readFile)(path, "utf8"));
+async function resendHandoff(key) {
+  const t = state.sessions.get(key);
+  const d = t?.delivery;
+  if (!t || !d) return;
+  try {
+    await launchHandoff({ target: d.target, mode: d.mode, cwd: d.cwd, id: d.id, prompt: d.prompt, terminalApp: settings.terminalApp, resolve: defaultResolveOptions() });
+    markResent(t, /* @__PURE__ */ new Date());
+  } catch (e) {
+    notify("Harlay could not open it again", `${errorMessage(e)}. The prompt is: ${d.prompt}`);
+  }
+  refreshUi();
 }
 async function persist() {
   await saveSettings(settingsFile, settings);
@@ -2698,19 +3598,6 @@ async function onAction(a) {
         if (t) await handoff(t.ref, a.target);
         break;
       }
-      case "previewBrief": {
-        const t = state.sessions.get(a.key);
-        if (t) await previewBrief(t.ref);
-        break;
-      }
-      case "copyBrief":
-        await copyBrief(a.key);
-        break;
-      case "openBrief": {
-        const path = previewedBriefs.get(a.key);
-        if (path) await import_electron.shell.openPath(path);
-        break;
-      }
       case "setTheme":
         settings.theme = a.theme;
         import_electron.nativeTheme.themeSource = a.theme;
@@ -2751,6 +3638,23 @@ async function onAction(a) {
       case "openCursorUsage":
         await import_electron.shell.openExternal("https://cursor.com/dashboard?tab=usage");
         break;
+      case "unpinChat":
+        settings.pinned = settings.pinned.filter((k) => k !== a.key);
+        await persist();
+        break;
+      case "freshStart": {
+        const t = state.sessions.get(a.key);
+        if (t) await startFresh(t.ref);
+        break;
+      }
+      case "resendHandoff":
+        await resendHandoff(a.key);
+        break;
+      case "copyPrompt": {
+        const d = state.sessions.get(a.key)?.delivery;
+        if (d) import_electron.clipboard.writeText(d.prompt);
+        break;
+      }
       case "quit":
         import_electron.app.quit();
         break;
@@ -2761,32 +3665,19 @@ async function onAction(a) {
   }
 }
 function onWatchEvent(ev) {
+  debug("watch event", ev.ref.tool, ev.ref.id, ev.event.kind);
   const now = /* @__PURE__ */ new Date();
   const tracked = applyWatchEvent(state, ev, now);
   refreshUi();
   const targets = pickTargets(ev.ref.tool, settings.defaultTarget, available, settings.modes, state.limitedUntil, now);
   const first = targets[0];
-  const name = sessionTitle(tracked);
   if (ev.event.kind === "halt") {
     if (settings.autoContinue && first && now.getTime() - lastAutoHandoffAt >= AUTO_HANDOFF_COOLDOWN_MS) {
       lastAutoHandoffAt = now.getTime();
       void handoff(ev.ref, first);
       return;
     }
-    const n = new import_electron.Notification({
-      title: `${TOOL_LABEL[ev.ref.tool]} stopped: ${name}`,
-      body: haltNotificationBody(tracked, first),
-      actions: targets.map((t) => ({ type: "button", text: `Continue in ${TOOL_LABEL[t]}` }))
-    });
-    keep(n);
-    n.on("action", (_e, index) => {
-      const t = targets[index];
-      if (t) void handoff(ev.ref, t);
-    });
-    n.on("click", () => {
-      if (first) void handoff(ev.ref, first);
-    });
-    n.show();
+    alertPopover(sessionKey(ev.ref));
     return;
   }
 }
@@ -2804,27 +3695,78 @@ function dataDir() {
   return import_electron.app.getPath("userData");
 }
 function onHotkey() {
-  const latest = latestSession(state);
-  if (!latest) {
-    notify("Harlay", "No recent agent session to hand off.");
+  if (popover?.isVisible()) {
+    hidePopover();
     return;
   }
-  const [target] = pickTargets(latest.ref.tool, settings.defaultTarget, available, settings.modes, state.limitedUntil, /* @__PURE__ */ new Date());
-  if (!target) {
-    notify("Harlay", "No other agent is available.");
-    return;
+  const latest = latestSession(state);
+  revealPopover(latest ? sessionKey(latest.ref) : null, "user");
+}
+async function trackPinned() {
+  const refs = await Promise.all(
+    settings.pinned.filter((k) => !state.sessions.has(k)).map(async (k) => {
+      const { tool, id } = parseSessionSpec(k);
+      return findSessionById(readers, tool, id).catch(() => null);
+    })
+  );
+  seedSessions(state, refs.filter((r) => r !== null));
+}
+async function addChat(tool, raw) {
+  const id = (0, import_node_path19.basename)(raw.trim()).replace(/\.jsonl?$/, "");
+  if (!/^[\w.-]{4,200}$/.test(id)) return { ok: false, error: "That doesn\u2019t look like a chat ID." };
+  const ref = await findSessionById(readers, tool, id).catch(() => null);
+  if (!ref) return { ok: false, error: `No ${TOOL_LABEL[tool]} chat with that ID on this Mac.` };
+  const key = sessionKey(ref);
+  if (!settings.pinned.includes(key)) {
+    if (settings.pinned.length >= MAX_PINNED) return { ok: false, error: `You can add up to ${MAX_PINNED} chats. Remove one first.` };
+    settings.pinned.push(key);
+    await saveSettings(settingsFile, settings);
+  }
+  seedSessions(state, [ref]);
+  refreshUi();
+  return { ok: true };
+}
+async function loadAgentIcons() {
+  const dir = defaultResolveOptions().applicationsDir;
+  for (const tool of TOOLS) {
+    for (const bundle of APP_BUNDLES[tool]) {
+      const path = (0, import_node_path19.join)(dir, bundle);
+      try {
+        await (0, import_promises19.access)(path);
+        const thumb = await import_electron.nativeImage.createThumbnailFromPath(path, { width: 64, height: 64 });
+        agentIcons[tool] = thumb.resize({ width: 36, height: 36, quality: "best" }).toDataURL();
+        break;
+      } catch {
+      }
+    }
   }
-  void handoff(latest.ref, target);
 }
 async function refreshSessions() {
   try {
-    seedSessions(state, await listAllSessions(readers, 8));
+    seedSessions(state, (await Promise.all(readers.map((r) => r.listSessions(PER_AGENT)))).flat());
+    await trackPinned();
     available = await availableTargets(defaultResolveOptions());
     refreshUi();
+    closeResolvedAlert();
+    await refreshHealth();
   } catch (e) {
     console.error("[harlay] refresh failed", e);
   }
 }
+async function refreshHealth() {
+  const shown = Object.values(shownByAgent([...state.sessions.values()], settings)).flat();
+  const changes = await health.update(shown.map((t) => t.ref));
+  if (changes.length) refreshUi();
+}
+async function startFresh(ref) {
+  const tool = ref.tool;
+  const mode = settings.modes[tool];
+  if (!available[tool][mode]) {
+    notify("Harlay", `${TOOL_LABEL[tool]} isn't installed for ${mode === "app" ? "App" : "Terminal"} mode, so Harlay can't open a new chat.`);
+    return;
+  }
+  await handoff(ref, tool);
+}
 function createPopover() {
   const win = new import_electron.BrowserWindow({
     width: POPOVER_WIDTH,
@@ -2840,34 +3782,62 @@ function createPopover() {
     fullscreenable: false,
     skipTaskbar: true,
     alwaysOnTop: true,
-    webPreferences: { preload: (0, import_node_path18.join)(__dirname, "preload.cjs"), contextIsolation: true, nodeIntegration: false, sandbox: true }
+    // The limit panel opens without focus (see alertPopover): the first click on it must still press the button.
+    acceptFirstMouse: true,
+    // backgroundThrottling off: the limit panel opens while another app is in front, and a throttled page would leave
+    // its fade-in (and so the whole panel) invisible.
+    webPreferences: { preload: (0, import_node_path19.join)(__dirname, "preload.cjs"), contextIsolation: true, nodeIntegration: false, sandbox: true, backgroundThrottling: false }
   });
   win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
   win.on("blur", hidePopover);
   win.webContents.on("will-navigate", (e) => e.preventDefault());
   win.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
-  void win.loadFile((0, import_node_path18.join)(__dirname, "..", "renderer", "popover.html"));
+  void win.loadFile((0, import_node_path19.join)(__dirname, "..", "renderer", "popover.html"));
   return win;
 }
-function showPopover() {
+var debug = process.env.HARLAY_DEBUG ? (...a) => console.log("[harlay]", ...a) : () => void 0;
+var alertKey = null;
+function alertPopover(key) {
+  debug("limit panel for", key, { popover: !!popover, tray: tray?.getBounds(), visible: popover?.isVisible(), focused: popover?.isFocused() });
+  if (!popover || !tray) return;
+  if (popover.isVisible() && popover.isFocused()) return;
+  alertKey = key;
+  const show = () => showPopover(key, false, "user");
+  if (popover.webContents.isLoading()) popover.webContents.once("did-finish-load", show);
+  else show();
+}
+function closeResolvedAlert() {
+  if (!alertKey || !popover?.isVisible() || popover.isFocused()) return;
+  if (state.sessions.get(alertKey)?.status === "limit") return;
+  alertKey = null;
+  hidePopover();
+}
+function showPopover(route = null, focus = true, where = "icon") {
   if (!popover || !tray) return;
   const t = tray.getBounds();
-  const area = import_electron.screen.getDisplayNearestPoint({ x: t.x, y: t.y }).workArea;
-  const x = Math.min(Math.max(t.x + t.width / 2 - POPOVER_WIDTH / 2, area.x), area.x + area.width - POPOVER_WIDTH);
-  popover.setPosition(Math.round(x), Math.round(t.y + t.height));
+  const iconArea = import_electron.screen.getDisplayNearestPoint({ x: t.x, y: t.y }).workArea;
+  const userArea = where === "user" ? import_electron.screen.getDisplayNearestPoint(import_electron.screen.getCursorScreenPoint()).workArea : iconArea;
+  const { x, y } = panelPosition(t, iconArea, userArea, POPOVER_WIDTH);
+  popover.setPosition(Math.round(x), Math.round(y));
   refreshUi();
   void usage?.topUpCodex();
-  popover.show();
-  popover.focus();
-  popover.webContents.send("harlay:shown");
-}
-function revealPopover() {
+  void refreshHealth();
+  if (focus) {
+    alertKey = null;
+    popover.show();
+    popover.focus();
+  } else popover.showInactive();
+  debug("panel shown", { focus, bounds: popover.getBounds(), visible: popover.isVisible() });
+  popover.webContents.send("harlay:shown", { route, alert: !focus });
+}
+function revealPopover(route = null, where = "icon") {
   if (!popover || !tray) return;
   import_electron.app.focus({ steal: true });
-  if (popover.webContents.isLoading()) popover.webContents.once("did-finish-load", showPopover);
-  else showPopover();
+  if (popover.webContents.isLoading()) popover.webContents.once("did-finish-load", () => showPopover(route, true, where));
+  else showPopover(route, true, where);
 }
 function hidePopover() {
+  alertKey = null;
   if (!popover?.isVisible()) return;
   popover.hide();
   popoverHiddenAt = Date.now();
@@ -2893,9 +3863,14 @@ function listenToPopover() {
     const area = import_electron.screen.getDisplayMatching(popover.getBounds()).workArea;
     popover.setSize(POPOVER_WIDTH, Math.round(Math.min(Math.max(height, 120), area.height - 24)));
   });
+  import_electron.ipcMain.handle("harlay:addChat", async (e, req) => {
+    const r = typeof req === "object" && req !== null ? req : {};
+    if (!fromPopover(e) || !isTool(r.tool) || typeof r.id !== "string") return { ok: false, error: "Paste a chat ID." };
+    return addChat(r.tool, r.id);
+  });
   import_electron.ipcMain.on("harlay:action", (e, action) => {
     if (!fromPopover(e) || !isMenuAction(action)) return;
-    if (action.type === "handoff" || action.type === "openBrief" || action.type === "openCursorUsage") hidePopover();
+    if (action.type === "handoff" || action.type === "freshStart" || action.type === "resendHandoff" || action.type === "openCursorUsage") hidePopover();
     void onAction(action);
   });
 }
@@ -2904,16 +3879,20 @@ if (!import_electron.app.requestSingleInstanceLock()) {
 } else {
   import_electron.app.on("window-all-closed", () => {
   });
-  import_electron.app.on("activate", revealPopover);
-  import_electron.app.on("second-instance", revealPopover);
+  import_electron.app.on("activate", () => {
+    debug("activate", { alertKey });
+    revealPopover();
+  });
+  import_electron.app.on("second-instance", () => revealPopover());
   import_electron.app.whenReady().then(async () => {
     import_electron.app.dock?.hide();
-    settingsFile = (0, import_node_path18.join)(import_electron.app.getPath("userData"), "settings.json");
+    settingsFile = (0, import_node_path19.join)(import_electron.app.getPath("userData"), "settings.json");
     settings = await loadSettings(settingsFile);
     import_electron.nativeTheme.themeSource = settings.theme;
     if (import_electron.app.isPackaged) import_electron.app.setLoginItemSettings({ openAtLogin: settings.openAtLogin });
     available = await availableTargets(defaultResolveOptions());
-    const iconPath = (0, import_node_path18.join)(__dirname, "..", "assets", "trayTemplate.png");
+    await loadAgentIcons();
+    const iconPath = (0, import_node_path19.join)(__dirname, "..", "assets", "trayTemplate.png");
     const icon = import_electron.nativeImage.createFromPath(iconPath);
     icon.setTemplateImage(true);
     tray = new import_electron.Tray(icon);
@@ -2932,6 +3911,7 @@ if (!import_electron.app.requestSingleInstanceLock()) {
       void refreshSessions();
       void usage?.refresh();
     }, 6e4);
+    setInterval(() => void checkDeliveries(), DELIVERY_CHECK_MS);
     watcher = new Watcher(readers, { usageThreshold: settings.usageThreshold });
     watcher.on("event", onWatchEvent);
     watcher.on("error", (e) => console.error("[harlay] watcher error", e));