@linkshell/host 0.4.69 → 0.4.70

package/dist/host/src/hub.d.ts

@@ -1,4 +1,4 @@
-import { type GoalChange, type BackgroundTask, type AgentInfo, type ContentBlock, type SessionEvent, type SessionSummary, type SubagentInfo, type QuestionAnswer, type GitInfo, type ProjectSummary, type WorktreeEntry, type SessionNotice, type AcpAgentSettings, type AcpRemoteAgent, type PendingPermissionSummary, type EditorRequest, type SideChat } from "@linkshell/wire";
+import { type GoalChange, type BackgroundTask, type AgentInfo, type ContentBlock, type SessionEvent, type SessionSummary, type SubagentInfo, type QuestionAnswer, type GitInfo, type ProjectSummary, type WorktreeEntry, type SessionNotice, type AcpAgentSettings, type AcpRemoteAgent, type PendingPermissionSummary, type EditorRequest, type SideChat, type MethodResult } from "@linkshell/wire";
 import type { AcpSettingsStore } from "./acp-settings.js";
 import type { AgentDriver, DesktopController, DesktopLaunchContext, DriverHost, LaunchSpec } from "./drivers/types.js";
 import { type HostStore } from "./store.js";
@@ -9,6 +9,17 @@ export interface Subscriber {
     /** The backlog that follows starts after `startSeq`, not where the subscriber left off. */
     window?(startSeq: number): void;
 }
+/**
+ * Archived here or in the app, unless it was unarchived here after the app
+ * archived it (`local.at` 0: chosen before times were kept, so it never outranks the app).
+ */
+export declare function mergedArchive(local: {
+    archived: boolean;
+    at: number;
+}, app: {
+    archived: boolean;
+    since: number;
+} | undefined): boolean;
 /**
  * The host's source of truth for sessions. Drivers push native events in;
  * the hub logs them with a per-session seq, keeps summaries current and fans
@@ -315,6 +326,11 @@ export declare class SessionHub {
     /** Asked for every project each time the list is: remembered for a moment. */
     private branchOf;
     getSession(sessionId: string): SessionSummary;
+    /** A session and its agent's driver, unchecked: for what one driver offers itself (`mcp.*`), which says what it needs of it. */
+    sessionDriver(sessionId: string): {
+        session: SessionSummary;
+        driver: AgentDriver | undefined;
+    };
     /** Adds the live-only fields (current activity, first pending permission) to a stored summary. */
     /** Marks a session that works in one of LinkShell's worktrees. */
     private withWorktree;
