@lumi.ai/runner 0.5.4 → 0.5.6

package/dist/cli.js

@@ -7,17 +7,17 @@ import { Command } from "commander";
 import os3 from "node:os";
 import {
   collection as collection5,
-  deleteField,
+  deleteField as deleteField2,
   doc as doc7,
   getDoc as getDoc5,
-  getDocs as getDocs3,
+  getDocs as getDocs4,
   onSnapshot as onSnapshot2,
-  orderBy as orderBy3,
-  query as query3,
+  orderBy as orderBy4,
+  query as query4,
   runTransaction as runTransaction2,
   setDoc as setDoc2,
   updateDoc as updateDoc2,
-  where as where3
+  where as where4
 } from "firebase/firestore";
 
 // ../shared/dist/engines/claude.js
@@ -117,6 +117,7 @@ function effectiveAgentTools(agent) {
 }
 
 // ../shared/dist/chat.js
+var MAX_CHAT_MESSAGE_CHARS = 8e3;
 var MAX_CHAT_MESSAGES_IN_PROMPT = 40;
 
 // ../shared/dist/collections.js
@@ -230,6 +231,164 @@ function jobTarget(job) {
   return null;
 }
 
+// ../shared/dist/jobProgress.js
+var MAX_JOB_STEPS = 10;
+var MAX_STEP_LABEL = 80;
+var MAX_STEP_DETAIL = 120;
+function clampStepText(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+}
+function firstLine(text) {
+  return text.split("\n").find((l) => l.trim()) ?? "";
+}
+function str(input, key) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const value = input[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function basename(path5) {
+  const parts = path5.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? path5;
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+var WORKSPACE_PREFIX = "mcp__workspace__";
+var MCP_PREFIX = "mcp__";
+var WORKSPACE_LABELS = {
+  ship_info: "Checking the Ship",
+  agent_list: "Looking up the crew",
+  task_list: "Looking through the board",
+  task_get: "Reading a task",
+  task_create: "Creating a task",
+  task_update_status: "Moving a task",
+  task_assign: "Assigning a task",
+  task_relate: "Linking two tasks",
+  task_comment: "Commenting on a task",
+  approval_request: "Asking for approval",
+  approval_decide: "Answering an approval",
+  run_report: "Writing its run report",
+  knowledge_get: "Reading the knowledge base",
+  knowledge_write: "Writing to the knowledge base",
+  media_get: "Opening an attachment",
+  media_attach: "Attaching a file",
+  memory_write: "Updating its notes",
+  chat_get: "Reading the conversation",
+  chat_send: "Writing its reply"
+};
+var BUILTIN_LABELS = {
+  Bash: "Running a command",
+  Read: "Reading a file",
+  Write: "Writing a file",
+  Edit: "Editing a file",
+  MultiEdit: "Editing a file",
+  Glob: "Looking for files",
+  Grep: "Searching the code",
+  WebSearch: "Searching the web",
+  WebFetch: "Reading a web page",
+  TodoWrite: "Planning its next steps",
+  Task: "Delegating to a sub-agent"
+};
+function workspaceDetail(tool, input) {
+  switch (tool) {
+    case "task_list":
+      return str(input, "status") ?? str(input, "query");
+    case "task_get":
+      return str(input, "taskId");
+    case "task_create":
+      return str(input, "title");
+    case "task_update_status":
+      return str(input, "status");
+    case "task_relate":
+      return str(input, "blockedBy") ? "blocked by" : str(input, "waitingOn") ? "waiting on" : void 0;
+    case "task_comment": {
+      const content = str(input, "content");
+      return content ? firstLine(content) : void 0;
+    }
+    case "approval_request":
+      return str(input, "action") ?? str(input, "summary");
+    case "knowledge_get":
+      return str(input, "slug") ?? str(input, "find") ?? "the catalog";
+    case "knowledge_write":
+      return str(input, "slug");
+    case "media_get":
+      return str(input, "mediaId");
+    case "media_attach":
+      return str(input, "name");
+    default:
+      return void 0;
+  }
+}
+function builtinDetail(tool, input) {
+  switch (tool) {
+    case "Bash":
+      return str(input, "command");
+    case "Read":
+    case "Write":
+    case "Edit":
+    case "MultiEdit": {
+      const path5 = str(input, "file_path");
+      return path5 ? basename(path5) : void 0;
+    }
+    case "Glob":
+    case "Grep":
+      return str(input, "pattern");
+    case "WebSearch":
+      return str(input, "query");
+    case "WebFetch": {
+      const url = str(input, "url");
+      return url ? hostOf(url) || void 0 : void 0;
+    }
+    case "Task":
+      return str(input, "description");
+    default:
+      return void 0;
+  }
+}
+function describeToolUse(name, input, opts) {
+  if (name.startsWith(WORKSPACE_PREFIX)) {
+    const tool = name.slice(WORKSPACE_PREFIX.length);
+    return {
+      kind: "tool",
+      label: WORKSPACE_LABELS[tool] ?? "Working",
+      detail: workspaceDetail(tool, input)
+    };
+  }
+  if (name.startsWith(MCP_PREFIX)) {
+    const rest = name.slice(MCP_PREFIX.length);
+    const split = rest.indexOf("__");
+    const key = split < 0 ? rest : rest.slice(0, split);
+    const tool = split < 0 ? void 0 : rest.slice(split + 2);
+    return {
+      kind: "tool",
+      label: `Using ${opts?.mcpNames?.[key] ?? key}`,
+      detail: tool || void 0
+    };
+  }
+  const label = BUILTIN_LABELS[name];
+  if (label)
+    return { kind: "tool", label, detail: builtinDetail(name, input) };
+  return { kind: "tool", label: "Working" };
+}
+function describeAssistantText(text) {
+  return { kind: "saying", label: "Working it out", detail: firstLine(text) || void 0 };
+}
+function pushJobStep(progress, step, max = MAX_JOB_STEPS) {
+  const steps = [...progress?.steps ?? [], step];
+  return {
+    seq: (progress?.seq ?? 0) + 1,
+    updatedAt: step.at,
+    // Keep the NEWEST `max`, oldest first — a reader renders top to bottom.
+    steps: steps.slice(Math.max(0, steps.length - max))
+  };
+}
+
 // ../shared/dist/knowledge.js
 var KNOWLEDGE_CATALOG_MAX_CHARS = 1500;
 var KNOWLEDGE_CATALOG_SUMMARIES = 8;
@@ -580,7 +739,7 @@ function mcpUrl(config2) {
 }
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.5.4" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.5.6" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -1415,6 +1574,31 @@ import { spawn as spawn3 } from "node:child_process";
 import fs3 from "node:fs";
 import os2 from "node:os";
 import path3 from "node:path";
+
+// src/engines/claudeEvents.ts
+function stepsFromClaudeEvent(event, opts) {
+  const type = typeof event?.type === "string" ? event.type : "";
+  if (type === "assistant") {
+    const message = event.message;
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const steps = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "tool_use" && typeof block.name === "string") {
+        steps.push(describeToolUse(block.name, block.input, { mcpNames: opts?.mcpNames }));
+      } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+        steps.push({ kind: "thinking", label: "Thinking" });
+      } else if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+        steps.push(describeAssistantText(block.text));
+      }
+    }
+    return steps;
+  }
+  if (type === "result") return [{ kind: "done", label: "Finished" }];
+  return [];
+}
+
+// src/engines/claude.ts
 function normalizeClaudeUsage(resultEvent, model, fallbackDurationS) {
   const result = resultEvent ?? {};
   const u = result.usage ?? {};
@@ -1558,6 +1742,8 @@ async function runSession(input, bin, dirs) {
       GIT_CONFIG_VALUE_0: "https://github.com/"
     } : {}
   };
