@evandu/super-pi 0.1.145 → 0.1.147

package/dist/server/application/session-orchestrator-service.js

@@ -1,8 +1,21 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { capText } from "../workflow.js";
+import { assertSessionCwdInsideWorkspace } from "../session-cwd.js";
+import { SessionWatchdog } from "./session-watchdog.js";
+import { isLengthExceededError } from "../turn-failure.js";
+import { LENGTH_CONTINUATION_PROMPT } from "../length-continuation.js";
 export const SESSION_OUTPUT_CHAR_LIMIT = 64 * 1024;
 export const sessionResultRelativePath = (conversationId) => `.super-pi/session-results/${conversationId}.md`;
+/**
+ * HOW MANY TIMES A CHILD MAY BE TOLD TO CONTINUE AFTER ITS OUTPUT WAS TRUNCATED.
+ *
+ * The bound is not about tokens - it is about a model that truncates on EVERY response. Three
+ * continuations cover the ordinary case (a long answer split across a few responses) and stop the
+ * pathological one. Past the bound the child is reported as unfinished, which is a true sentence
+ * about what happened, instead of a loop that never ends.
+ */
+export const MAX_LENGTH_CONTINUATIONS = 3;
 /**
  * Orchestrator service coordinating sibling and child conversations.
  *
@@ -15,25 +28,90 @@ export class SessionOrchestratorService {
     runService;
     ledger;
     broadcaster;
-    constructor(store, conversationService, runService, ledger, broadcaster) {
+    watchdog;
+    /**
+     * HOW MANY TIMES EACH CHILD HAS BEEN TOLD TO CONTINUE AFTER A TRUNCATION.
+     *
+     * Per child rather than per dispatch, so a child that is given several tasks cannot extend itself
+     * indefinitely by being handed a new task each time it runs out of output budget. The entry is
+     * dropped as soon as the child finishes, so a child that continues successfully starts fresh on
+     * its next task.
+     */
+    lengthContinuations = new Map();
+    /**
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     *
+     * A child can report explicitly - the `report` action - and that report is the child's own
+     * statement of what it did. When the child's turn then ends, the automatic completion report
+     * would deliver the same thing a second time, so the automatic path steps aside for a child that
+     * is in this set.
+     *
+     * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
+     * update is not the child's final word: the task is still running, and the parent will want to
+     * hear how it ended.
+     */
+    reportedChildren = new Set();
+    constructor(store, conversationService, runService, ledger, broadcaster, watchdog) {
         this.store = store;
         this.conversationService = conversationService;
         this.runService = runService;
         this.ledger = ledger;
         this.broadcaster = broadcaster;
+        this.watchdog = watchdog ?? new SessionWatchdog({
+            onTimeout: async (event) => {
+                await this.handleWatchdogTimeout(event);
+            },
+            workspacePath: (workspaceId) => this.store.workspace(workspaceId)?.path,
+            workspaceIds: () => this.store.workspaces().map((w) => w.id),
+            isChildWorking: (childConversationId) => {
+                const conversation = this.store.conversation(childConversationId);
+                return conversation ? (conversation.status === "running" || conversation.status === "waiting") : false;
+            },
+            warn: (message) => console.warn(message),
+        });
+    }
+    /**
+     * The watchdog timer fired: the child has been silent for longer than the parent declared.
+     * Delivers a reminder message to the parent session. Does NOT interrupt or abort the child session.
+     */
+    async handleWatchdogTimeout(event) {
+        const { childConversationId, parentConversationId, timeoutSeconds, elapsedSeconds, childWorking } = event;
+        const conversation = this.store.conversation(childConversationId);
+        const workspace = conversation ? this.store.workspace(conversation.workspaceId) : undefined;
+        const statusText = childWorking ? "运行中" : "空闲";
+        const minutes = Math.max(1, Math.round(elapsedSeconds / 60));
+        const output = `[Watchdog 提醒] 子会话 ${childConversationId} 已经超过 ${elapsedSeconds} 秒（约 ${minutes} 分钟）未汇报。当前状态：${statusText}。如果需要，你可以主动查看子会话状态或打断其执行。`;
+        const resultPath = sessionResultRelativePath(childConversationId);
+        if (workspace) {
+            try {
+                const resultDirectory = join(workspace.path, ".super-pi", "session-results");
+                await mkdir(resultDirectory, { recursive: true });
+                await writeFile(join(resultDirectory, `${childConversationId}.md`), output, "utf8");
+            }
+            catch (error) {
+                console.warn(`Super Pi: writing watchdog result file failed for ${childConversationId}:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+        await this.runService.enqueueSessionResult({
+            conversationId: childConversationId,
+            parentConversationId,
+            output,
+            resultPath,
+        });
     }
     /**
      * Spawns a new sibling conversation and immediately dispatches its initial task.
      */
     async spawn(options) {
-        let workspaceId = options.workspaceId;
-        if (!workspaceId && options.parentConversationId) {
-            const parent = this.store.conversation(options.parentConversationId);
-            workspaceId = parent?.workspaceId;
-        }
+        const workspaceId = options.workspaceId?.trim();
         if (!workspaceId) {
-            throw new Error("创建兄弟会话需要指定工作区（或提供有效的父会话 ID）。");
+            throw new Error("创建兄弟会话必须显式指定 workspaceId；父会话只记录树形关系，不能代替目标工作区。");
         }
+        const workspace = this.store.workspace(workspaceId);
+        if (!workspace)
+            throw new Error("找不到这个工作区。");
+        await assertSessionCwdInsideWorkspace(workspace.path, options.cwd);
+        const cwd = options.cwd;
         // THE PARENTAGE IS WRITTEN AT CREATION TIME, onto the conversation itself - not only into the
         // in-memory ledger below. The ledger is task/status/progress metadata and dies with the process;
         // the conversation's parentConversationId/origin is what the sidebar's session tree redraws
@@ -41,7 +119,7 @@ export class SessionOrchestratorService {
         const conversationId = await this.conversationService.createConversation(workspaceId, {
             parentConversationId: options.parentConversationId,
             origin: options.parentConversationId ? "orchestrator" : "user",
-        });
+        }, cwd);
         // Set title if requested or derive from task
         if (options.title) {
             await this.conversationService.renameConversation(conversationId, options.title);
@@ -69,6 +147,16 @@ export class SessionOrchestratorService {
             task: options.task,
             status: "idle",
         });
+        // Arm silence watchdog if configured and session has a direct parent
+        const watchdogTimeout = options.watchdogTimeoutSeconds ?? options.watchdog_timeout_seconds ?? options.watchdogSeconds;
+        if (watchdogTimeout && watchdogTimeout > 0 && options.parentConversationId) {
+            await this.watchdog.arm({
+                childConversationId: conversationId,
+                parentConversationId: options.parentConversationId,
+                workspaceId,
+                timeoutSeconds: watchdogTimeout,
+            });
+        }
         // Immediately dispatch initial work
         const prompt = options.initialPrompt ?? options.task;
         if (prompt && prompt.trim()) {
@@ -88,7 +176,11 @@ export class SessionOrchestratorService {
         this.ledger.update(conversationId, {
             status: "running",
         });
-        const runPromise = this.runService.enqueueAndRun(conversationId, content);
+        // THE ORDER IS THE SYSTEM'S, NOT THE READER'S. It used to go through `enqueueAndRun`, which
+        // writes the words under the reader's own name - so the child's transcript showed an
+        // instruction the reader never typed, wearing the reader's avatar, and a reader who looked at
+        // the child session saw their own name on somebody else's order.
+        const runPromise = this.runService.enqueueAndRunAsAgent(conversationId, content);
         const completion = (async () => {
             let failure;
             try {
@@ -100,17 +192,62 @@ export class SessionOrchestratorService {
                 failure = error;
                 await this.runService.waitForConversationIdle(conversationId);
             }
+            // A TRUNCATED ANSWER IS NOT A DEAD CHILD. The model filled its single-response output budget
+            // and stopped mid-sentence; everything it said is already on the child's transcript, and the
+            // work it was doing is NOT over. Treating that as a failure is what killed the child: the run
+            // service stamped the conversation `failed`, the orchestrator reported a failure to the
+            // parent, and a task that was one turn from done was thrown away.
+            //
+            // So a length stop is CONTINUED, not reported. The child is told to pick up where the output
+            // stopped, and it runs again. The bound is real: a model that truncates forever would
+            // otherwise loop until the watchdog gave up, and a task that cannot finish is better REPORTED
+            // as unfinished than retried until the server falls over.
+            //
+            // A CONTINUED CHILD IS NOT A FAILED ONE, SO THE FAILURE IS CLEARED. Everything below reads
+            // `failure` to decide what the parent is told and what the ledger records; a child that
+            // finished its answer has neither a failure to report nor a result to hand over - the parent
+            // reads the child's session, exactly as it does for a child that finished normally.
+            if (failure !== undefined && isLengthExceededError(failure)) {
+                const continued = await this.continueAfterLengthStop(conversationId, failure);
+                if (continued)
+                    failure = undefined;
+            }
+            // THE RESULT FILE IS ALWAYS WRITTEN, AND THE PARENT IS ALWAYS TOLD.
+            //
+            // The file is the child's product and the reader may open it. The report is a message to the
+            // parent, and it goes out WHETHER THE CHILD SUCCEEDED OR FAILED - because a parent that
+            // delegated a task has to be told how it went. A parent that heard nothing would wait forever,
+            // or would have to poll the child's session to find out, which is exactly what the automatic
+            // report exists to avoid.
+            //
+            // The envelope already tells the two apart: `state="completed"` with `<task_result>` for a
+            // child that finished, `state="error"` with `<task_error>` for one that broke. Reporting only
+            // the failures was a real defect - it left a parent that had successfully delegated a task
+            // staring at an empty transcript, and the child looking finished to everyone except the one
+            // person waiting for it.
             try {
                 const result = await this.persistSessionResult(conversationId, failure);
                 if (result) {
                     const current = this.store.conversation(conversationId);
-                    await this.runService.enqueueSessionResult({
-                        conversationId,
-                        parentConversationId: current?.parentConversationId,
-                        output: result.output,
-                        resultPath: result.resultPath,
-                        ...(failure !== undefined ? { error: result.output } : {}),
-                    });
+                    // AN INTERRUPTED CHILD HAS NO RESULT TO REPORT. "stopped" means somebody pressed stop, and
+                    // the half-finished answer that was on screen is not a result anybody stated. The parent is
+                    // told nothing, which is right: the child can be asked again, and then it reports.
+                    const interrupted = current?.status === "stopped";
+                    // A CHILD THAT REPORTED ITSELF IS NOT REPORTED TWICE. The explicit report is the child's
+                    // own statement of what it did, so the automatic completion steps aside for it.
+                    const alreadyReported = this.reportedChildren.has(conversationId);
+                    if (!interrupted && !alreadyReported) {
+                        await this.runService.enqueueSessionResult({
+                            conversationId,
+                            parentConversationId: current?.parentConversationId,
+                            output: result.output,
+                            resultPath: result.resultPath,
+                            // THE ERROR GOES ONLY WHEN THERE IS ONE. `enqueueSessionResult` reads the presence of
+                            // `error` as "this failed", so a successful report must NOT carry the key - carrying it
+                            // with the output would tell the parent the child failed.
+                            ...(failure !== undefined ? { error: result.output } : {}),
+                        });
+                    }
                 }
             }
             catch (error) {
@@ -130,11 +267,174 @@ export class SessionOrchestratorService {
             void completion.catch(() => undefined);
         return { conversationId };
     }
+    /**
+     * THE CHILD'S OUTPUT WAS CUT OFF. TELL IT TO CARRY ON, AND LET IT.
+     *
+     * This is the recovery for a length stop, and it exists because a truncated answer is not a
+     * finished one. The child has already said most of what it had to say - that text is on its
+     * transcript - so the work left to do is the tail of the answer, not the whole of it.
+     *
+     * WHY THE CONTINUATION IS A NEW TURN RATHER THAN A RESUME OF THE SAME ONE. Pi has already settled
+     * the turn that was truncated: the model stopped, the message was written, the run ended. There is
+     * no live turn to resume, so the only way to get more output is to ask again - and asking again in
+     * the SAME conversation is what makes the continuation work, because the child's own partial
+     * answer is in its context and the model can see exactly where it stopped.
+     *
+     * WHY IT IS AN AGENT-SENT ORDER RATHER THAN A USER MESSAGE. The person never typed this, and the
+     * child's transcript must not show words under their name that they never said - the same reason
+     * `dispatch` uses `enqueueAndRunAsAgent` in the first place.
+     *
+     * Returns true when the child was continued (and the caller must NOT report a failure), and false
+     * when the continuation could not be made or the bound was reached - in which case the caller
+     * reports the original failure, which is then the honest description of what happened.
+     */
+    async continueAfterLengthStop(conversationId, failure) {
+        if (!this.store.conversation(conversationId))
+            return false;
+        // THE LOOP, BECAUSE A CONTINUATION CAN BE TRUNCATED TOO. A long answer often needs more than
+        // one continuation: each response fills its own output budget, so a three-part answer runs out
+        // of room twice before it is done. The bound counts every continuation this child has been
+        // given, so the loop cannot run forever - a model that truncates on EVERY response reaches
+        // the bound and is reported as unfinished, which is the honest sentence about what happened.
+        for (;;) {
+            const used = this.lengthContinuations.get(conversationId) ?? 0;
+            if (used >= MAX_LENGTH_CONTINUATIONS) {
+                console.warn(`Super Pi: session ${conversationId} hit the output limit ${MAX_LENGTH_CONTINUATIONS} times; reporting it as unfinished.`);
+                this.lengthContinuations.delete(conversationId);
+                return false;
+            }
+            this.lengthContinuations.set(conversationId, used + 1);
+            const reason = failure instanceof Error ? failure.message : String(failure);
+            console.warn(`Super Pi: session ${conversationId} was truncated (${reason}); asking it to continue (${used + 1}/${MAX_LENGTH_CONTINUATIONS}).`);
+            let continuationFailure;
+            try {
+                // THE ORDER GOES IN AS A SYSTEM MESSAGE, AND THE RUN IS WAITED FOR. The child must be given
+                // the chance to finish before anything is reported to the parent - otherwise the parent would
+                // receive a result that is missing the tail the child was about to write.
+                await this.runService.enqueueAndRunAsAgent(conversationId, LENGTH_CONTINUATION_PROMPT);
+                await this.runService.waitForConversationIdle(conversationId);
+            }
+            catch (error) {
+                continuationFailure = error;
+            }
+            if (continuationFailure !== undefined) {
+                // A CONTINUATION THAT IS ITSELF TRUNCATED IS THE SAME SITUATION AGAIN, AND THE LOOP
+                // CONTINUES. It is only a different thing when the continuation failed for a reason that
+                // is NOT the output limit - a provider error, a refused tool - and those are the child's
+                // real failure, reported through the normal path below.
+                if (isLengthExceededError(continuationFailure)) {
+                    failure = continuationFailure;
+                    continue;
+                }
+                console.warn(`Super Pi: continuing session ${conversationId} failed:`, continuationFailure instanceof Error ? continuationFailure.message : String(continuationFailure));
+                this.lengthContinuations.delete(conversationId);
+                return false;
+            }
+            // THE CHILD SETTLED WITHOUT ANOTHER TRUNCATION. Its work is done: the answer on its transcript
+            // is now complete, and there is nothing to report to the parent - the parent reads the child's
+            // result from the session itself, exactly as it does for a child that finished normally.
+            //
+            // THE WARNING IS CLEARED HERE. It described the answer that was cut short, and the child has
+            // now finished that answer; leaving it up would tell the reader the answer is still truncated
+            // when it is not.
+            await this.store.setWarningReason(conversationId, undefined);
+            this.lengthContinuations.delete(conversationId);
+            this.ledger.update(conversationId, { status: "completed" });
+            return true;
+        }
+    }
+    /**
+     * Explicit report from a child session to its direct parent.
+     * Can be called multiple times at any point during execution.
+     */
+    async report(childConversationId, options) {
+        const conversation = this.store.conversation(childConversationId);
+        if (!conversation) {
+            throw new Error(`找不到会话：${childConversationId}`);
+        }
+        const parentConversationId = conversation.parentConversationId;
+        if (!parentConversationId) {
+            throw new Error(`会话 ${childConversationId} 没有直属父会话，无法汇报`);
+        }
+        const parent = this.store.conversation(parentConversationId);
+        if (!parent) {
+            throw new Error(`直属父会话 ${parentConversationId} 不存在`);
+        }
+        const content = options.content ?? "";
+        const status = options.status ?? "in_progress";
+        const failed = status === "failed";
+        const workspace = this.store.workspace(conversation.workspaceId);
+        const resultPath = sessionResultRelativePath(childConversationId);
+        if (workspace) {
+            const resultDirectory = join(workspace.path, ".super-pi", "session-results");
+            await mkdir(resultDirectory, { recursive: true });
+            await writeFile(join(resultDirectory, `${childConversationId}.md`), content, "utf8");
+        }
+        await this.runService.enqueueSessionResult({
+            conversationId: childConversationId,
+            parentConversationId,
+            output: content,
+            resultPath,
+            ...(failed ? { error: content } : {}),
+        });
+        // THE CHILD HAS NOW SPOKEN FOR ITSELF. The automatic report that fires when the child's turn
+        // ends would otherwise repeat what was just delivered - the parent would receive the same
+        // answer twice, once as the child's own report and once as the automatic completion.
+        //
+        // An EXPLICIT report is the child's own statement of what it did, so it is the better of the
+        // two and the automatic one steps aside. A report that is NOT terminal (an interim update)
+        // does not silence the automatic report: the child is still working, and the parent will want
+        // to hear how the task ended.
+        if (status === "completed" || status === "failed") {
+            this.reportedChildren.add(childConversationId);
+            await this.watchdog.cancel(childConversationId);
+        }
+        else {
+            await this.watchdog.noteSignal(childConversationId);
+        }
+        return { delivered: true, parentConversationId };
+    }
+    /**
+     * Sets or updates a silence watchdog timer on a child session.
+     */
+    async setWatchdog(options) {
+        const child = this.store.conversation(options.childConversationId);
+        if (!child) {
+            throw new Error(`找不到会话：${options.childConversationId}`);
+        }
+        await this.watchdog.arm({
+            childConversationId: options.childConversationId,
+            parentConversationId: options.parentConversationId,
+            workspaceId: child.workspaceId,
+            timeoutSeconds: options.timeoutSeconds,
+        });
+        return { ok: true, childConversationId: options.childConversationId, timeoutSeconds: options.timeoutSeconds };
+    }
+    /**
+     * Cancels a silence watchdog timer on a child session.
+     */
+    async cancelWatchdog(childConversationId) {
+        await this.watchdog.cancel(childConversationId);
+        return { ok: true };
+    }
+    /**
+     * Re-arms persisted watchdogs from disk.
+     */
+    async restoreWatchdogs() {
+        await this.watchdog.restore();
+    }
     async persistSessionResult(conversationId, failure) {
         const conversation = this.store.conversation(conversationId);
         const workspace = conversation ? this.store.workspace(conversation.workspaceId) : undefined;
         if (!conversation || !workspace)
             return undefined;
+        // THE FILE IS THE CHILD'S PRODUCT, AND THE REPORT USES IT. They used to be the same thing, and
+        // the split is what the user asked for:
+        //   - the FILE is written on every turn, so the reader can open it and `status(includeOutput)`
+        //     can return what the child actually produced;
+        //   - the REPORT to the parent carries that same text, because the parent is waiting for an
+        //     answer. A failure reports the DIAGNOSIS rather than whatever the model managed to say,
+        //     because a broken turn's last words are not a diagnosis of why it broke.
         const output = failure !== undefined
             ? (failure instanceof Error ? failure.message : String(failure))
             : ([...conversation.messages].reverse().find((message) => message.role === "assistant")?.content ?? "");
@@ -175,11 +475,22 @@ export class SessionOrchestratorService {
         if (conversation.status === "running" || conversation.status === "waiting") {
             const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
             if (lastAssistant?.toolCalls?.length) {
-                const lastCall = lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1];
-                if (!lastCall.status || lastCall.live || lastCall.preparing) {
-                    activeTool = { label: lastCall.label, detail: lastCall.detail };
+                const isCompleted = (t) => t.status === "ok" || t.status === "error" || t.status === "done" || t.status === "failed";
+                const isRunning = (t) => !isCompleted(t) && (Boolean(t.preparing) || Boolean(t.live) || !t.status || t.status === "running");
+                const runningCall = [...lastAssistant.toolCalls].reverse().find(isRunning)
+                    ?? (!isCompleted(lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1])
+                        ? lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1]
+                        : undefined);
+                if (runningCall) {
+                    activeTool = {
+                        label: runningCall.label || runningCall.name || "tool",
+                        detail: runningCall.detail || runningCall.live,
+                    };
                 }
             }
+            if (!activeTool && ledgerEntry?.activeTool) {
+                activeTool = { ...ledgerEntry.activeTool };
+            }
         }
         const hasPendingQuestion = this.store.pendingQuestions(conversationId).length > 0;
         let output;
@@ -200,54 +511,113 @@ export class SessionOrchestratorService {
                 }
             }
         }
+        const effectiveStatus = conversation.error
+            ? "failed"
+            : conversation.status;
+        const finalProgress = lastAssistantSnippet ?? ledgerEntry?.lastProgress ?? lastUserSnippet;
         // Sync ledger status if present
-        if (ledgerEntry && ledgerEntry.status !== conversation.status) {
+        if (ledgerEntry && (ledgerEntry.status !== effectiveStatus || ledgerEntry.activeTool !== activeTool || ledgerEntry.lastProgress !== finalProgress)) {
             this.ledger.update(conversationId, {
-                status: conversation.status,
-                lastProgress: lastAssistantSnippet ?? ledgerEntry.lastProgress,
+                status: effectiveStatus,
+                lastProgress: finalProgress,
+                activeTool,
+                ...(conversation.error ? { error: conversation.error } : {}),
             });
         }
         return {
             conversationId: conversation.id,
             workspaceId: conversation.workspaceId,
             title: conversation.title,
-            status: conversation.status,
-            origin: ledgerEntry?.origin ?? "user",
+            status: effectiveStatus,
+            origin: ledgerEntry?.origin ?? conversation.origin ?? "user",
             parentConversationId: conversation.parentConversationId ?? ledgerEntry?.parentConversationId,
-            task: ledgerEntry?.task,
+            task: ledgerEntry?.task ?? (conversation.title && conversation.title !== "新会话" ? conversation.title : undefined),
             messageCount: messages.length,
             turnCount,
             lastAssistantSnippet,
             lastUserSnippet,
             hasPendingQuestion,
             activeTool,
-            error: conversation.error,
+            error: conversation.error ?? ledgerEntry?.error,
             updatedAt: conversation.updatedAt,
-            createdAt: ledgerEntry?.createdAt,
-            lastProgress: ledgerEntry?.lastProgress ?? lastAssistantSnippet,
+            createdAt: ledgerEntry?.createdAt ?? (conversation.messages?.[0]?.createdAt ? new Date(conversation.messages[0].createdAt).getTime() : (conversation.updatedAt ? new Date(conversation.updatedAt).getTime() : Date.now())),
+            lastProgress: finalProgress,
             ...(options?.includeOutput ? { outputPath: resultPath } : {}),
             ...(output !== undefined ? { output, outputTruncated } : {}),
         };
     }
     /**
      * Lists summaries of all sessions, optionally filtered by parent conversation.
+     *
+     * Persisted store conversations are the authoritative source for session tree
+     * parent-child relationships across server restarts, while SessionLedger
+     * enriches live in-memory task, progress, and activeTool state.
      */
     async list(parentConversationId) {
-        const entries = parentConversationId
-            ? this.ledger.listByParent(parentConversationId)
-            : this.ledger.listAll();
+        const targetParentId = parentConversationId?.trim();
+        const candidateIds = new Set();
+        if (targetParentId) {
+            // 1. Check parent in store to know parent's workspace
+            const parentConv = this.store.conversation(targetParentId);
+            if (parentConv) {
+                const workspaceChildren = this.store.conversationsForWorkspace(parentConv.workspaceId);
+                for (const child of workspaceChildren) {
+                    if (child.parentConversationId === targetParentId) {
+                        candidateIds.add(child.id);
+                    }
+                }
+            }
+            else {
+                // Fallback: check all conversations in store
+                const allConversations = this.store.snapshot().conversations;
+                for (const conv of allConversations) {
+                    if (conv.parentConversationId === targetParentId) {
+                        candidateIds.add(conv.id);
+                    }
+                }
+            }
+            // 2. Also check in-memory ledger entries
+            const ledgerEntries = this.ledger.listByParent(targetParentId);
+            for (const entry of ledgerEntries) {
+                candidateIds.add(entry.conversationId);
+            }
+        }
+        else {
+            // No parent specified: list all orchestrator / child sessions
+            for (const conv of this.store.snapshot().conversations) {
+                if (conv.parentConversationId || conv.origin === "orchestrator") {
+                    candidateIds.add(conv.id);
+                }
+            }
+            for (const entry of this.ledger.listAll()) {
+                candidateIds.add(entry.conversationId);
+            }
+        }
+        const parentConv = targetParentId ? this.store.conversation(targetParentId) : undefined;
         const summaries = [];
-        for (const entry of entries) {
+        for (const conversationId of candidateIds) {
             try {
-                const summary = await this.status(entry.conversationId);
+                const summary = await this.status(conversationId);
+                // Workspace boundary enforcement: do not leak sessions across different workspaces
+                if (parentConv && summary.workspaceId !== parentConv.workspaceId) {
+                    continue;
+                }
+                if (targetParentId && summary.parentConversationId !== targetParentId) {
+                    continue;
+                }
                 summaries.push(summary);
             }
             catch {
                 // Conversation was removed from store; prune ledger
-                this.ledger.delete(entry.conversationId);
+                this.ledger.delete(conversationId);
             }
         }
-        return summaries;
+        // Sort newest first by creation time or updated timestamp
+        return summaries.sort((a, b) => {
+            const timeA = a.createdAt ?? (a.updatedAt ? new Date(a.updatedAt).getTime() : 0);
+            const timeB = b.createdAt ?? (b.updatedAt ? new Date(b.updatedAt).getTime() : 0);
+            return timeB - timeA;
+        });
     }
     /**
      * Stops a target session.
@@ -284,6 +654,7 @@ export class SessionOrchestratorService {
             mode = "all";
         }
         this.ledger.update(conversationId, { status: "stopped" });
+        await this.watchdog.cancel(conversationId);
         return { stopped: true, mode };
     }
     /**