@wirecat/cli-core 0.551.0 → 0.553.0

package/dist/cli/messenger/projects-command.js

@@ -3,6 +3,7 @@ import { annotate, annotateOption } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { FETCHING } from "../../services/archive.js";
+import { BUILT_IN_PURPOSES, purposeList } from "../../services/project-purposes.js";
 import { projectStatus, STATUS_SIGNALS } from "../../services/project-status/index.js";
 import { gatherStoredProject } from "../../services/stored-project-gathering.js";
 import { answerEntity } from "../answer-entity.js";
@@ -61,6 +62,8 @@ const archiveFetcher = (withServices, messenger) => {
         },
     };
 };
+const purposeHelp = (messenger) => `the linked chats' purposes to read, comma separated (${(messenger.purposes?.purposes ?? BUILT_IN_PURPOSES).join(", ")}), ` +
+    "or all; the configured defaults if not given, and a chat left out is counted, never dropped silently";
 /** Off MCP: a tool call ends at about a minute, too soon for a sync, which would fail the whole answer. */
 const cliOnly = (flags, description, value) => {
     const option = new Option(flags, description);
@@ -88,6 +91,8 @@ export const projectsCommand = (messenger) => {
         .option("--alias <name>", "another name of the project, searched on its own; repeat for more", collect, [])
         .option("--context-query <words>", "more words that all appear in one text; repeat for another", collect, [])
         .option("--contact <person>", "a name to search, or person:<id> to read what that person wrote", collect, [])
+        .option("--purpose <purposes>", purposeHelp(messenger), purposeList, [])
+        .option("--include-proposed", "also read chats and members proposed for the project and not yet confirmed; each item they bring is marked")
         .option("--since-time <time>", "how far back: days (90d, at most 730d) or a start date (2026-09-01)", "60d")
         .option("--before-time <time>", "fixed exclusive end: ISO 8601 timestamp with UTC offset")
         .option("--limit <n>", "new references at most, up to 500; 100 if not given", positiveCount("--limit"))
@@ -116,20 +121,31 @@ export const projectsCommand = (messenger) => {
             ...(options.contact.length ? { people: options.contact } : {}),
             ...(options.maxPages === undefined ? {} : { maxReads: options.maxPages }),
             ...(options.cursor === undefined ? {} : { checkpoint: options.cursor }),
+            ...(options.purpose.length ? { purposes: options.purpose } : {}),
+            ...(messenger.purposes ? { purposeConfig: messenger.purposes } : {}),
+            ...(options.includeProposed ? { includeProposed: true } : {}),
             ...(fetcher ? { fetcher, maxFetchMs, onFetchProgress: progressNote(context.renderer.note) } : {}),
         }));
         const fetcher = options.syncFirst
             ? archiveFetcher((work) => context.withServices(work, { name: "projects evidence fetch" }), messenger)
             : undefined;
-        const found = await context.withStore((store, account) => gather(store, account, fetcher));
-        const parts = projectAnswerParts(options.sinceTime, found);
+        let profile;
+        const found = await context.withStore((store, account) => {
+            profile = account;
+            return gather(store, account, fetcher);
+        });
+        const root = rootOf(this);
         const hints = {
             sync: (one, since) => one.provider === messenger.provider
                 ? lineOf(this, `projects evidence ${quote(project)} --since-time ${since} --sync-first`)
                 : null,
+            read: (one, since) => one.provider === profile?.provider && one.account === profile.account
+                ? lineOf(this, wordsOf(root, readStep(one.chat, since)))
+                : null,
             showDocument: "the notes app that imported it",
         };
-        renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync)), parts), () => projectEvidenceText(found, hints));
+        const parts = projectAnswerParts(options.sinceTime, found, hints);
+        renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync, hints.read)), parts), () => projectEvidenceText(found, hints));
     }));
     projects.addCommand(statusCommand(messenger));
     return projects;