+  const mcpNames = {};
+  for (const s of input.extraMcpServers ?? []) mcpNames[s.key] = s.name || s.key;
   const startedAt = Date.now();
   const lines = [];
   const stderrLines = [];
@@ -1590,6 +1776,9 @@ async function runSession(input, bin, dirs) {
           const event = JSON.parse(line);
           if (event.type === "result") resultEvent = event;
           if (event.type === "assistant") input.log("claude: assistant turn");
+          if (input.onStep) {
+            for (const step of stepsFromClaudeEvent(event, { mcpNames })) input.onStep(step);
+          }
         } catch {
         }
       }
@@ -1863,9 +2052,15 @@ function selectDispatch(input) {
 import {
   addDoc,
   collection as collection4,
+  deleteField,
   doc as doc6,
+  getDocs as getDocs3,
+  limit as fsLimit,
+  orderBy as orderBy3,
+  query as query3,
   runTransaction,
-  updateDoc
+  updateDoc,
+  where as where3
 } from "firebase/firestore";
 import { ref as storageRef, uploadBytes } from "firebase/storage";
 function redactTranscript(transcript, knownSecrets) {
@@ -1909,6 +2104,16 @@ async function finalizeJob(db, shipId, job, input) {
       endedAt: now,
       usage: u,
       transcriptPath: input.transcriptPath,
+      // §15.36. The live strip dies with the run — the transcript is the record, and a settled job
+      // still carrying steps would show a spinner over work that finished.
+      //
+      // `stopRequestedAt` is cleared on EVERY terminal path, including a plain `done`: the marker
+      // is self-consuming (§15.13's `startAt` shape), and leaving one behind on a job that
+      // succeeded anyway is what would let the watchdog's stop branch re-examine settled jobs
+      // forever. Deleting an absent field is not an affected key, so both are legal whether or not
+      // anything ever set them.
+      progress: deleteField(),
+      stopRequestedAt: deleteField(),
       ...input.error ? { error: input.error.slice(0, 1500) } : {},
       // Omitted rather than written empty, so a job that had none looks exactly like every job
       // written before §15.31 — there is nothing to migrate and nothing to read defensively.
@@ -1941,7 +2146,9 @@ async function requeueForRetry(db, shipId, job, error) {
     tx.update(doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id), {
       status: "queued",
       attempt: job.attempt + 1,
-      error: error.slice(0, 1500)
+      error: error.slice(0, 1500),
+      // The steps describe an attempt that is over; the next one starts its own stream.
+      progress: deleteField()
     });
   });
 }
