daily-focus 1.2.0-dev.12 → 1.2.0-dev.13

package/README.md

@@ -163,8 +163,13 @@ in `DAILY_FOCUS_AGENT_AT`, and from the refresh icon beside the brief's age when
 morning's brief is out of date by lunch. Each run keeps what you have marked done,
 snoozed or noted.
 
+The agent reads your sources in parallel, handing each to a subagent of its own.
+While it runs, its panel shows what it is doing: what it says, each command it runs
+and each thread or page it reads, and each subagent under the step that started it,
+open while it works.
+
 Every run is recorded. Click "updated … ago" to open the latest: its report says what
-it wrote and what it could not reach, its working commentary is folded away beneath,
+it wrote and what it could not reach, how it got there is folded away beneath,
 and you can ask it why it did what it did, or to look again, in the same session. Earlier runs are folded away below. See
 [SETUP.md](SETUP.md#connect-your-morning-agent).
 

package/SETUP.md

@@ -414,10 +414,17 @@ in the archive. While it runs, a banner says so and offers Stop; click the banne
 to watch the run. When it finishes the banner goes, since the brief it wrote is the
 page. A run that fails stays as a warning until you dismiss it.
 
+The agent reads your sources in parallel, each handed to a subagent of its own, and
+the panel shows what it is doing as it goes: what it says, each command it runs and
+each thing it reads, and each subagent under the step that started it, open while
+it works. Claude Code reports its subagents itself. Codex doesn't, so for a Codex
+run the dashboard reads them from Codex's own session files, under `~/.codex/sessions`
+or `$CODEX_HOME`. It only ever reads them.
+
 Click "updated … ago" to open the latest run in the panel. It holds the agent's
 report — what it wrote, what it dropped as handled, and any source it could not
-reach — with everything it said on the way there folded away beneath, and a field
-to ask it about the run. The question goes to the agent in the
+reach — with everything it said and did on the way there folded away beneath, and a
+field to ask it about the run. The question goes to the agent in the
 same session, so it answers from what it actually did: why it dropped an item, what
 it could not find, whether it can find it now. A follow-up is given nothing to
 write; if something in the brief should change, it says what, and you run it again.

package/dist/{chunk-FPBY3TAW.js → chunk-6COKG3VL.js}

@@ -299,6 +299,10 @@ var claudeAdapter = {
     const event = parseLine(line);
     if (!event) return null;
     const type = event.type;
+    if (type === "system" && event.subtype === "task_notification" && typeof event.tool_use_id === "string") {
+      const step = { id: event.tool_use_id, state: event.status === "completed" ? "done" : "failed", final: true };
+      return { steps: [step] };
+    }
     if (type === "system" && typeof event.session_id === "string") {
       return { sessionId: event.session_id };
     }
@@ -310,7 +314,9 @@ var claudeAdapter = {
       if (text) parsed.text = text;
       const steps = content.flatMap((block) => claudeStep(block) ?? []);
       if (steps.length) parsed.steps = steps;
-      return text || steps.length ? parsed : null;
+      if (!text && !steps.length) return null;
+      if (typeof event.parent_tool_use_id === "string") parsed.by = event.parent_tool_use_id;
+      return parsed;
     }
     if (type === "result") {
       const ok = event.is_error !== true && event.subtype === "success";
@@ -369,6 +375,8 @@ var ADAPTERS = {
   codex: codexAdapter
 };
 var CLAUDE_QUIET_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "TodoWrite", "StructuredOutput"]);
+var HANDOFF = "Hand part of it to a subagent";
+var WAIT = "Wait for its subagents";
 function claudeStep(block) {
   if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
     return { id: block.tool_use_id, state: block.is_error === true ? "failed" : "done" };
@@ -393,7 +401,7 @@ function claudeStep(block) {
       return step("List files", said("pattern"));
     case "Task":
     case "Agent":
-      return step("Hand part of it to a subagent", said("description"));
+      return { ...step(HANDOFF, said("description")), handoff: true };
   }
   const mcp = /^mcp__(.+?)__(.+)$/.exec(block.name);
   if (mcp) return step(connectorLabel(mcp[1], mcp[2]), compactArgs(input));
@@ -415,6 +423,7 @@ function codexStep(item, completed) {
   if (item.type === "mcp_tool_call" && typeof item.server === "string" && typeof item.tool === "string") {
     return { id: item.id, text: connectorLabel(item.server, item.tool), detail: compactArgs(item.arguments), state };
   }
+  if (item.type === "collab_tool_call" && item.tool === "wait") return { id: item.id, text: WAIT, detail: null, state };
   if (item.type === "web_search") {
     const action = item.action ?? {};
     if (action.type === "open_page") return { id: item.id, text: "Open a page", detail: shorten(action.url ?? null), state };
@@ -1010,6 +1019,12 @@ export {
   codexLatestModel,
   QUICK_ACTIONS,
   ADAPTERS,
+  HANDOFF,
+  WAIT,
+  unwrapShell,
+  connectorLabel,
+  compactArgs,
+  shorten,
   Assistant,
   autoKeys,
   actionOf,

package/dist/cli.js

@@ -49,7 +49,7 @@ function shouldOpen(flag) {
   return flag && process.stdout.isTTY === true && !process.env.CI;
 }
 async function demo(open, profile) {
-  const { demoEnv, demoIntegrations, demoProfile, writeDemoStore } = await import("./demo-UKILSZYF.js");
+  const { demoEnv, demoIntegrations, demoProfile, writeDemoStore } = await import("./demo-AJWHY6KY.js");
   const chosen = demoProfile(profile);
   const store = await mkdtemp(join(tmpdir(), "daily-focus-demo-"));
   process.on("exit", () => rmSync(store, { recursive: true, force: true }));
@@ -66,7 +66,7 @@ async function demo(open, profile) {
   );
 }
 async function start(open, onStarted, options = {}) {
-  const { runServer } = await import("./server-RKEB6FDK.js");
+  const { runServer } = await import("./server-VPSSCDBW.js");
   await runServer({
     ...options,
     onStarted: (url) => {

package/dist/{demo-UKILSZYF.js → demo-AJWHY6KY.js}

@@ -3,7 +3,7 @@ import {
   actionOf,
   autoKeys,
   judge
-} from "./chunk-FPBY3TAW.js";
+} from "./chunk-6COKG3VL.js";
 import {
   dateFromNow,
   sampleBrief,
@@ -619,7 +619,7 @@ function runLines(seed) {
     return lines2;
   }
   const report = seed.messages.at(-1) ?? "";
-  lines2.push({ event: "finished", run: seed.id, sessionId: `sample-${seed.id}`, report, messages: seed.messages, at: endedAt });
+  lines2.push({ event: "finished", run: seed.id, sessionId: `sample-${seed.id}`, report, messages: seed.messages, steps: seed.steps ?? [], at: endedAt });
   if (seed.question) {
     const turn = `${seed.id}-q1`;
     const replied = new Date(new Date(seed.question.at).getTime() + 48e3).toISOString();
@@ -741,8 +741,75 @@ function demoAgentLog(profile, now) {
       }
     }
   ];
+  const newest = runs.find((run) => run.id === "run-0");
+  newest.steps = demoRunSteps(profile, newest.messages);
   return runs.flatMap(runLines);
 }
+function demoRunSteps(profile, messages) {
+  const said2 = (text, by = null) => ({ kind: "message", text, detail: null, state: "done", by });
+  const call2 = (text, detail, by = null) => ({ kind: "tool", text, detail, state: "done", by });
+  const handoff = (name) => ({ ...call2("Hand part of it to a subagent", name), subagent: name });
+  const wait = call2("Wait for its subagents", null);
+  const start = [
+    said2(messages[0]),
+    call2("Run a command", "cat prompt.md focus.md sources.md items.json"),
+    call2("Run a command", "tail -n 400 actions.jsonl")
+  ];
+  const finish = [call2("Run a command", "mv items.json.tmp items.json"), said2(messages.at(-1))];
+  if (profile === "work") {
+    return [
+      ...start,
+      handoff("calendar"),
+      handoff("gmail"),
+      handoff("github"),
+      call2("Google calendar list events", '{"calendar_id":"primary","time_min":"today 00:00"}', "calendar"),
+      said2("5 events. The 1:1 with Alice and the design review both sit at 11:00; the lunch & learn is marked free.", "calendar"),
+      call2("Gmail search emails", '{"query":"newer_than:3d -category:promotions"}', "gmail"),
+      call2("Gmail batch read email", '{"message_ids":["19a2f\u2026","19a31\u2026","19a33\u2026","19a35\u2026"]}', "gmail"),
+      said2("31 threads in the window. 4 ask something of you; Bob followed up on Q4 headcount yesterday.", "gmail"),
+      call2("Run a command", "gh search prs --review-requested=@me --state=open --json url,title,updatedAt", "github"),
+      call2("Run a command", "gh pr checks 3402 -R acme/webapp", "github"),
+      said2("A review request from Alice on acme/webapp#3421, and a red check on #3402. The rest is already on the board.", "github"),
+      wait,
+      said2(messages[1]),
+      said2(messages[2]),
+      handoff("jira"),
+      handoff("slack"),
+      handoff("workday"),
+      call2("Run a command", 'acli jira workitem search --jql "assignee = currentUser() AND statusCategory != Done"', "jira"),
+      said2("PROJ-8842 is still open, with both of its pull requests merged.", "jira"),
+      call2("Slack search messages", '{"query":"to:me after:yesterday"}', "slack"),
+      said2("One direct question, from Chris in #webapp-dev.", "slack"),
+      call2("Workday list inbox tasks", null, "workday"),
+      said2("The compliance training is due tonight. The Berlin expense report is still a draft.", "workday"),
+      { ...wait },
+      said2(messages[3]),
+      ...finish
+    ];
+  }
+  return [
+    ...start,
+    handoff("calendar"),
+    handoff("eboks"),
+    handoff("email"),
+    call2("Google calendar list events", '{"calendar_id":"personal","time_min":"today 00:00"}', "calendar"),
+    call2("Google calendar list events", '{"calendar_id":"family","time_min":"today 00:00"}', "calendar"),
+    said2("6 events across Personal and Family. The insurance call at 16:30 overlaps the daycare pickup.", "calendar"),
+    call2("Run a command", "eboks list --since 3d --json", "eboks"),
+    call2("Run a command", "eboks text --json 4417911204", "eboks"),
+    said2("5 letters. The daycare invoice and the tax assessment ask for something; three are confirmations.", "eboks"),
+    call2("Gmail search emails", '{"query":"newer_than:3d -category:promotions"}', "email"),
+    said2("3 threads need you, the insulation quote among them, quiet for nine days.", "email"),
+    wait,
+    said2(messages[1]),
+    handoff("messages"),
+    call2("Run a command", "messages recent --since 3d --json", "messages"),
+    said2("Jonas asked about Saturday on Tuesday, and Priya is still waiting for the photos.", "messages"),
+    { ...wait },
+    said2(messages[2]),
+    ...finish
+  ];
+}
 var call = (text, detail, state = "done") => ({ kind: "tool", text, detail, state });
 var said = (text) => ({ kind: "message", text, detail: null, state: "done" });
 function turnLines(seed) {

package/dist/{server-RKEB6FDK.js → server-VPSSCDBW.js}

@@ -3,13 +3,19 @@ import {
   Assistant,
   AutoAsk,
   CodexGate,
+  HANDOFF,
+  WAIT,
   codexLatestModel,
   codexVersionWarning,
+  compactArgs,
   computerUseOff,
+  connectorLabel,
   countBoard,
   refusalFor,
-  resolveBoard
-} from "./chunk-FPBY3TAW.js";
+  resolveBoard,
+  shorten,
+  unwrapShell
+} from "./chunk-6COKG3VL.js";
 import {
   FOCUS_TEMPLATE,
   sourcesTemplate
@@ -58,7 +64,7 @@ import {
 import { createServer } from "node:http";
 import { createReadStream } from "node:fs";
 import { stat as stat4 } from "node:fs/promises";
-import { basename, extname, join as join6, normalize, resolve, sep } from "node:path";
+import { basename, extname, join as join7, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/clis.ts
@@ -2729,11 +2735,170 @@ async function readTicketsFile(path) {
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, readFile as readFile7 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { createInterface } from "node:readline";
+
+// src/codexsessions.ts
+import { open, readdir as readdir2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
+function codexHome(env = process.env) {
+  return env.CODEX_HOME?.trim() || join4(homedir2(), ".codex");
+}
+var DAY_MS = 24 * 60 * 6e4;
+var CHUNK = 4 * 1024 * 1024;
+var CodexSessions = class {
+  threads = /* @__PURE__ */ new Map();
+  since;
+  home;
+  /** `threadId` is the run's, as the stream's `thread.started` gives it; `since`, when the run started. */
+  constructor(threadId, since, home = codexHome()) {
+    this.since = since;
+    this.home = home;
+    this.threads.set(threadId, { id: threadId, root: true, path: null, offset: 0, partial: Buffer.alloc(0) });
+  }
+  /**
+   * Whatever the files have added since the last read, oldest first within each
+   * thread. A subagent found on the way is read in the same pass.
+   */
+  async read(now = /* @__PURE__ */ new Date()) {
+    const news = [];
+    for (const thread of this.threads.values()) {
+      thread.path ??= await this.find(thread.id, now);
+      if (!thread.path) continue;
+      for (const line of await this.tail(thread)) this.take(thread, line, news);
+    }
+    return news;
+  }
+  /**
+   * The file a thread is written to. Codex files a session under the local date
+   * it started, so the days the run spans are searched, a day either side for a
+   * clock that disagrees.
+   */
+  async find(id, now) {
+    const suffix = `-${id}.jsonl`;
+    for (let at = this.since.getTime() - DAY_MS; at <= now.getTime() + DAY_MS; at += DAY_MS) {
+      const day = new Date(at);
+      const dir = join4(
+        this.home,
+        "sessions",
+        String(day.getFullYear()),
+        String(day.getMonth() + 1).padStart(2, "0"),
+        String(day.getDate()).padStart(2, "0")
+      );
+      let names;
+      try {
+        names = await readdir2(dir);
+      } catch {
+        continue;
+      }
+      const name = names.find((candidate) => candidate.endsWith(suffix));
+      if (name) return join4(dir, name);
+    }
+    return null;
+  }
+  /** The whole lines added to a thread's file since the last read. */
+  async tail(thread) {
+    let handle;
+    try {
+      handle = await open(thread.path, "r");
+    } catch {
+      return [];
+    }
+    try {
+      const { size } = await handle.stat();
+      if (size <= thread.offset) return [];
+      const buffer = Buffer.alloc(Math.min(size - thread.offset, CHUNK));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, thread.offset);
+      thread.offset += bytesRead;
+      const bytes = Buffer.concat([thread.partial, buffer.subarray(0, bytesRead)]);
+      const end = bytes.lastIndexOf(10);
+      thread.partial = end === -1 ? bytes : bytes.subarray(end + 1);
+      return end === -1 ? [] : bytes.subarray(0, end).toString("utf8").split("\n");
+    } catch {
+      return [];
+    } finally {
+      await handle.close();
+    }
+  }
+  take(thread, line, news) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (record?.type !== "event_msg" || record.payload?.type !== "item_completed") return;
+    const item = record.payload.item;
+    if (typeof item !== "object" || item === null) return;
+    const by = thread.root ? null : thread.id;
+    if (item.type === "SubAgentActivity" && typeof item.agent_thread_id === "string") {
+      const child = item.agent_thread_id;
+      if (item.kind === "started") {
+        if (!this.threads.has(child)) {
+          this.threads.set(child, { id: child, root: false, path: null, offset: 0, partial: Buffer.alloc(0) });
+        }
+        news.push({ by, step: { id: child, text: HANDOFF, detail: subagentName(item.agent_path), state: "running", handoff: true } });
+      } else if (item.kind === "completed") {
+        news.push({ by, step: { id: child, state: "done", final: true } });
+      } else if (typeof item.kind === "string" && /fail|error|abort|interrupt|cancel|kill/i.test(item.kind)) {
+        news.push({ by, step: { id: child, state: "failed", final: true } });
+      }
+      return;
+    }
+    if (thread.root) return;
+    if (item.type === "AgentMessage") {
+      const text = Array.isArray(item.content) ? item.content.map((part) => typeof part?.text === "string" ? part.text : "").join("").trim() : "";
+      if (text) news.push({ by: thread.id, message: text });
+      return;
+    }
+    const step = rolloutStep(item);
+    if (step) news.push({ by: thread.id, step: { ...step, id: `${thread.id}:${step.id}` } });
+  }
+};
+function subagentName(path) {
+  if (typeof path !== "string") return null;
+  const name = path.split("/").filter(Boolean).at(-1);
+  return name ? name.replace(/[_-]+/g, " ") : null;
+}
+function rolloutStep(item) {
+  if (typeof item.id !== "string") return null;
+  const failed = item.status === "failed" || item.error !== void 0 && item.error !== null;
+  const state = failed ? "failed" : "done";
+  switch (item.type) {
+    case "CommandExecution": {
+      const command3 = Array.isArray(item.command) ? item.command.length === 3 && /^-l?c$/.test(item.command[1] ?? "") ? item.command[2] : item.command.join(" ") : unwrapShell(item.command ?? "");
+      const exited = typeof item.exit_code === "number" && item.exit_code !== 0;
+      return { id: item.id, text: "Run a command", detail: shorten(command3), state: exited ? "failed" : state };
+    }
+    case "McpToolCall": {
+      const app = item.server === "codex_apps" && typeof item.appName === "string" && typeof item.actionName === "string";
+      const text = connectorLabel(item.server ?? "tool", app ? `${item.appName}_${item.actionName}` : item.tool ?? "call");
+      return { id: item.id, text, detail: compactArgs(item.arguments), state };
+    }
+    case "Extension": {
+      if (item.kind !== "web.search") return null;
+      const action = item.action ?? {};
+      if (action.type === "openPage") return { id: item.id, text: "Open a page", detail: shorten(action.url ?? null), state };
+      if (action.type === "findInPage") return { id: item.id, text: "Find in a page", detail: shorten(action.pattern ?? null), state };
+      return { id: item.id, text: "Search the web", detail: shorten(action.query || item.query || null), state };
+    }
+    case "FileChange":
+      return { id: item.id, text: "Write a file", detail: shorten(Object.keys(item.changes ?? {}).join(", ") || null), state };
+    case "ImageView":
+      return { id: item.id, text: "Look at an image", detail: shorten(item.path?.replace(/^file:\/\//, "") ?? null), state };
+    case "CollabAgentToolCall":
+      return item.tool === "wait" ? { id: item.id, text: WAIT, detail: null, state } : null;
+  }
+  return null;
+}
+
+// src/agent.ts
 var RUN_TIMEOUT_MS = 60 * 6e4;
 var TURN_TIMEOUT_MS = 10 * 6e4;
 var RUNS_SHOWN = 30;
+var STEPS_KEPT = 500;
+var SESSIONS_EVERY_MS = 2e3;
 function agentPrompt(promptPath) {
   return [
     "Run my morning brief for today.",
@@ -2764,7 +2929,7 @@ function followUpPrompt(question) {
     question.trim()
   ].join("\n");
 }
-function displayPath(path, home = homedir2()) {
+function displayPath(path, home = homedir3()) {
   return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
 function foldAgentLog(text) {
@@ -2790,6 +2955,7 @@ function foldAgentLog(text) {
         status: "running",
         report: "",
         messages: [],
+        steps: [],
         error: null,
         turns: [],
         resumable: false
@@ -2830,6 +2996,7 @@ function foldAgentLog(text) {
     run5.sessionId = typeof record.sessionId === "string" ? record.sessionId : run5.sessionId;
     run5.report = typeof record.report === "string" ? record.report : run5.report;
     run5.messages = Array.isArray(record.messages) ? record.messages.filter((message) => typeof message === "string") : run5.report ? [run5.report] : [];
+    run5.steps = readSteps(record.steps);
     run5.endedAt = record.at;
     if (record.event === "finished") {
       run5.status = "done";
@@ -2843,6 +3010,57 @@ function foldAgentLog(text) {
   }
   return [...runs.values()].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
 }
+function readSteps(value) {
+  if (!Array.isArray(value)) return [];
+  const steps = [];
+  for (const candidate of value) {
+    if (typeof candidate !== "object" || candidate === null || typeof candidate.text !== "string") continue;
+    steps.push({
+      kind: candidate.kind === "message" ? "message" : "tool",
+      text: candidate.text,
+      detail: typeof candidate.detail === "string" ? candidate.detail : null,
+      state: candidate.state === "failed" ? "failed" : "done",
+      by: typeof candidate.by === "string" ? candidate.by : null,
+      ...typeof candidate.subagent === "string" ? { subagent: candidate.subagent } : {}
+    });
+  }
+  return steps;
+}
+var StepTrail = class {
+  calls = /* @__PURE__ */ new Map();
+  run;
+  constructor(run5) {
+    this.run = run5;
+  }
+  said(by, text) {
+    this.add({ kind: "message", text, detail: null, state: "done", by });
+  }
+  call(by, parsed) {
+    const known = this.calls.get(parsed.id);
+    if (known) {
+      if (parsed.text) known.text = parsed.text;
+      if (parsed.detail) known.detail = parsed.detail;
+      if (!known.subagent || parsed.final || parsed.state === "failed") known.state = parsed.state;
+      return;
+    }
+    if (!parsed.text) return;
+    const step = { kind: "tool", text: parsed.text, detail: parsed.detail ?? null, state: parsed.state, by };
+    if (parsed.handoff) step.subagent = parsed.id;
+    this.calls.set(parsed.id, step);
+    this.add(step);
+  }
+  /** A call nobody reported back on went the way the run did. */
+  settle(ok) {
+    for (const step of this.run.steps) if (step.state === "running") step.state = ok ? "done" : "failed";
+  }
+  add(step) {
+    const steps = this.run.steps;
+    steps.push(step);
+    if (steps.length <= STEPS_KEPT) return;
+    const oldest = steps.findIndex((candidate) => !candidate.subagent);
+    steps.splice(oldest === -1 ? 0 : oldest, 1);
+  }
+};
 var AgentRunner = class {
   /** Every run in the log, oldest first. */
   runs = [];
@@ -2853,11 +3071,14 @@ var AgentRunner = class {
   spawnFn;
   /** Refuses a Codex too old to hold to the connector rules; see `codex.ts`. */
   codexGate;
-  constructor(config, hooks, spawnFn = spawn, execFn) {
+  /** Where Codex writes its session files, which say what a Codex run's subagents do. */
+  codexHome;
+  constructor(config, hooks, spawnFn = spawn, execFn, home = codexHome()) {
     this.config = config;
     this.hooks = hooks;
     this.spawnFn = spawnFn;
     this.codexGate = new CodexGate(config.agent.binPath, execFn);
+    this.codexHome = home;
   }
   get enabled() {
     return this.config.agent.cli !== null;
@@ -2883,7 +3104,7 @@ var AgentRunner = class {
         run5.status = "aborted";
         run5.error = reason;
         run5.endedAt = at;
-        await this.append({ event: "aborted", run: run5.id, sessionId: run5.sessionId, reason, report: run5.report, messages: run5.messages, at });
+        await this.append({ event: "aborted", run: run5.id, sessionId: run5.sessionId, reason, report: run5.report, messages: run5.messages, steps: run5.steps, at });
       }
       for (const turn of run5.turns) {
         if (turn.status !== "running") continue;
@@ -2903,7 +3124,7 @@ var AgentRunner = class {
     return this.runs.at(-1) ?? null;
   }
   view(now = /* @__PURE__ */ new Date()) {
-    const runs = this.runs.slice(-RUNS_SHOWN).reverse().map((run5) => ({ ...run5, resumable: this.resumable(run5) }));
+    const runs = this.runs.slice(-RUNS_SHOWN).reverse().map((run5, index) => ({ ...run5, steps: index === 0 ? run5.steps : [], resumable: this.resumable(run5) }));
     return {
       enabled: this.enabled,
       cli: this.config.agent.cli,
@@ -2967,6 +3188,7 @@ var AgentRunner = class {
       status: "running",
       report: "",
       messages: [],
+      steps: [],
       error: null,
       turns: [],
       resumable: false
@@ -3078,23 +3300,31 @@ var AgentRunner = class {
       stderr.push(chunk.toString("utf8"));
       if (stderr.length > 50) stderr.shift();
     });
+    const trail = turn ? null : new StepTrail(run5);
+    let reader = null;
     if (child.stdout) {
       const lines = createInterface({ input: child.stdout });
       lines.on("line", (line) => {
         const event = adapter.parse(line);
         if (!event) return;
         if (event.sessionId && !turn) run5.sessionId = event.sessionId;
+        if (trail && cli2 === "codex" && run5.sessionId && !reader) reader = this.readSessions(run5, trail);
+        const by = event.by ?? null;
         if (event.text) {
-          if (turn) {
+          if (by !== null) {
+            trail?.said(by, event.text);
+          } else if (turn) {
             turn.reply = turn.reply ? `${turn.reply}
 
 ${event.text}` : event.text;
           } else {
             run5.messages.push(event.text);
             run5.report = event.text;
+            trail?.said(null, event.text);
           }
-          this.hooks.onChange();
         }
+        for (const parsed of event.steps ?? []) trail?.call(by, parsed);
+        if (event.text || trail && event.steps) this.hooks.onChange();
         if (event.done) done = event.done;
       });
     }
@@ -3103,14 +3333,53 @@ ${event.text}` : event.text;
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      this.running = null;
       const outcome = running.abortReason ? { ok: false, error: running.abortReason } : done ?? {
         ok: false,
         error: `${cli2} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
       };
-      void this.finish(run5, turn, outcome, running.abortReason !== null);
+      void (async () => {
+        if (reader) await this.stopReading(reader, trail);
+        this.running = null;
+        trail?.settle(outcome.ok);
+        await this.finish(run5, turn, outcome, running.abortReason !== null);
+      })();
     });
   }
+  /**
+   * Start reading a Codex run's session files for its subagents, now that the
+   * stream has named the run's thread.
+   */
+  readSessions(run5, trail) {
+    const reader = {
+      sessions: new CodexSessions(run5.sessionId, new Date(run5.startedAt), this.codexHome),
+      timer: setInterval(() => void this.readOnce(reader, trail), SESSIONS_EVERY_MS),
+      reading: null
+    };
+    reader.timer.unref();
+    return reader;
+  }
+  readOnce(reader, trail) {
+    reader.reading ??= (async () => {
+      try {
+        const news = await reader.sessions.read();
+        for (const entry of news) {
+          if ("message" in entry) trail.said(entry.by, entry.message);
+          else trail.call(entry.by, entry.step);
+        }
+        if (news.length) this.hooks.onChange();
+      } catch (err) {
+        console.warn(`[daily-focus] could not read Codex's session files: ${err.message}`);
+      } finally {
+        reader.reading = null;
+      }
+    })();
+    return reader.reading;
+  }
+  async stopReading(reader, trail) {
+    clearInterval(reader.timer);
+    await reader.reading;
+    await this.readOnce(reader, trail);
+  }
   /**
    * Kill whatever is going, run or follow-up. What a run already renamed into
    * place stays: the brief it replaced is gone either way, and the archive has it.
@@ -3152,17 +3421,17 @@ ${event.text}` : event.text;
     const report = outcome.reply ?? run5.report;
     run5.report = report;
     run5.endedAt = at;
-    const messages = run5.messages;
+    const { messages, steps } = run5;
     if (outcome.ok) {
-      await this.append({ event: "finished", run: run5.id, sessionId: run5.sessionId, report, messages, at });
+      await this.append({ event: "finished", run: run5.id, sessionId: run5.sessionId, report, messages, steps, at });
       run5.status = "done";
     } else if (aborted) {
       run5.error = outcome.error ?? "stopped";
-      await this.append({ event: "aborted", run: run5.id, sessionId: run5.sessionId, reason: run5.error, report, messages, at });
+      await this.append({ event: "aborted", run: run5.id, sessionId: run5.sessionId, reason: run5.error, report, messages, steps, at });
       run5.status = "aborted";
     } else {
       run5.error = outcome.error ?? "failed";
-      await this.append({ event: "failed", run: run5.id, sessionId: run5.sessionId, error: run5.error, report, messages, at });
+      await this.append({ event: "failed", run: run5.id, sessionId: run5.sessionId, error: run5.error, report, messages, steps, at });
       run5.status = "failed";
     }
     this.hooks.onChange();
@@ -3209,19 +3478,19 @@ function watchDataDir(dir, onChange, { debounceMs = 120, ignore = [] } = {}) {
 }
 
 // src/assets.ts
-import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 async function computeAssetVersion(dir) {
   const parts = [];
   async function walk(current) {
     let entries;
     try {
-      entries = await readdir2(current, { withFileTypes: true });
+      entries = await readdir3(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const path = join4(current, entry.name);
+      const path = join5(current, entry.name);
       if (entry.isDirectory()) {
         await walk(path);
       } else {
@@ -3281,7 +3550,7 @@ function refusal(req, listenHost) {
 import { spawn as spawn2 } from "node:child_process";
 import { mkdir as mkdir2, mkdtemp, readFile as readFile8, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // src/questions.ts
@@ -4233,7 +4502,7 @@ async function saveSettings(path, settings) {
 // src/onboarding.ts
 var TURN_TIMEOUT_MS2 = 4 * 6e4;
 var KILL_AFTER_MS = 5e3;
-var STEPS_KEPT = 40;
+var STEPS_KEPT2 = 40;
 var SESSION_MODEL = {
   claude: { model: "opus", effort: "low" },
   codex: { model: null, effort: "low" }
@@ -4687,8 +4956,8 @@ ${request}`, resume, said);
         return this.settle(question.id, record, { ok: false, error: `Codex could not say which plugins to switch off: ${err.message}` });
       }
     }
-    const schemaDir = await mkdtemp(join5(tmpdir2(), "daily-focus-setup-"));
-    const schemaFile = join5(schemaDir, "schema.json");
+    const schemaDir = await mkdtemp(join6(tmpdir2(), "daily-focus-setup-"));
+    const schemaFile = join6(schemaDir, "schema.json");
     const json = JSON.stringify(question.agent.schema);
     await writeFile2(schemaFile, json, "utf8");
     await mkdir2(this.config.onboardingDir, { recursive: true });
@@ -4729,7 +4998,7 @@ ${request}`, resume, said);
     const steps = this.steps.get(question.id);
     const add = (step) => {
       steps.push(step);
-      if (steps.length > STEPS_KEPT) steps.shift();
+      if (steps.length > STEPS_KEPT2) steps.shift();
     };
     if (child.stdout) {
       createInterface2({ input: child.stdout }).on("line", (line) => {
@@ -5116,7 +5385,7 @@ async function readBody(req) {
 }
 async function serveStatic(res, urlPath) {
   const relative = normalize(decodeURIComponent(urlPath === "/" ? "/index.html" : urlPath));
-  const filePath = join6(PUBLIC_DIR, relative);
+  const filePath = join7(PUBLIC_DIR, relative);
   if (filePath !== PUBLIC_DIR && !filePath.startsWith(PUBLIC_DIR + sep)) {
     res.writeHead(403).end("Forbidden");
     return;
@@ -5205,7 +5474,7 @@ async function startServer(env, options = {}) {
   let restart = null;
   let restarting = false;
   let settingsWrites = Promise.resolve();
-  await stat4(join6(PUBLIC_DIR, "app.js")).catch(() => {
+  await stat4(join7(PUBLIC_DIR, "app.js")).catch(() => {
     console.warn(
       PACKAGED ? "[daily-focus] public/app.js is missing from the package: reinstall it" : "[daily-focus] public/app.js is missing: run `npm run build` (npm start does so on its own)"
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daily-focus",
-  "version": "1.2.0-dev.12",
+  "version": "1.2.0-dev.13",
   "description": "An interactive dashboard of what you should focus on today at work",
   "keywords": [
     "dashboard",

package/prompts/README.md

@@ -78,6 +78,13 @@ writes `agent-settings.json` with the values it is running with, whether they we
 saved on the settings page or set in `.env`, and both prompts say what each key means.
 The wrapper stays the same whatever the settings are.
 
+The prompt has the agent hand the reading of its sources to subagents, which share
+its working directory and what its CLI allows it, so the prompt also tells it to
+tell them that they only read. The judging and the writing stay with the agent. The
+run's panel shows each subagent under the step that started it: Claude Code reports
+them in its output, and for Codex the dashboard reads Codex's own session files
+(`src/codexsessions.ts`).
+
 Which days it runs is `DAILY_FOCUS_AGENT_DAYS` — cron-numbered, so `1-5` is Mon–Fri
 and `0-4` is the Sun–Thu week — and Mon–Fri when unset. The same schedule drives the
 staleness banner, which turns red once the brief is more than 24 *working* hours old,

package/prompts/morning-brief-personal.md

@@ -104,6 +104,33 @@ Otherwise, each source's window starts three days before the previous brief's
 
 ### Step 2 — Gather
 
+#### Hand the reading to subagents
+
+Read the sources in parallel rather than one after another: hand each source to a
+subagent of its own, or a few small ones to one subagent, so the slowest source sets
+the pace rather than the sum of them. Run up to three at a time, starting the next as
+one finishes. The reading is all you hand out. Step 1, the judging in step 3, the
+writing in step 4 and the checks in step 5 stay with you, because they need
+everything in one place.
+
+A subagent may not see this file, so give it what it needs in its task: its source's
+section of this step in full, with the value of any setting from `agent-settings.json`
+that the section names; the rules under "Across every source" below; the window from
+step 1; and the ids from the previous brief that came from its source and are still
+open, so it looks at each again. Name each after its source — `calendar`, `email`, `eboks` — since
+the dashboard shows the user which is which while you work.
+
+Ask for evidence, not decisions. For each thing that might be an item: its upstream id
+or key, its link, who and what it is about, its dates, and what the source shows about
+whether it is still open. Then what it could not read, why, and the link. Merging
+duplicates, ranking and wording are yours. When an answer is missing something its
+source should have had, ask again or read it yourself.
+
+A subagent only reads, and tell it so: it writes no file, `items.json` least of all,
+and changes nothing in any source.
+
+If you cannot start subagents, read the sources yourself, one after another.
+
 #### Across every source
 
 **Use a connector, API, MCP server or CLI as the evidence source.** `sources.md` says

package/prompts/morning-brief-work.md

@@ -111,6 +111,33 @@ a recent query alone make unfinished work disappear.
 
 ### Step 2 — Gather
 
+#### Hand the reading to subagents
+
+Read the sources in parallel rather than one after another: hand each source to a
+subagent of its own, or a few small ones to one subagent, so the slowest source sets
+the pace rather than the sum of them. Run up to three at a time, starting the next as
+one finishes. The reading is all you hand out. Step 1, the judging in step 3, the
+writing in step 4 and the checks in step 5 stay with you, because they need
+everything in one place.
+
+A subagent may not see this file, so give it what it needs in its task: its source's
+section of this step in full, with the value of any setting from `agent-settings.json`
+that the section names; the rules under "Across every source" below; the window from
+step 1; and the ids from the previous brief that came from its source and are still
+open, so it looks at each again. Name each after its source — `calendar`, `gmail`, `github` — since
+the dashboard shows the user which is which while you work.
+
+Ask for evidence, not decisions. For each thing that might be an item: its upstream id
+or key, its link, who and what it is about, its dates, and what the source shows about
+whether it is still open. Then what it could not read, why, and the link. Merging
+duplicates, ranking and wording are yours. When an answer is missing something its
+source should have had, ask again or read it yourself.
+
+A subagent only reads, and tell it so: it writes no file, `items.json` least of all,
+and changes nothing in any source.
+
+If you cannot start subagents, read the sources yourself, one after another.
+
 #### Across every source
 
 **Use a connector, API or CLI as the evidence source.** A browser may only help you

package/public/app.js

@@ -2479,10 +2479,11 @@ function agentRunBanner(run, state2, handlers2) {
     }
   };
   if (run.status === "running") {
+    const helping = (run.steps ?? []).filter((step) => step.subagent && step.state === "running").length;
     return bannerNode(
       "info",
       "i",
-      `The morning agent is writing a new brief, started ${relativeTime(run.startedAt, now)}.`,
+      `The morning agent is writing a new brief, started ${relativeTime(run.startedAt, now)}` + (helping ? `, with ${helping} ${helping === 1 ? "subagent" : "subagents"} at work.` : "."),
       [el("button", { type: "button", class: "button banner__action", onClick: () => handlers2.stopAgent() }, "Stop")],
       strip
     );
@@ -3935,6 +3936,7 @@ function describeWhen(value, now) {
   return `${named ? day : date && date.getFullYear() === now.getFullYear() ? formatShortDay(value) : formatDay(value)} at ${formatTime(value)}`;
 }
 function runReport(run, ui2, handlers2) {
+  if (run.steps?.length) return runWork(run, ui2, handlers2);
   const messages = run.messages ?? (run.report ? [run.report] : []);
   const running = run.status === "running";
   const earlier = !running && messages.length && messages.at(-1) === run.report ? messages.slice(0, -1) : messages;
@@ -3993,6 +3995,92 @@ function runReport(run, ui2, handlers2) {
     ) : null
   );
 }
+function runWork(run, ui2, handlers2) {
+  const running = run.status === "running";
+  if (running) {
+    return el(
+      "section",
+      { class: "flyout__section" },
+      el("h3", { class: "flyout__label" }, "What it is doing"),
+      runSteps(run, run.steps, null, ui2, handlers2)
+    );
+  }
+  const last = run.steps.findLast((step) => step.by === null && step.kind === "message");
+  const steps2 = last && sameWords(last.text, run.report) ? run.steps.filter((step) => step !== last) : run.steps;
+  const handoffs = steps2.filter((step) => step.subagent).length;
+  return el(
+    "section",
+    { class: "flyout__section" },
+    el("h3", { class: "flyout__label" }, run.status === "done" ? "Its report" : "What it said last"),
+    run.report ? el("div", { class: "assistant__reply" }, renderMarkdownBlocks(run.report)) : el("p", { class: "flyout__empty" }, "It said nothing."),
+    steps2.length ? el(
+      "details",
+      { class: "agent-run__list" },
+      el(
+        "summary",
+        null,
+        `How it got there, in ${steps2.length} ${steps2.length === 1 ? "step" : "steps"}` + (handoffs ? `, with ${handoffs} ${handoffs === 1 ? "subagent" : "subagents"}` : "")
+      ),
+      runSteps(run, steps2, null, ui2, handlers2)
+    ) : null
+  );
+}
+var NESTING = 4;
+function runSteps(run, steps2, by, ui2, handlers2, depth = 0) {
+  const own = steps2.filter((step) => step.by === by);
+  return el(
+    "ol",
+    { class: "assistant__steps agent-run__steps" },
+    own.length ? null : el("li", { class: "assistant__step assistant__step--message" }, "Nothing yet."),
+    own.map((step, index) => {
+      if (step.kind === "message") {
+        return el("li", { key: index, class: "agent-run__said" }, renderMarkdownBlocks(step.text));
+      }
+      if (step.subagent && depth < NESTING) return runHandoff(run, steps2, step, ui2, handlers2, depth, index);
+      return el(
+        "li",
+        { key: index, class: "assistant__step", "data-state": step.state },
+        el("span", { class: "assistant__step-text" }, step.text),
+        step.detail ? el("code", { class: "assistant__step-detail", title: step.detail }, step.detail) : null
+      );
+    })
+  );
+}
+function runHandoff(run, steps2, step, ui2, handlers2, depth, index) {
+  const id = step.subagent;
+  const own = steps2.filter((candidate) => candidate.by === id);
+  const latest = own.at(-1);
+  const calls = own.filter((candidate) => candidate.kind === "tool").length;
+  const doing = step.state === "running" ? latest ? latest.kind === "message" ? firstLine(latest.text) : latest.text : "starting" : `${calls} ${calls === 1 ? "step" : "steps"}`;
+  const key = `${run.id}:${id}`;
+  const fallback = step.state === "running";
+  const open = ui2.messageOpen.value.has(key) ? ui2.messageOpen.value.get(key) : fallback;
+  return el(
+    "li",
+    { key: index, class: "assistant__step agent-run__handoff", "data-state": step.state },
+    el(
+      "details",
+      {
+        open,
+        // As the message folds do: a toggle back to the default is forgotten.
+        onToggle: (event) => {
+          const isOpen = event.currentTarget.open;
+          handlers2.toggleMessage(key, isOpen === fallback ? null : isOpen);
+        }
+      },
+      el(
+        "summary",
+        null,
+        el("span", { class: "assistant__step-text" }, `Subagent: ${step.detail ?? "unnamed"}`),
+        el("span", { class: "assistant__step-detail" }, doing)
+      ),
+      runSteps(run, steps2, id, ui2, handlers2, depth + 1)
+    )
+  );
+}
+function sameWords(a4, b4) {
+  return a4.replace(/\s+/g, " ").trim() === b4.replace(/\s+/g, " ").trim();
+}
 function runStatus(run, now, handlers2) {
   if (run.status === "running") {
     return el(

package/public/style.css

@@ -541,6 +541,64 @@ body[data-view='tickets'] #brief-refresh {
 .agent-run__message .assistant__reply {
   padding: 0 10px 8px;
 }
+/*
+ * A run's steps, the assistant's look: what it said in its own words between
+ * the calls, and each subagent as a fold under the step that handed it work.
+ */
+.agent-run__list > .agent-run__steps {
+  margin-top: 8px;
+}
+.agent-run__said {
+  margin: 6px 0;
+  font-size: 12.5px;
+  line-height: 1.45;
+  color: var(--ink-1);
+  overflow-wrap: anywhere;
+}
+.agent-run__said:first-child {
+  margin-top: 0;
+}
+.agent-run__said > * {
+  margin: 0;
+}
+.agent-run__said > * + * {
+  margin-top: 5px;
+}
+.agent-run__said ul,
+.agent-run__said ol {
+  padding-left: 18px;
+}
+.agent-run__said pre {
+  white-space: pre-wrap;
+}
+.agent-run__handoff > details {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+/* The spinner stays on the subagent's own line, not in the middle of its open steps. */
+.agent-run__steps > .agent-run__handoff[data-state='running']::before {
+  align-self: flex-start;
+  margin-top: 4px;
+}
+.agent-run__handoff summary {
+  cursor: pointer;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.agent-run__handoff summary:hover {
+  color: var(--ink-1);
+}
+.agent-run__handoff summary .assistant__step-text {
+  font-weight: 600;
+}
+.agent-run__handoff summary .assistant__step-detail {
+  margin-left: 6px;
+  font-size: 12px;
+}
+.agent-run__handoff .agent-run__steps {
+  margin-top: 4px;
+}
 .agent-run__runs {
   margin: 8px 0 0;
   padding: 0;