@@ -149,26 +165,37 @@ const statusCommand = (messenger) => answerEntity(annotate(new Command("status")
     .argument("<project>", "an existing project's id, key, exact name or alias")
     .option("--since-time <time>", "how far back: days (60d, at most 730d) or a start date (2026-09-01)", "60d")
     .option("--before-time <time>", "fixed exclusive end: ISO 8601 timestamp with UTC offset")
+    .option("--purpose <purposes>", purposeHelp(messenger), purposeList, [])
     .option("--context-query <words>", "words that all appear in one text; reports their last mention per side. Repeat for another", collect, [])
     .action(async function (project) {
     const options = this.opts();
     const context = messengerContext(this, messenger);
-    const found = await context.withStore((store, account) => projectStatus(store, {
-        project,
-        accounts: [account],
-        ...projectWindowOf(options.sinceTime),
-        ...(options.beforeTime === undefined ? {} : { asOf: projectCutoffTime(options.beforeTime) }),
-        contextQueries: options.contextQuery,
-    }));
+    let profile;
+    const found = await context.withStore((store, account) => {
+        profile = account;
+        return projectStatus(store, {
+            project,
+            accounts: [account],
+            ...projectWindowOf(options.sinceTime),
+            ...(options.beforeTime === undefined ? {} : { asOf: projectCutoffTime(options.beforeTime) }),
+            contextQueries: options.contextQuery,
+            ...(options.purpose.length ? { purposes: options.purpose } : {}),
+            ...(messenger.purposes ? { purposeConfig: messenger.purposes } : {}),
+        });
+    });
     const root = rootOf(this);
     const hints = {
         sync: (chat, since) => nextStep("messages.sync", { args: { chat: chat.chatId, since_time: since } }),
-        read: (chat, since) => nextStep("messages.list", { args: { chat: chat.chatId, query: `date>=${since}` } }),
+        read: (chat, since) => readStep(chat.chatId, since),
+        readChat: (chat, since) => chat.account.provider === profile?.provider && chat.account.account === profile.account
+            ? readStep(chat.chatId, since)
+            : null,
         line: (step) => (step.kind === "command" ? lineOf(this, wordsOf(root, step)) : step.why),
     };
     const { item, ...parts } = projectStatusAnswer(found, hints);
     renderAnswer(this, context, itemOf(item, parts), () => projectStatusText(found, hints));
 }), "project_status", projectStatusSchema, { row: projectStatusRow(STATUS_SIGNALS) });
+const readStep = (chat, since) => nextStep("messages.list", { args: { chat, query: `date>=${since}` } });
 /** A step's words after the tool and the profile, so `lineOf` names the profile the run used. */
 const wordsOf = (root, step) => {
     const profile = root.getOptionValue("profile");

package/dist/cli/messenger/search-answers.js

@@ -293,7 +293,14 @@ export const allHitItem = (item) => item.kind === "meeting"
         offset_ms: item.startMs,
         scope: item.scope,
         id: String(item.id),
-        ...(item.cueRef === undefined ? {} : { cue_ref: item.cueRef, sender_name: item.speakerName ?? null }),
+        ...(item.cueRef === undefined
+            ? {}
+            : {
+                cue_ref: item.cueRef,
+                sender_name: item.speakerName ?? null,
+                language: item.language ?? null,
+                ...(item.line === undefined ? {} : { line: item.line, lines_total: item.linesTotal }),
+            }),
         untrusted: ALL_HIT_UNTRUSTED.meeting,
     }
     : defined({

package/dist/cli/messenger/serve-catch-up.d.ts

@@ -0,0 +1,43 @@
+import type { Chat } from "../../domain/models.js";
+import type { ServeNotice } from "./serve-notice.js";
+/** The provider's own catch-up lands first; this pass then finds most chats already current. */
+export declare const START_SYNC_DELAY_MS = 30000;
+export declare const START_SYNC_BUDGET_MS: number;
+/** A longer downtime is `messages sync --all`'s job, not a start's. */
+export declare const START_SYNC_WINDOW_MS: number;
+export declare const START_SYNC_PER_CHAT = 500;
+export interface StartSyncSummary {
+    chats: number;
+    fetched: number;
+    failed: number;
+    stopped: boolean;
+}
+export interface StartSync {
+    /** Runs the pass once, after the delay; a second call is ignored. */
+    start(): void;
+    /** Aborts the pass and waits for it, which stops before its next request. */
+    stop(): Promise<void>;
+    summary(): StartSyncSummary | undefined;
+}
+/**
+ * `serve`'s one pass on start over the chats that moved while nothing listened. A provider's own
+ * catch-up drops a gap it finds too long (Telegram's `differenceTooLong`, `channelDifferenceTooLong`
+ * past 100 updates), so each chat whose newest message is newer than the newest one held is read back
+ * to that one. A chat never held is read back to the newest message held anywhere, which is about when
+ * the last serve stopped. Bounded by a window, a per-chat limit and a time budget; an empty store is
+ * left to `messages sync --all`.
+ */
+export declare const startSync: ({ chats, newestHeld, fetch, note, warn, delayMs, budgetMs, windowMs, now, }: {
+    chats: (stop: AbortSignal) => Promise<Chat[]>;
+    /** The newest message held from before this serve started, epoch milliseconds. */
+    newestHeld: (chatId: string) => Promise<number | undefined>;
+    fetch: (chatId: string, sinceMs: number, stop: AbortSignal) => Promise<{
+        fetched: number;
+    }>;
+    note: (notice: ServeNotice) => void;
+    warn: (notice: ServeNotice) => void;
+    delayMs?: number;
+    budgetMs?: number;
+    windowMs?: number;
+    now?: () => number;
+}) => StartSync;

package/dist/cli/messenger/serve-catch-up.js

@@ -0,0 +1,90 @@
+import { failureKey } from "../../errors/failures.js";
+/** The provider's own catch-up lands first; this pass then finds most chats already current. */
+export const START_SYNC_DELAY_MS = 30_000;
+export const START_SYNC_BUDGET_MS = 5 * 60_000;
+/** A longer downtime is `messages sync --all`'s job, not a start's. */
+export const START_SYNC_WINDOW_MS = 7 * 86_400_000;
+export const START_SYNC_PER_CHAT = 500;
+/**
+ * `serve`'s one pass on start over the chats that moved while nothing listened. A provider's own
+ * catch-up drops a gap it finds too long (Telegram's `differenceTooLong`, `channelDifferenceTooLong`
+ * past 100 updates), so each chat whose newest message is newer than the newest one held is read back
+ * to that one. A chat never held is read back to the newest message held anywhere, which is about when
+ * the last serve stopped. Bounded by a window, a per-chat limit and a time budget; an empty store is
+ * left to `messages sync --all`.
+ */
+export const startSync = ({ chats, newestHeld, fetch, note, warn, delayMs = START_SYNC_DELAY_MS, budgetMs = START_SYNC_BUDGET_MS, windowMs = START_SYNC_WINDOW_MS, now = Date.now, }) => {
+    const controller = new AbortController();
+    let timer;
+    let pass = Promise.resolve();
+    let started = false;
+    let done;
+    const run = async () => {
+        const stop = AbortSignal.any([controller.signal, AbortSignal.timeout(budgetMs)]);
+        const floor = now() - windowMs;
+        const moved = [];
+        for (const chat of await chats(stop)) {
+            const lastAt = Date.parse(chat.lastMessageAt ?? "");
+            if (Number.isNaN(lastAt) || lastAt < floor)
+                continue;
+            moved.push({ chat, lastAt, held: await newestHeld(chat.id) });
+        }
+        const anywhere = moved.reduce((top, { held }) => (held === undefined ? top : Math.max(top, held)), -Infinity);
+        if (!Number.isFinite(anywhere))
+            return;
+        const behind = moved
+            .filter(({ lastAt, held }) => lastAt > (held ?? anywhere))
+            .sort((one, other) => other.lastAt - one.lastAt);
+        if (behind.length === 0)
+            return;
+        const summary = { chats: 0, fetched: 0, failed: 0, stopped: false };
+        done = summary;
+        for (const { chat, held } of behind) {
+            if (stop.aborted)
+                break;
+            try {
+                summary.fetched += (await fetch(chat.id, Math.max(held ?? anywhere, floor), stop)).fetched;
+                summary.chats += 1;
+            }
+            catch (error) {
+                if (stop.aborted)
+                    break;
+                summary.failed += 1;
+                const errorCode = failureKey(error);
+                warn({
+                    code: "start_sync_chat_failed",
+                    chatId: chat.id,
+                    errorCode,
+                    text: `what ${chat.id} received while serve was down was not fetched: ${errorCode}`,
+                });
+            }
+        }
+        summary.stopped = stop.aborted && summary.chats + summary.failed < behind.length;
+        note({
+            code: "start_sync",
+            text: `caught up ${summary.fetched} message(s) in ${summary.chats} chat(s) that moved while serve was down` +
+                (summary.stopped ? ` — stopped at the time limit, ${behind.length - summary.chats - summary.failed} left` : ""),
+        });
+    };
+    return {
+        start: () => {
+            if (started || controller.signal.aborted)
+                return;
+            started = true;
+            timer = setTimeout(() => {
+                pass = run().catch((error) => {
+                    if (controller.signal.aborted)
+                        return;
+                    const errorCode = failureKey(error);
+                    warn({ code: "start_sync_failed", errorCode, text: `the catch-up on start failed: ${errorCode}` });
+                });
+            }, delayMs);
+        },
+        stop: async () => {
+            controller.abort();
+            clearTimeout(timer);
+            await pass;
+        },
+        summary: () => done,
+    };
+};

package/dist/cli/messenger/serve-command.js

@@ -2,7 +2,9 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { holdLock, lockPath, releaseLock, takeLock } from "../../background/lock.js";
+import { parseDuration } from "../../domain/duration.js";
 import { failureKey } from "../../errors/failures.js";
+import { capability } from "../../ports/messenger.js";
 import { senderFacts } from "../../replies/dry-run.js";
 import { replyRenderer } from "../../replies/rendering.js";
 import { audienceWarnings, readReplies, repliesPathFor } from "../../replies/rules.js";
@@ -10,14 +12,17 @@ import { NO_RULES, replyTo } from "../../replies/serve.js";
 import { repliesStatePathFor } from "../../replies/state.js";
 import { levelFor } from "../../sends/permissions.js";
 import { newSendId } from "../../sends/send-id.js";
+import { FETCHING } from "../../services/archive.js";
 import { onlineDeps } from "../../services/deps.js";
 import { servicesFor } from "../../services/index.js";
+import { patiently } from "../../services/patience.js";
 import { applyTaskRulesOnArrival, openRequestTask } from "../../services/task-rules.js";
 import { environmentOf } from "../context.js";
 import { REMOTE_WRITE } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
+import { START_SYNC_PER_CHAT, startSync } from "./serve-catch-up.js";
 import { memberFetches } from "./serve-members.js";
 import { noticeFor, recordDiagnostics } from "./serve-notice.js";
 import { serveRelay } from "./serve-relay.js";
@@ -75,7 +80,7 @@ export const serveCommand = (messenger) => {
         const counts = {};
         const rules = replying(context, messenger, Date.parse(startedAt));
         const tasks = tasking(context, warn);
-        const { handled } = environmentOf(this);
+        const { handled, startSyncDelayMs } = environmentOf(this);
         const count = (event) => {
             counts[event.event] = (counts[event.event] ?? 0) + 1;
             if (event.event === "message") {
@@ -99,6 +104,50 @@ export const serveCommand = (messenger) => {
             }).chats.fetchMembers(chatId, {}),
             warn,
         });
+        const fetching = messenger.fetching ?? FETCHING;
+        const catchingUp = startSync({
+            chats: async (stop) => {
+                const list = capability(connection, "chats", "list its chats");
+                const all = [];
+                for (let offset = 0;;) {
+                    const page = await patiently(() => list({ offset, limit: 100 }), context.renderer.note, stop);
+                    for (const chat of page.items)
+                        all.push(chat);
+                    offset += page.items.length;
+                    if (!page.hasMore || page.items.length === 0)
+                        return all;
+                }
+            },
+            newestHeld: (chatId) => context.withStore(async (store, account) => {
+                // What this serve stored itself would hide the gap before it.
+                const [newest] = await store.messages.messagesWindow(account, chatId, {
+                    at: startedAt,
+                    before: 1,
+                    after: 0,
+                });
+                return newest ? Date.parse(newest.timestamp) : undefined;
+            }, { name: "serve catch-up" }),
+            fetch: (chatId, sinceMs, stop) => context.withStore((store, account) => servicesFor({
+                ...onlineDeps(messenger, connection, context.guard, {
+                    profile: context.profile,
+                    env: context.env,
+                }),
+                store: async () => store,
+                account: async () => account,
+            }).archive.fetch(chatId, {
+                limit: START_SYNC_PER_CHAT,
+                pageSize: fetching.page,
+                pauseMs: parseDuration(fetching.pause, "pause"),
+                sinceMs,
+                catchUp: false,
+                note: context.renderer.note,
+                stop,
+                onPage: () => { },
+            }), { name: "serve catch-up" }),
+            note,
+            warn,
+            ...(startSyncDelayMs === undefined ? {} : { delayMs: startSyncDelayMs }),
+        });
         const stems = stemFills({
             withStore: (work) => context.withStore((store) => work(store), { name: "serve stems" }),
             warn,
@@ -113,6 +162,8 @@ export const serveCommand = (messenger) => {
                     rules.connected(open);
                     members.start();
                     stems.start();
+                    if (messenger.history !== "store" && typeof open.chats === "function")
+                        catchingUp.start();
                 },
             });
         }
@@ -120,6 +171,7 @@ export const serveCommand = (messenger) => {
             await relaying;
             await relay?.close();
             rules.stop();
+            await catchingUp.stop();
             await members.stop();
             await stems.stop();
             await rules.settled();
@@ -135,6 +187,7 @@ export const serveCommand = (messenger) => {
             ...rules.summary(),
             ...(members.summary().fetched + members.summary().failed > 0 ? { members: members.summary() } : {}),
             ...(stems.summary().stemmed > 0 ? { stems: stems.summary() } : {}),
+            ...(catchingUp.summary() ? { caught_up: catchingUp.summary() } : {}),
             ...tasks.summary(),
         }));
     });