@@ -1950,7 +2157,15 @@ async function releaseJob(db, shipId, job, reason) {
     status: "queued",
     runnerId: "",
     startedAt: 0,
-    error: reason.slice(0, 1500)
+    error: reason.slice(0, 1500),
+    // §15.36: cleared here too, not only on the terminal paths. A released job sits `queued`
+    // waiting to be re-claimed, and steps left behind would show a live-looking strip describing a
+    // session that is no longer running anywhere.
+    //
+    // `stopRequestedAt` deliberately SURVIVES a release. The job goes back on the queue still
+    // carrying the request, so whichever daemon claims it next honours the stop instead of running
+    // work somebody already asked to end.
+    progress: deleteField()
   });
 }
 async function markTaskFailed(db, shipId, job, error, statuses) {
@@ -1973,6 +2188,25 @@ ${error.slice(0, 800)}
     });
   });
 }
+async function markTaskStopped(db, shipId, job, stoppedBy) {
+  const taskRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.tasks, job.taskId);
+  await addDoc(collection4(taskRef, COLLECTIONS.activity), {
+    author: { type: "agent", id: job.agentId },
+    createdAt: Date.now(),
+    kind: "comment",
+    content: `This run was stopped by ${stoppedBy} before it finished. The task is unchanged.`
+  });
+}
+async function markChatStopped(db, shipId, job, stoppedBy) {
+  const chatRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.chats, job.chatId);
+  const content = `Stopped by ${stoppedBy} before I finished. Write again to start a fresh run.`;
+  await addDoc(collection4(chatRef, COLLECTIONS.chatMessages), {
+    author: { type: "agent", id: job.agentId },
+    content,
+    chars: content.length,
+    createdAt: Date.now()
+  });
+}
 async function markChatFailed(db, shipId, job, error) {
   const shipRef = doc6(db, COLLECTIONS.ships, shipId);
   const chatRef = doc6(shipRef, COLLECTIONS.chats, job.chatId);
@@ -1991,12 +2225,132 @@ Write again to start a fresh run.`;
     createdAt: now
   });
 }
+var REPLY_SCAN_LIMIT = 20;
+function backstopReplyContent(resultText) {
+  const text = resultText.trim();
+  if (!text) {
+    return "I finished that run without writing a reply. Write again to start a fresh one.";
+  }
+  if (text.length <= MAX_CHAT_MESSAGE_CHARS) return text;
+  const marker = "\n\n\u2026(truncated)";
+  return `${text.slice(0, MAX_CHAT_MESSAGE_CHARS - marker.length)}${marker}`;
+}
+async function ensureChatReply(db, shipId, job, resultText) {
+  const chatRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.chats, job.chatId);
+  const messagesCol = collection4(chatRef, COLLECTIONS.chatMessages);
+  const snap = await getDocs3(
+    query3(
+      messagesCol,
+      where3("createdAt", ">=", job.startedAt || 0),
+      orderBy3("createdAt", "desc"),
+      fsLimit(REPLY_SCAN_LIMIT)
+    )
+  );
+  const replied = snap.docs.some((d) => {
+    const author = d.data().author;
+    return author?.type === "agent" && author.id === job.agentId;
+  });
+  if (replied) return "agent-replied";
+  const content = backstopReplyContent(resultText);
+  await addDoc(messagesCol, {
+    author: { type: "agent", id: job.agentId },
+    content,
+    chars: content.length,
+    createdAt: Date.now()
+  });
+  return resultText.trim() ? "posted-final-text" : "posted-silence-note";
+}
+
+// src/jobs/progress.ts
+var PROGRESS_FLUSH_MS = 3e3;
+var PROGRESS_DENIALS_BEFORE_PROBE = 2;
+function redactStep(step, secrets) {
+  const label = clampStepText(redactTranscript(step.label, secrets), MAX_STEP_LABEL);
+  if (step.detail === void 0) return { ...step, label };
+  const detail = clampStepText(redactTranscript(step.detail, secrets), MAX_STEP_DETAIL);
+  return detail ? { ...step, label, detail } : { at: step.at, kind: step.kind, label };
+}
+function isDenied(error) {
+  const code = error?.code ?? "";
+  return code === "permission-denied" || code.endsWith("/permission-denied");
+}
+function createProgressWriter(deps) {
+  const now = deps.now ?? Date.now;
+  const flushMs = deps.flushMs ?? PROGRESS_FLUSH_MS;
+  let progress;
+  let pending = [];
+  let timer = null;
+  let lastWriteAt = 0;
+  let inFlight = false;
+  let denials = 0;
+  let closed = false;
+  let loggedFailure = false;
+  function flush() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (closed || inFlight || pending.length === 0) return;
+    const secrets = deps.secrets();
+    for (const step of pending) progress = pushJobStep(progress, redactStep(step, secrets));
+    pending = [];
+    lastWriteAt = now();
+    inFlight = true;
+    const snapshot = progress;
+    void deps.write(snapshot).then(() => {
+      denials = 0;
+    }).catch((e) => {
+      if (isDenied(e)) {
+        denials += 1;
+        if (denials >= PROGRESS_DENIALS_BEFORE_PROBE) {
+          closed = true;
+          deps.onDenied();
+        }
+        return;
+      }
+      denials = 0;
+      if (!loggedFailure) {
+        loggedFailure = true;
+        deps.log(`progress write failed (further ones silent): ${e instanceof Error ? e.message : e}`);
+      }
+    }).finally(() => {
+      inFlight = false;
+      if (pending.length > 0 && !closed) schedule();
+    });
+  }
+  function schedule() {
+    if (closed || timer) return;
+    const due = lastWriteAt + flushMs - now();
+    if (due <= 0 && !inFlight) {
+      flush();
+      return;
+    }
+    timer = setTimeout(flush, Math.max(due, 0));
+    timer.unref?.();
+  }
+  return {
+    push(step) {
+      if (closed) return;
+      pending.push({ ...step, at: now() });
+      schedule();
+    },
+    stop() {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      pending = [];
+    }
+  };
+}
 
 // src/daemon.ts
 var HEARTBEAT_MS = 3e4;
 var JOB_TIMEOUT_MS = 20 * 60 * 1e3;
 var MAX_ATTEMPTS = 2;
 var SHUTDOWN_GRACE_MS = 1e4;
+var STOP_POLL_MS = 5e3;
 async function startDaemon() {
   const moved = migrateLegacyDir();
   let config2 = requireConfig();
@@ -2110,11 +2464,11 @@ async function startDaemon() {
       needsRefill.delete(shipId);
       if (!serving.has(shipId) || approved.get(shipId) !== true) continue;
       try {
-        const snap = await getDocs3(
-          query3(
+        const snap = await getDocs4(
+          query4(
             collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
-            where3("status", "==", "queued"),
-            orderBy3("createdAt", "asc")
+            where4("status", "==", "queued"),
+            orderBy4("createdAt", "asc")
           )
         );
         for (const d of snap.docs) {
@@ -2142,10 +2496,10 @@ async function startDaemon() {
     console.error(`${what} listener error (${shipId}):`, e.message);
   };
   for (const shipId of serving) {
-    const q = query3(
+    const q = query4(
       collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
-      where3("status", "==", "queued"),
-      orderBy3("createdAt", "asc")
+      where4("status", "==", "queued"),
+      orderBy4("createdAt", "asc")
     );
     unsubsByShip.set(shipId, [
       onSnapshot2(
@@ -2383,6 +2737,23 @@ async function startDaemon() {
       ...job.workflowName ? { workflowName: job.workflowName } : {},
       startedAt: Date.now()
     };
+    const stopPoll = setInterval(() => {
+      void (async () => {
+        if (slot.stop) return;
+        try {
+          const snap = await getDoc5(
+            doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
+          );
+          const fresh = snap.data();
+          if (!fresh?.stopRequestedAt || slot.stop) return;
+          slot.stop = { at: fresh.stopRequestedAt, by: fresh.stopRequestedBy?.id ?? "someone" };
+          log2(`Job ${job.id}: stop requested \u2014 ending the session.`);
+          slot.abort.abort();
+        } catch {
+        }
+      })();
+    }, STOP_POLL_MS);
+    stopPoll.unref();
     await setAgentStatus(shipId, job.agentId, "working");
     void heartbeat();
     const wake = config2.keepAwake === false ? null : inhibitSleep(`Crew job ${job.id}`);
@@ -2396,6 +2767,7 @@ async function startDaemon() {
     let sessionLimit = null;
     let engineId = DEFAULT_ENGINE_ID;
     let transcript = "";
+    let resultText = "";
     let usage = {
       engine: DEFAULT_ENGINE_ID,
       inputTokens: 0,
@@ -2408,6 +2780,37 @@ async function startDaemon() {
     let githubToken;
     let extraMcpServers = [];
     let statuses = DEFAULT_TASK_STATUSES;
+    let knownSecrets = [];
+    const progress = createProgressWriter({
+      write: (p) => updateDoc2(doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id), {
+        progress: p
+      }),
+      secrets: () => knownSecrets,
+      // Two consecutive DENIALS mean this job is no longer ours to write — a force-stop took it, or
+      // the machine was revoked. The §15.30 door: the news arrives as `permission-denied`.
+      //
+      // A PROBE RATHER THAN A BARE ABORT, and it is not optional. If a deploy lands the daemon
+      // before the rules, every progress write is denied on a perfectly healthy job, and aborting
+      // on that signal alone would kill live work for the length of the rollout. One read settles
+      // which of the two it is.
+      onDenied: () => {
+        void (async () => {
+          try {
+            const snap = await getDoc5(
+              doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
+            );
+            const fresh = snap.data();
+            if (!fresh || fresh.status !== "running" || fresh.runnerId !== config2.runnerId) {
+              log2(`Job ${job.id} is no longer this machine's to run \u2014 ending the session.`);
+              slot.abort.abort();
+            }
+          } catch {
+          }
+        })();
+      },
+      log: log2
+    });
+    progress.push({ kind: "start", label: "Starting up" });
     try {
       const secrets = await loadSecrets(shipId);
       const packed = target.kind === "chat" ? { kind: "chat", ctx: await loadChatContext(sess(shipId).fb.db, shipId, { ...job, chatId: target.chatId }) } : { kind: "task", ctx: await loadJobContext(sess(shipId).fb.db, shipId, { ...job, taskId: target.taskId }) };
@@ -2461,6 +2864,15 @@ async function startDaemon() {
         throw e;
       }
       if (slot.abort.signal.aborted) throw new Error("Stopped before the session started.");
+      knownSecrets = [
+        idToken,
+        secrets?.claudeToken,
+        githubToken,
+        secrets?.githubPat,
+        // §15.31. BOTH the composed header value and the bare credential — see
+        // `mcpSecretsToRedact` for why one of them is not enough.
+        ...mcpSecretsToRedact(extraMcpServers)
+      ];
       const session = await getDriver(engineId).run({
         prompt,
         agent,
@@ -2473,17 +2885,13 @@ async function startDaemon() {
         githubToken,
         timeoutMs: JOB_TIMEOUT_MS,
         signal: slot.abort.signal,
-        log: log2
+        log: log2,
+        // §15.36. The driver emits Crew's step vocabulary; the writer coalesces, redacts and
+        // persists. A throw here must never reach the driver's stdout loop, which is why `push`
+        // swallows everything.
+        onStep: (step) => progress.push(step)
       });
-      transcript = redactTranscript(session.transcript, [
-        idToken,
-        secrets?.claudeToken,
-        githubToken,
-        secrets?.githubPat,
-        // §15.31. BOTH the composed header value and the bare credential — see
-        // `mcpSecretsToRedact` for why one of them is not enough.
-        ...mcpSecretsToRedact(extraMcpServers)
-      ]);
+      transcript = redactTranscript(session.transcript, knownSecrets);
       usage = session.usage;
       if (session.limit && getEngine(engineId).usageWindows) {
         sessionLimit = session.limit;
@@ -2496,17 +2904,36 @@ async function startDaemon() {
         });
         armLimitTimer();
       }
+      resultText = session.resultText;
       if (!session.ok) failure = session.resultText || "Session failed.";
     } catch (e) {
       failure = e instanceof Error ? e.message : String(e);
       transient = isTransientFirestoreError(e);
     }
     wake?.release();