@@ -322,7 +338,20 @@ export declare class SessionHub {
     private worktrees;
     private readonly pendingQuestions;
     private questionsOf;
+    /** Per session, the session it was forked from (null: none), read from the store once. */
+    private readonly forkOrigins;
+    /** Per session, the sessions whose lineage names it: their rows change when it comes or goes. */
+    private readonly related;
+    private forkOrigin;
+    /** Where the session came from, naming only sessions this host has: a list can't nest under one it doesn't show. */
+    private withLineage;
+    /** As the Claude app nests: a session still in use stands alone when the one it came from is archived. */
+    private firstKnown;
+    /** The session came, went or was (un)archived: the rows that name it as parent or origin say so now. */
+    private announceRelated;
     private decorate;
+    /** What a new session of `agent` could run on (see `agents.models`): nothing from a driver that can't tell before a session exists. */
+    agentModels(agent: string, cwd?: string): Promise<MethodResult<"agents.models">>;
     createSession(input: {
         agent: string;
         cwd: string;
@@ -416,6 +445,9 @@ export declare class SessionHub {
     private sendHeld;
     onRemoved(listener: (sessionId: string) => void): () => void;
     archive(sessionId: string, archived: boolean): Promise<SessionSummary>;
+    /** Folds in the archive state of the agent's app that LinkShell only reads (see `mergedArchive`). */
+    private reconcileAppArchive;
+    private localArchive;
     rename(sessionId: string, title: string): Promise<SessionSummary>;
     /**
      * Deletes a session. A worktree only it used goes too when nothing in it

package/dist/host/src/hub.js

@@ -1,4 +1,4 @@
-import { RpcError, questionReplies, questionAnswerError, updateAsyncQuestions, sessionIdFor, } from "@linkshell/wire";
+import { RpcError, questionReplies, readUserText, questionAnswerError, updateAsyncQuestions, sessionIdFor, } from "@linkshell/wire";
 import { inOrder } from "./drivers/acp/driver.js";
 import { canForkNatively } from "./drivers/behavior.js";
 import { homedir } from "node:os";
@@ -57,6 +57,24 @@ function worktreeLossMessage(state) {
 const RENAMED = "renamed";
 /** Driver-state key: the conversation a forked session's agent is still to be told, with its first message. */
 const CARRY = "carry";
+/** Driver-state key: the session a session was forked from (made here, or as its agent recorded it). */
+const FORKED_FROM = "forkedFrom";
+/**
+ * Driver-state keys, for agents with an app LinkShell only reads (`appArchive`):
+ * LinkShell's own archive choice and when it was made, and the app's state as
+ * last seen and since when.
+ */
+const LOCAL_ARCHIVE = "archive-local";
+const APP_ARCHIVE = "archive-app";
+/**
+ * Archived here or in the app, unless it was unarchived here after the app
+ * archived it (`local.at` 0: chosen before times were kept, so it never outranks the app).
+ */
+export function mergedArchive(local, app) {
+    if (local.archived)
+        return true;
+    return !!app?.archived && !(local.at > app.since);
+}
 /** A returning client catches up from where it was, unless it missed more than this. */
 const CATCH_UP = { events: 800, bytes: 4 * 1024 * 1024 };
 /** State a client needs from before its window: the latest of each applies. */
@@ -172,6 +190,17 @@ export class SessionHub {
             this.emitSummary(stored);
         },
         removed: (agent, nativeId) => this.forget(sessionIdFor(agent, nativeId)),
+        nativeRecordsChanged: (agent, nativeIds) => {
+            for (const nativeId of nativeIds) {
+                const stored = this.store.getSession(sessionIdFor(agent, nativeId));
+                if (!stored)
+                    continue;
+                const merged = this.reconcileAppArchive(stored);
+                this.emitSummary(merged);
+                if (merged.archived !== stored.archived)
+                    this.announceRelated(merged.id);
+            }
+        },
         desktop: (agent, nativeId) => this.desktops.get(sessionIdFor(agent, nativeId)),
         state: (agent, nativeId) => {
             const sessionId = sessionIdFor(agent, nativeId);
@@ -180,6 +209,10 @@ export class SessionHub {
                 set: (key, value) => this.store.setDriverState(sessionId, key, value),
             };
         },
+        agentState: (agent) => ({
+            get: (key) => this.store.getAgentState(agent, key),
+            set: (key, value) => this.store.setAgentState(agent, key, value),
+        }),
         log: (message) => this.log(message),
     };
     constructor(store, drivers, log = () => { }, 
@@ -291,6 +324,7 @@ export class SessionHub {
         else if (availability === "available" && this.store.isNativeMissing(session.id)) {
             this.store.setNativeMissing(session.id, false);
             this.emitSummary(session);
+            this.announceRelated(session.id);
         }
     }
     hideMissingSession(session) {
@@ -305,6 +339,7 @@ export class SessionHub {
         driver?.watched?.(session.nativeId, false);
         this.live.delete(session.id);
         this.emitRemoved(session.id);
+        this.announceRelated(session.id);
         void driver?.detach(session.nativeId).catch((error) => this.log(`[hub] detach missing ${session.id}: ${String(error)}`));
     }
     async stop() {
@@ -425,6 +460,8 @@ export class SessionHub {
                 await existing.configureAcp?.(services.settings.settings(id));
                 await existing.stop();
                 this.drivers.delete(id);
+                // What the old definition's agent reported (its models) needn't hold for the new one.
+                this.store.clearAgentState(id);
             }
             if (save && driver) {
                 services.settings.saveAgent(save);
@@ -493,6 +530,11 @@ export class SessionHub {
             throw RpcError.app("not_found", "这个会话的原始记录已不存在，已从列表隐藏；本地缓存仍保留。");
         return this.decorate(summary);
     }
+    /** A session and its agent's driver, unchecked: for what one driver offers itself (`mcp.*`), which says what it needs of it. */
+    sessionDriver(sessionId) {
+        const session = this.getSession(sessionId);
+        return { session, driver: this.drivers.get(session.agent) };
+    }
     /** Adds the live-only fields (current activity, first pending permission) to a stored summary. */
     /** Marks a session that works in one of LinkShell's worktrees. */
     withWorktree(summary) {
@@ -512,8 +554,55 @@ export class SessionHub {
         }
         return questions;
     }
+    /** Per session, the session it was forked from (null: none), read from the store once. */
+    forkOrigins = new Map();
+    /** Per session, the sessions whose lineage names it: their rows change when it comes or goes. */
+    related = new Map();
+    forkOrigin(sessionId) {
+        let origin = this.forkOrigins.get(sessionId);
+        if (origin === undefined) {
+            origin = this.store.getDriverState(sessionId, FORKED_FROM) ?? null;
+            this.forkOrigins.set(sessionId, origin);
+        }
+        return origin ?? undefined;
+    }
+    /** Where the session came from, naming only sessions this host has: a list can't nest under one it doesn't show. */
+    withLineage(summary) {
+        const native = this.drivers.get(summary.agent)?.lineage?.(summary.nativeId);
+        const ids = (nativeIds) => nativeIds?.map((nativeId) => sessionIdFor(summary.agent, nativeId)) ?? [];
+        const origin = this.forkOrigin(summary.id);
+        const parentId = this.firstKnown(summary, ids(native?.parent));
+        const forkedFrom = this.firstKnown(summary, [...(origin ? [origin] : []), ...ids(native?.forkedFrom)]);
+        const appId = native?.appId;
+        if (!parentId && !forkedFrom && !appId)
+            return summary;
+        return { ...summary, ...(parentId ? { parentId } : {}), ...(forkedFrom ? { forkedFrom } : {}), ...(appId ? { appId } : {}) };
+    }
+    /** As the Claude app nests: a session still in use stands alone when the one it came from is archived. */
+    firstKnown(summary, candidates) {
+        let found;
+        for (const candidate of candidates) {
+            if (candidate === summary.id)
+                continue;
+            let children = this.related.get(candidate);
+            if (!children)
+                this.related.set(candidate, (children = new Set()));
+            children.add(summary.id);
+            if (found)
+                continue;
+            const other = this.store.getSession(candidate);
+            if (other && !(other.archived && !summary.archived) && !this.store.isNativeMissing(candidate))
+                found = candidate;
+        }
+        return found;
+    }
+    /** The session came, went or was (un)archived: the rows that name it as parent or origin say so now. */
+    announceRelated(sessionId) {
+        for (const child of this.related.get(sessionId) ?? [])
+            this.announce(child);
+    }
     decorate(summary) {
-        summary = { ...summary, asyncQuestions: this.questionsOf(summary.id) };
+        summary = this.withLineage({ ...summary, asyncQuestions: this.questionsOf(summary.id) });
         const live = this.live.get(summary.id);
         if (!live)
             return this.withWorktree(summary);
@@ -561,6 +650,11 @@ export class SessionHub {
         }
         return decorated;
     }
+    /** What a new session of `agent` could run on (see `agents.models`): nothing from a driver that can't tell before a session exists. */
+    async agentModels(agent, cwd) {
+        const driver = this.requireDriver(agent);
+        return (await driver.listModels?.(cwd)) ?? { models: [] };
+    }
     async createSession(input) {
         const driver = this.requireDriver(input.agent);
         const worktree = input.worktree ? await this.newWorktree(input.cwd, promptLabel(input.prompt)) : undefined;
@@ -615,7 +709,7 @@ export class SessionHub {
             }
             if (!discovered)
                 return await this.forkByReplay(summary, driver, cwd, cut);
-            this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title });
+            this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title, forkedFrom: summary.nativeId });
             return this.getSession(sessionIdFor(driver.id, discovered.nativeId));
         }
         catch (error) {
@@ -633,7 +727,7 @@ export class SessionHub {
         const start = this.store.pageStart(summary.id, cut);
         const events = this.store.readEvents(summary.id, start, PAGE.maxEvents + 1, cut).filter((event) => isConversation(event.update));
         const discovered = await driver.createSession({ cwd });
-        this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title });
+        this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title, forkedFrom: summary.nativeId });
         const forkId = sessionIdFor(driver.id, discovered.nativeId);
         await this.ensureAttached(forkId);
         const live = this.liveFor(forkId);
@@ -1185,10 +1279,40 @@ export class SessionHub {
         const driver = this.drivers.get(summary.agent);
         if (driver?.archive)
             await driver.archive(summary.nativeId, archived);
-        const updated = this.store.patchSession(sessionId, { archived });
+        // Kept apart from the app's, with when: unarchiving here outranks an older archive there.
+        if (driver?.appArchive)
+            this.store.setDriverState(sessionId, LOCAL_ARCHIVE, JSON.stringify({ archived, at: Date.now() }));
+        const updated = this.reconcileAppArchive(this.store.patchSession(sessionId, { archived }));
         this.emitSummary(updated);
+        this.announceRelated(sessionId);
         return this.decorate(updated);
     }
+    /** Folds in the archive state of the agent's app that LinkShell only reads (see `mergedArchive`). */
+    reconcileAppArchive(summary) {
+        const reported = this.drivers.get(summary.agent)?.appArchive?.(summary.nativeId);
+        // Not in that app (or not read yet): the flag is LinkShell's alone, or stays as last merged.
+        if (!reported)
+            return summary;
+        const saved = this.store.getDriverState(summary.id, APP_ARCHIVE);
+        const seen = saved ? JSON.parse(saved) : undefined;
+        if (!seen && !reported.archived)
+            return summary;
+        // Only a change counts as the app archiving it: the app rewrites its record for much else.
+        const app = seen?.archived === reported.archived ? seen : { archived: reported.archived, since: reported.at };
+        if (app !== seen)
+            this.store.setDriverState(summary.id, APP_ARCHIVE, JSON.stringify(app));
+        const archived = mergedArchive(this.localArchive(summary), app);
+        return archived === summary.archived ? summary : this.store.patchSession(summary.id, { archived });
+    }
+    localArchive(summary) {
+        const saved = this.store.getDriverState(summary.id, LOCAL_ARCHIVE);
+        if (saved)
+            return JSON.parse(saved);
+        // Until the app's state is first merged in, the flag is LinkShell's own choice.
+        const local = { archived: summary.archived, at: 0 };
+        this.store.setDriverState(summary.id, LOCAL_ARCHIVE, JSON.stringify(local));
+        return local;
+    }
     async rename(sessionId, title) {
         const summary = this.getSession(sessionId);
         const name = compact(title, TITLE_LENGTH);
@@ -1249,7 +1373,9 @@ export class SessionHub {
         this.previews.forget(sessionId);
         this.sides.forget(sessionId);
         this.store.removeSession(sessionId);
+        this.forkOrigins.delete(sessionId);
         this.emitRemoved(sessionId);
+        this.announceRelated(sessionId);
     }
     emitRemoved(sessionId) {
         for (const listener of this.removedListeners) {
@@ -1431,10 +1557,19 @@ export class SessionHub {
                     // Items without a recorded time get the time of the one before, never "now".
                     // (An agent that only says when a session last changed gives that as its creation too.)
                     let ts = Math.min(summary.createdAt, history.find((item) => item.ts !== undefined)?.ts ?? summary.createdAt);
-                    for (const item of history) {
+                    // The log only grows at its end. A message before what it already has is one an earlier
+                    // reading skipped (a reader that now shows more), not something that happened since:
+                    // added now it would land at the bottom, out of place, so it is only marked as seen.
+                    const logged = history.map((item) => this.store.isItemLogged(sessionId, item.itemId));
+                    const lastLogged = logged.lastIndexOf(true);
+                    for (const [index, item] of history.entries()) {
                         ts = Math.min(Math.max(item.ts ?? ts, ts), summary.updatedAt);
-                        if (this.store.isItemLogged(sessionId, item.itemId))
+                        if (logged[index])
                             continue;
+                        if (index < lastLogged && item.updates.every((update) => update.sessionUpdate === "user_message_chunk")) {
+                            this.store.markItemLogged(sessionId, item.itemId);
+                            continue;
+                        }
                         for (const update of item.updates)
                             this.commit(sessionId, update, undefined, ts);
                         this.store.markItemLogged(sessionId, item.itemId);
@@ -1500,9 +1635,9 @@ export class SessionHub {
             updatedAt: session.updatedAt,
         });
         const { created } = stored;
-        const summary = session.archived !== undefined && session.archived !== stored.summary.archived
+        const summary = this.reconcileAppArchive(session.archived !== undefined && session.archived !== stored.summary.archived
             ? this.store.patchSession(stored.summary.id, { archived: session.archived })
-            : stored.summary;
+            : stored.summary);
         const changed = !!before &&
             (before.title !== summary.title ||
                 before.state !== summary.state ||
@@ -1517,8 +1652,16 @@ export class SessionHub {
             if (questionsChanged)
                 this.store.setDriverState(summary.id, "asyncQuestions", JSON.stringify(session.asyncQuestions));
         }
-        if (created || changed || questionsChanged || restored)
+        const origin = session.forkedFrom === undefined ? undefined : sessionIdFor(agent, session.forkedFrom);
+        const forked = origin !== undefined && origin !== summary.id && origin !== this.forkOrigin(summary.id);
+        if (forked) {
+            this.store.setDriverState(summary.id, FORKED_FROM, origin);
+            this.forkOrigins.set(summary.id, origin);
+        }
+        if (created || changed || questionsChanged || restored || forked)
             this.emitSummary(summary);
+        if (created || restored || before?.archived !== summary.archived)
+            this.announceRelated(summary.id);
     }
     ingest(sessionId, update, itemId, ts) {
         if (this.store.isNativeMissing(sessionId))
@@ -1595,8 +1738,9 @@ export class SessionHub {
                 if (update.parentToolCallId || !update.content)
                     break;
                 const text = update.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-                if (update.role === "user" && !before.title && text.trim())
-                    patch.title = compact(text, TITLE_LENGTH);
+                // A title is the person's words, not the context their client or Claude wrapped around them.
+                if (update.role === "user" && !before.title && readUserText(text).text.trim())
+                    patch.title = compact(readUserText(text).text, TITLE_LENGTH);
                 if (update.role === "agent" && text.trim())
                     patch.preview = compact(text, PREVIEW_LENGTH);
                 if (live.turnActive && update.role === "agent")
@@ -1604,7 +1748,7 @@ export class SessionHub {
                 break;
             }
             case "user_message_chunk": {
-                const text = update.content.type === "text" ? update.content.text : "";
+                const text = update.content.type === "text" ? readUserText(update.content.text).text : "";
                 if (text && !before.title)
                     patch.title = compact(text, TITLE_LENGTH);
                 if (text && !before.preview)