package/dist/cli/messenger/serve-relay.d.ts

@@ -41,6 +41,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         resolveSettings: (flags: import("../settings.js").GlobalFlags, options?: import("../settings.js").ResolveOptions) => import("../settings.js").Settings;
         profileState?: (profile: string, env: NodeJS.ProcessEnv) => import("./context.js").ProfileState;
         chatArgument: string;
+        purposes?: import("../../services/project-purposes.js").PurposeConfig;
         groupSettings?: readonly import("../../domain/models.js").GroupSettingKey[];
         pollQuiz?: boolean;
         pollCloseSeconds?: readonly [min: number, max: number];

package/dist/cli/messenger/server-command.d.ts

@@ -35,8 +35,9 @@ export interface ServerOptions {
 /**
  * `serve` in the background: `start`, `stop`, `restart`, `status`, `logs`. Without a unit, `start`
  * runs `serve` as a process of its own; with one — `install`, a systemd user unit or a launchd
- * agent — it goes through systemd or launchd. **Nothing starts until `start` is typed** (NEED-9):
- * `install` only writes the file. What the server does stays each CLI's; `options.process` says how
- * to find, start and stop it.
+ * agent — it goes through systemd or launchd. **Nothing starts now until `start` is typed** (NEED-9):
+ * `install` writes the file and enables it, so it starts with every session from the next login (or boot,
+ * under linger) until `uninstall`. What the server does stays each CLI's; `options.process` says how to find,
+ * start and stop it.
  */
 export declare const serverCommand: (messenger: Messenger, options?: ServerOptions) => Command;

package/dist/cli/messenger/server-command.js

@@ -54,9 +54,10 @@ const lockProcess = (app, marker, serveArgv) => (context, system, logPath) => ({
 /**
  * `serve` in the background: `start`, `stop`, `restart`, `status`, `logs`. Without a unit, `start`
  * runs `serve` as a process of its own; with one — `install`, a systemd user unit or a launchd
- * agent — it goes through systemd or launchd. **Nothing starts until `start` is typed** (NEED-9):
- * `install` only writes the file. What the server does stays each CLI's; `options.process` says how
- * to find, start and stop it.
+ * agent — it goes through systemd or launchd. **Nothing starts now until `start` is typed** (NEED-9):
+ * `install` writes the file and enables it, so it starts with every session from the next login (or boot,
+ * under linger) until `uninstall`. What the server does stays each CLI's; `options.process` says how to find,
+ * start and stop it.
  */
 export const serverCommand = (messenger, options = {}) => {
     const { app } = messenger;
@@ -226,8 +227,11 @@ export const serverCommand = (messenger, options = {}) => {
             : undefined;
         const gaveUpReason = gaveUp === undefined ? undefined : Object.entries(EXIT_CODES).find(([, code]) => code === gaveUp)?.[0];
         const flood = new FloodMemory(floodPathFor(app, unit.profile, context.env)).read();
+        const startsAtLogin = isInstalled && state.enabled === true;
         const unitLine = isInstalled
-            ? `Unit: ${tilde(unit.path, context.env)} — ${state.detail ?? (state.active ? "active" : "inactive")}.`
+            ? `Unit: ${tilde(unit.path, context.env)} — ${state.detail ?? (state.active ? "active" : "inactive")}, ${startsAtLogin
+                ? "starts at login."
+                : `does not start at login — \`${app.command} ${unit.profile} server install\` turns that on.`}`
             : `No unit installed — \`${app.command} ${unit.profile} server install\` adds one, for starting under systemd or launchd.`;
         say({
             profile: unit.profile,
@@ -248,6 +252,7 @@ export const serverCommand = (messenger, options = {}) => {
             ...(gaveUp !== undefined
                 ? { stopped: { exitCode: gaveUp, reason: gaveUpReason ?? null, restarts: false } }
                 : {}),
+            startsAtLogin,
             unit: { name: unit.name, path: unit.path, installed: isInstalled, ...state },
             flood: { deadlines: flood.deadlines, sendBlock: flood.sendBlock ?? null },
         }, [
@@ -293,16 +298,28 @@ export const serverCommand = (messenger, options = {}) => {
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server install`],
     }))
-        .description("write a systemd user unit or a launchd agent for this profile; starts nothing")
-        .action(function () {
-        const { context, platform, unit, say } = prepare(this);
+        .summary("install this profile's background server to start at every login")
+        .description("write a systemd user unit or a launchd agent for this profile and have it start at every login; starts nothing now")
+        .action(async function () {
+        const { context, platform, unit, each, say } = prepare(this);
         const replaced = existsSync(unit.path);
         writeSecurely(unit.path, platform.text(unit, app), 0o644);
         platform.prepare?.(unit);
-        say({ profile: unit.profile, unit: unit.name, path: unit.path, command: unit.command, replaced }, [
-            `${replaced ? "Rewrote" : "Wrote"} ${tilde(unit.path, context.env)} — nothing started.`,
+        // A unit of moved folders runs a development checkout, which must not start at every login on the owner's keyring.
+        const moved = Object.keys(locationVariables(app, context.env)).length > 0;
+        if (!moved)
+            await each(platform.install(unit));
+        say({
+            profile: unit.profile,
+            unit: unit.name,
+            path: unit.path,
+            command: unit.command,
+            replaced,
+            startsAtLogin: !moved,
+        }, [
+            `${replaced ? "Rewrote" : "Wrote"} ${tilde(unit.path, context.env)} — ${moved ? "with moved folders it does not start at login" : "it starts at every login"}, nothing started now.`,
             `It runs: ${unit.command.map((word) => tilde(word, context.env)).join(" ")}`,
-            `Start it now: ${app.command} ${unit.profile} server start · ${platform.atLogin(unit)}`,
+            `Start it now: ${app.command} ${unit.profile} server start · never at login: ${app.command} ${unit.profile} server uninstall`,
             // Suggested, never turned on: an agent reading chats every morning is the owner's choice (NEED-161).
             `A daily follow-up review is off. To turn it on: ${app.command} ${unit.profile} schedule agent follow-ups claude "${followUpsPrompt(app.command)}" --at 08:30`,
         ]);
@@ -311,13 +328,14 @@ export const serverCommand = (messenger, options = {}) => {
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server uninstall`],
     }))
-        .description("remove this profile's unit; stop it first")
+        .description("remove this profile's unit, so it no longer starts at login; stop it first")
         .action(async function () {
-        const { context, platform, unit, say } = prepare(this);
+        const { context, platform, unit, each, say } = prepare(this);
         installed(unit);
         if ((await platform.state(unit)).active) {
             throw new CliError("validation_error", `the unit is running — \`${app.command} ${unit.profile} server stop\` first`);
         }
+        await each(platform.uninstall(unit));
         rmSync(unit.path, { force: true });
         say({ profile: unit.profile, unit: unit.name, path: unit.path, removed: true }, [
             `Removed ${tilde(unit.path, context.env)}.`,

package/dist/cli/program.js

@@ -192,11 +192,15 @@ const runOnce = async (argv, definition, options) => {
     };
     const sigint = () => interrupted("SIGINT");
     const sigterm = () => interrupted("SIGTERM");
+    // A sync, or a one-shot's wait on work it started (`schedule run`), outlives its reader: a desktop that closed the
+    // pipe 18 minutes in must not lose the sync, and the run record still says how it ended. Its later lines go
+    // nowhere. A listening command's stream is its work, so it still ends.
+    let outlivesReader = false;
     const pipeError = (error) => {
-        if (error.code === "EPIPE") {
-            signalExit = 0;
-            control.abort(error);
-        }
+        if (error.code !== "EPIPE" || outlivesReader || (phased && !listens))
+            return;
+        signalExit = 0;
+        control.abort(error);
     };
     const externalAbort = () => {
         const cancelled = new CliError("cancelled", "command cancelled", { retryable: false });
@@ -343,6 +347,7 @@ const runOnce = async (argv, definition, options) => {
         const { lifetime, cooperative: stopsAtItsPace, partial: answersPartial } = metaOf(action);
         const persistent = lifetime === "persistent";
         listens = persistent;
+        outlivesReader = stopsAtItsPace === true;
         const interactiveLogin = !headless && lifetime === "interactive";
         const timeout = flags.timeout ?? (commandEnv[envName(definition.app, "TIMEOUT")]?.trim() || undefined);
         // A background fetch was asked to outlive the shell; only an explicit --timeout bounds it.

package/dist/cli/project-evidence.d.ts

@@ -1,4 +1,4 @@
-import type { StoredProjectGathering } from "../services/stored-project-gathering.js";
+import type { LeftOutChat, StoredProjectGathering } from "../services/stored-project-gathering.js";
 /** Days back (`90d`) or a start date (`2026-09-01`); either way the run freezes its end, so a resume keeps it. */
 export declare const projectWindowOf: (value: string) => {
     days: number;
@@ -10,7 +10,7 @@ export declare const projectCutoffTime: (value: string) => number;
  * The zone a typed start date was read in, and the window the run used, in UTC. `complete` is "the answer is whole":
  * reads finished and every linked chat held in full; the answer's own `complete` stays "reads finished".
  */
-export declare const projectAnswerParts: (sinceTime: string, found: StoredProjectGathering) => {
+export declare const projectAnswerParts: (sinceTime: string, found: StoredProjectGathering, hints?: Pick<ProjectTextHints, "read">) => {
     next?: ({
         kind: "command";
         step: string;
@@ -45,7 +45,7 @@ export declare const projectAnswerParts: (sinceTime: string, found: StoredProjec
  * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
  * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
  */
-export declare const withSyncCommands: (found: StoredProjectGathering, sync: ProjectTextHints["sync"]) => {
+export declare const withSyncCommands: (found: StoredProjectGathering, sync: ProjectTextHints["sync"], read?: ProjectTextHints["read"]) => {
     schemaVersion: 1;
     runKey: string;
     fingerprint: string;
@@ -80,7 +80,6 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         pages: number;
         issue: string | null;
     }[];
-    items: import("../services/project-gathering.js").ProjectEvidenceItem[];
     people: import("../services/project-gathering.js").ProjectEvidencePerson[];
     peopleOmitted: number;
     oversized: {
@@ -110,6 +109,9 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
     complete: boolean;
     completeness: "complete" | "partial" | "unknown";
     checkpoint: string | null;
+    items: (import("../services/project-gathering.js").ProjectEvidenceItem & {
+        proposed?: string;
+    })[];
     projectRef: string | null;
     unreadSources: {
         source: string;
@@ -117,6 +119,14 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
     }[];
     mentions: import("../services/project-gathering-mentions.js").EvidenceMentions;
+    purposes: "all" | string[];
+    members: import("../services/stored-project-gathering.js").ProjectMember[];
+    purposeHint: {
+        chat: string;
+        relationship: string;
+        items: number;
+        of: number;
+    } | null;
     linkedChats: {
         provider: string;
         account: string;
@@ -134,13 +144,32 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         } | null;
         items?: number | undefined;
         capped?: boolean | undefined;
+        purpose: string;
+        proposed?: string;
+        score?: number;
         syncCommand: string | null;
     }[];
+    leftOut: {
+        ref: string;
+        provider: string;
+        account: string;
+        chat: string;
+        title: string | null;
+        purpose: string;
+        relationship: string | null;
+        proposed?: string;
+        messages: number;
+        firstAt: string | null;
+        lastAt: string | null;
+        readCommand: string | null;
+    }[];
 };
 export interface ProjectTextHints {
     /** The command that syncs one linked chat back to `since` (`YYYY-MM-DD`), or null when no command here can. */
     sync: (chat: StoredProjectGathering["linkedChats"][number], since: string) => string | null;
     /** How to open a document too large to read here. */
     showDocument: string;
+    /** The command that reads a chat left out by its purpose from `since`, or null when no command here can. */
+    read?: (chat: LeftOutChat, since: string) => string | null;
 }
 export declare const projectEvidenceText: (found: StoredProjectGathering, hints: ProjectTextHints) => string;