+    progress.stop();
+    clearInterval(stopPoll);
     try {
       if (!serving.has(shipId)) {
         log2(
           `Job ${job.id} stopped \u2014 Ship ${shipId} removed this machine mid-run. The Ship has put the job back on its own queue; nothing more is written from here.`
         );
+      } else if (slot.stop && failure) {
+        const transcriptPath = transcript ? await uploadTranscript(sess(shipId).fb.storage, shipId, job.id, transcript) : "";
+        await finalizeJob(sess(shipId).fb.db, shipId, job, {
+          status: "stopped",
+          usage,
+          transcriptPath,
+          mcpServers: extraMcpServers.map((s) => s.key)
+        });
+        const by = slot.stop.by;
+        if (target.kind === "chat") {
+          await markChatStopped(sess(shipId).fb.db, shipId, { ...job, chatId: target.chatId }, by);
+        } else {
+          await markTaskStopped(sess(shipId).fb.db, shipId, { ...job, taskId: target.taskId }, by);
+        }
+        log2(`Job ${job.id} STOPPED by ${by} (attempt ${job.attempt}).`);
+        notify("Crew job stopped", `${targetLabel} was stopped before it finished.`);
       } else if (shuttingDown) {
         await releaseJob(
           sess(shipId).fb.db,
@@ -2541,9 +2968,33 @@ async function startDaemon() {
           mcpServers: extraMcpServers.map((s) => s.key)
         });
         log2(`Job ${job.id} done (${usage.inputTokens}in/${usage.outputTokens}out tokens).`);
+        let delivery = "agent-replied";
+        if (target.kind === "chat") {
+          try {
+            delivery = await ensureChatReply(
+              sess(shipId).fb.db,
+              shipId,
+              { ...job, chatId: target.chatId },
+              resultText
+            );
+            if (delivery === "posted-final-text") {
+              log2(
+                `Job ${job.id}: the agent never called chat_send \u2014 posted its final text to chat ${target.chatId} instead.`
+              );
+            } else if (delivery === "posted-silence-note") {
+              log2(
+                `Job ${job.id}: the agent neither called chat_send nor produced any text \u2014 posted a note to chat ${target.chatId} so the thread is not silent.`
+              );
+            }
+          } catch (e) {
+            log2(
+              `Job ${job.id}: could not check whether the agent replied in chat ${target.chatId} \u2014 ${e instanceof Error ? e.message : e}`
+            );
+          }
+        }
         notify(
           "Crew job finished",
-          target.kind === "task" ? `Task ${target.taskId} is done.` : "Agent replied in a chat."
+          target.kind === "task" ? `Task ${target.taskId} is done.` : delivery === "agent-replied" ? "Agent replied in a chat." : "Agent finished a chat run without replying \u2014 its answer was posted for it."
         );
       } else if (transient) {
         await releaseJob(
@@ -2623,8 +3074,8 @@ async function startDaemon() {
           {
             status: "offline",
             lastSeenAt: now,
-            currentJob: deleteField(),
-            currentJobs: deleteField()
+            currentJob: deleteField2(),
+            currentJobs: deleteField2()
           },
           { merge: true }
         );
@@ -2884,7 +3335,7 @@ function setParallel(config2, value, ship2) {
 
 // src/cli/commands/doctor.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { collection as collection6, doc as doc8, getDoc as getDoc6, getDocs as getDocs4 } from "firebase/firestore";
+import { collection as collection6, doc as doc8, getDoc as getDoc6, getDocs as getDocs5 } from "firebase/firestore";
 
 // src/service.ts
 import { spawnSync } from "node:child_process";
@@ -3099,10 +3550,10 @@ function serviceStatus() {
     };
   }
   if (process.platform === "win32") {
-    const query5 = run("schtasks", ["/Query", "/TN", WINDOWS_TASK]);
-    if (!query5.ok) return { state: "not-installed", detail: "No scheduled task installed." };
+    const query6 = run("schtasks", ["/Query", "/TN", WINDOWS_TASK]);
+    if (!query6.ok) return { state: "not-installed", detail: "No scheduled task installed." };
     return {
-      state: /\bRunning\b/i.test(query5.out) ? "running" : "installed",
+      state: /\bRunning\b/i.test(query6.out) ? "running" : "installed",
       detail: "Scheduled task installed (runs at logon).",
       unitPath: WINDOWS_TASK
     };
@@ -3339,7 +3790,7 @@ async function checkShips(config2) {
     }
     let agents = [];
     try {
-      const snap = await getDocs4(collection6(fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.agents));
+      const snap = await getDocs5(collection6(fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.agents));
       agents = snap.docs.map((d) => ({ id: d.id, ...d.data() }));
     } catch {
     }
@@ -3864,9 +4315,9 @@ import {
   doc as doc10,
   getCountFromServer as getCountFromServer2,
   getDoc as getDoc8,
-  getDocs as getDocs5,
-  query as query4,
-  where as where4
+  getDocs as getDocs6,
+  query as query5,
+  where as where5
 } from "firebase/firestore";
 async function runStatus() {
   const config2 = loadConfig();
@@ -3906,7 +4357,7 @@ async function runStatus() {
     let queued = 0;
     try {
       const counted = await getCountFromServer2(
-        query4(collection7(shipRef, COLLECTIONS.jobs), where4("status", "==", "queued"))
+        query5(collection7(shipRef, COLLECTIONS.jobs), where5("status", "==", "queued"))
       );
       queued = counted.data().count;
     } catch {
@@ -3915,7 +4366,7 @@ async function runStatus() {
     const usageSnap = await getDoc8(doc10(shipRef, COLLECTIONS.usageDaily, utcDay(Date.now())));
     const today = { ...EMPTY_USAGE_TOTALS, ...usageSnap.data()?.totals ?? {} };
     const now = Date.now();
-    const limitsSnap = await getDocs5(collection7(shipRef, COLLECTIONS.engineLimits));
+    const limitsSnap = await getDocs6(collection7(shipRef, COLLECTIONS.engineLimits));
     const engineLimits = limitsSnap.docs.map((d) => ({ id: d.id, ...d.data() })).filter((l) => isEngineLimited(l, now));
     ships.push({
       shipId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi.ai/runner",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "type": "module",
   "description": "Lumi Crew runner daemon — claims jobs from your Ships and executes them as headless Claude sessions on your own machine.",
   "//name": "The ONLY package in this monorepo published to the public registry, so it is the one that does not follow the internal @lumi/crew-* convention: `@lumi` is not a scope we own, `@lumi.ai` is (the npm org). The workspace DIRECTORY stays packages/crew/runner — renaming the package is not renaming the folder.",