agor-live 0.21.2 → 0.22.0

package/dist/daemon/register-routes.js

@@ -315,7 +315,7 @@ var init_mcp_token_authorization = __esm({
 });
 
 // src/utils/session-tasks.ts
-import { TaskStatus as TaskStatus2 } from "@agor/core/types";
+import { EXECUTING_TASK_STATUSES, isTaskExecuting } from "@agor/core/types";
 function recencyKey(t) {
   return new Date(t.started_at || t.created_at).getTime();
 }
@@ -335,22 +335,16 @@ async function findTasksForSession(app, sessionId, params) {
 }
 async function findActiveTasksForSession(app, sessionId, params) {
   const all = await findTasksForSession(app, sessionId, params);
-  return all.filter((t) => ACTIVE_TASK_STATUSES.has(t.status));
+  return all.filter((t) => isTaskExecuting(t));
 }
 async function findHostTaskForSession(app, sessionId, params) {
   const all = await findTasksForSession(app, sessionId, params);
   if (all.length === 0) return void 0;
-  return all.find((t) => ACTIVE_TASK_STATUSES.has(t.status)) ?? all[0];
+  return all.find((t) => isTaskExecuting(t)) ?? all[0];
 }
-var ACTIVE_TASK_STATUSES;
 var init_session_tasks = __esm({
   "src/utils/session-tasks.ts"() {
     "use strict";
-    ACTIVE_TASK_STATUSES = /* @__PURE__ */ new Set([
-      TaskStatus2.RUNNING,
-      TaskStatus2.AWAITING_PERMISSION,
-      TaskStatus2.STOPPING
-    ]);
   }
 });
 
@@ -1330,7 +1324,7 @@ __export(tokens_exports, {
   validateSessionToken: () => validateSessionToken
 });
 import { MCP_TOKEN } from "@agor/core/config";
-import { generateId as generateId5, SessionRepository as SessionRepository3, shortId as shortId8 } from "@agor/core/db";
+import { generateId as generateId5, SessionRepository as SessionRepository3, shortId as shortId9 } from "@agor/core/db";
 import {
   MCP_TOKEN_AUDIENCE,
   MCP_TOKEN_ISSUER
@@ -1384,7 +1378,7 @@ async function generateSessionToken2(app, sessionId, userId) {
   const cached2 = s.tokenCache.get(cacheKey);
   const refreshBufferMs = Math.min(5 * 60 * 1e3, Math.max(30 * 1e3, s.expirationMs * 0.1));
   if (cached2 && cached2.expiresAtMs - nowMs > refreshBufferMs) {
-    mcpTokenDebug(`\u{1F3AB} MCP token cache hit: session=${shortId8(sessionId)}`);
+    mcpTokenDebug(`\u{1F3AB} MCP token cache hit: session=${shortId9(sessionId)}`);
     return cached2.token;
   }
   const sessionExists = await s.sessionRepo.exists(sessionId);
@@ -1410,7 +1404,7 @@ async function generateSessionToken2(app, sessionId, userId) {
   const token = jwt4.sign(payload, jwtSecret, { algorithm: "HS256" });
   s.tokenCache.set(cacheKey, { token, expiresAtMs });
   mcpTokenDebug(
-    `\u{1F3AB} MCP token issued: session=${shortId8(sessionId)} jti=${jti.substring(0, 8)} exp=+${Math.floor(s.expirationMs / 1e3)}s`
+    `\u{1F3AB} MCP token issued: session=${shortId9(sessionId)} jti=${jti.substring(0, 8)} exp=+${Math.floor(s.expirationMs / 1e3)}s`
   );
   return token;
 }
@@ -1450,7 +1444,7 @@ async function validateSessionToken(app, token) {
   }
   const sessionExists = await s.sessionRepo.exists(sessionId);
   if (!sessionExists) {
-    console.warn(`[mcp-tokens] token rejected: session ${shortId8(sessionId)} not found`);
+    console.warn(`[mcp-tokens] token rejected: session ${shortId9(sessionId)} not found`);
     return null;
   }
   return { sessionId, userId, jti: payload.jti };
@@ -1500,11 +1494,11 @@ import {
 import {
   generateId as generateId6,
   SessionRepository as SessionRepository4,
-  shortId as shortId9,
+  shortId as shortId10,
   TaskRepository
 } from "@agor/core/db";
 import {
-  SessionStatus as SessionStatus3,
+  SessionStatus as SessionStatus4,
   TaskStatus as TaskStatus4
 } from "@agor/core/types";
 import {
@@ -1522,7 +1516,7 @@ async function persistActiveTurnSnapshot(app, sessionId, turn) {
   const repo = new SessionRepository4(db);
   const row = await repo.findById(sessionId);
   if (!row) {
-    throw new Error(`persistActiveTurnSnapshot: session not found: ${shortId9(sessionId)}`);
+    throw new Error(`persistActiveTurnSnapshot: session not found: ${shortId10(sessionId)}`);
   }
   const patch = {
     cli_state: {
@@ -1702,7 +1696,7 @@ function buildCliEventSink(app) {
       });
       app.service("tasks").emit("created", task);
       await app.service("sessions").patch(sessionId, {
-        status: SessionStatus3.RUNNING,
+        status: SessionStatus4.RUNNING,
         ready_for_prompt: false,
         tasks: [...session.tasks, task.task_id]
       }).catch((err) => {
@@ -1979,7 +1973,7 @@ function buildCliEventSink(app) {
         }
         try {
           const patch = {
-            status: SessionStatus3.IDLE,
+            status: SessionStatus4.IDLE,
             ready_for_prompt: true
           };
           if (computedContextWindow !== void 0) {
@@ -2044,7 +2038,7 @@ function buildSpawnConfigForSession(session, branchCwd, opts = {}) {
   return {
     sessionId: transcriptExists ? void 0 : session.session_id,
     resumeSessionId: transcriptExists ? session.session_id : void 0,
-    displayName: `cli-${shortId9(session.session_id)}`,
+    displayName: `cli-${shortId10(session.session_id)}`,
     model: session.model_config?.model,
     effort: session.model_config?.effort,
     advisorModel: session.model_config?.advisorModel,
@@ -2161,7 +2155,7 @@ async function writeClaudeCliMcpConfigForSession(app, session, opts = {}) {
     sessionCreatedBy: session.created_by
   })) {
     console.warn(
-      `[claude-cli-integration] not writing owner-scoped MCP config for session ${shortId9(session.session_id)}: caller ${opts.actor.user_id ?? "anonymous"} cannot receive session creator token`
+      `[claude-cli-integration] not writing owner-scoped MCP config for session ${shortId10(session.session_id)}: caller ${opts.actor.user_id ?? "anonymous"} cannot receive session creator token`
     );
     return void 0;
   }
@@ -2178,12 +2172,12 @@ async function writeClaudeCliMcpConfigForSession(app, session, opts = {}) {
     });
     return writeClaudeCliMcpConfigFile({
       mcpConfig,
-      sessionShortId: shortId9(session.session_id),
+      sessionShortId: shortId10(session.session_id),
       targetUnixUser: resolveClaudeCliMcpConfigTargetUnixUser(config2, session)
     });
   } catch (err) {
     console.warn(
-      `[claude-cli-integration] failed to write MCP config for session ${shortId9(session.session_id)}; Agor MCP tools will be unavailable in Claude CLI/RemoteTrigger:`,
+      `[claude-cli-integration] failed to write MCP config for session ${shortId10(session.session_id)}; Agor MCP tools will be unavailable in Claude CLI/RemoteTrigger:`,
       err instanceof Error ? err.message : String(err)
     );
     return void 0;
@@ -2210,7 +2204,7 @@ async function onCliSessionCreated(app, session, branchCwd) {
   const mcpConfigPath = await writeClaudeCliMcpConfigForSession(app, session);
   const spawnCfg = buildSpawnConfigForSession(session, branchCwd, { mcpConfigPath });
   const built = buildClaudeCliSpawn(spawnCfg);
-  const tabName = spawnCfg.displayName ?? `cli-${shortId9(session.session_id)}`;
+  const tabName = spawnCfg.displayName ?? `cli-${shortId10(session.session_id)}`;
   const persister = buildCliPersister(app);
   await persister.saveOffset(session.session_id, {
     watcher_offset: 0,
@@ -18113,6 +18107,7 @@ IMPORTANT:
         {
           folderPath,
           branch_id: resolvedBranchId,
+          source_session_id: ctx.sessionId,
           subpath,
           board_id: resolvedBoardId,
           name: coerceString(args.name),
@@ -19045,7 +19040,7 @@ var init_environment_helpers = __esm({
 // src/mcp/tools/branches.ts
 import { existsSync as existsSync3 } from "fs";
 import { isBranchRbacEnabled } from "@agor/core/config";
-import { BranchRepository as BranchRepository3, shortId as shortId10 } from "@agor/core/db";
+import { BranchRepository as BranchRepository3, shortId as shortId11 } from "@agor/core/db";
 import { BRANCH_PERMISSION_LEVELS as BRANCH_PERMISSION_LEVELS2, getAssistantConfig, isAssistant } from "@agor/core/types";
 import { computeZoneRelativePosition } from "@agor/core/utils/board-placement";
 import { normalizeOptionalHttpUrl } from "@agor/core/utils/url";
@@ -19654,7 +19649,7 @@ function registerBranchTools(server, ctx) {
       }
       const targetSessionId = rawTargetSessionId ? await resolveSessionId(ctx, rawTargetSessionId) : void 0;
       console.log(
-        zoneId === null ? `\u{1F4CD} MCP clearing zone pin for branch ${shortId10(branchId)}` : `\u{1F4CD} MCP pinning branch ${shortId10(branchId)} to zone ${zoneId}`
+        zoneId === null ? `\u{1F4CD} MCP clearing zone pin for branch ${shortId11(branchId)}` : `\u{1F4CD} MCP pinning branch ${shortId11(branchId)} to zone ${zoneId}`
       );
       const branch = await ctx.app.service("branches").get(branchId, ctx.baseServiceParams);
       const boardObjectsService = ctx.app.service("board-objects");
@@ -19717,7 +19712,7 @@ function registerBranchTools(server, ctx) {
       const hasZoneTrigger = zone.trigger?.template && zone.trigger.template.trim().length > 0;
       const isAlwaysNew = hasZoneTrigger && zone.trigger.behavior === "always_new";
       if (triggerTemplate && targetSessionId && hasZoneTrigger) {
-        console.log(`\u{1F3AF} Triggering zone prompt template for session ${shortId10(targetSessionId)}`);
+        console.log(`\u{1F3AF} Triggering zone prompt template for session ${shortId11(targetSessionId)}`);
         const { renderTemplate: renderTemplate2 } = await import("@agor/core/templates/handlebars-helpers");
         const { buildZoneTriggerContext: buildZoneTriggerContext2 } = await import("@agor/core/templates/zone-trigger-context");
         let targetSession;
@@ -19750,7 +19745,7 @@ function registerBranchTools(server, ctx) {
               note: "Session is busy. Zone trigger prompt has been queued."
             };
             console.log(
-              `\u{1F4EC} Zone trigger queued for session ${shortId10(targetSessionId)} at position ${task.queue_position}`
+              `\u{1F4EC} Zone trigger queued for session ${shortId11(targetSessionId)} at position ${task.queue_position}`
             );
           } else {
             promptResult = {
@@ -19758,7 +19753,7 @@ function registerBranchTools(server, ctx) {
               sessionId: targetSessionId,
               note: "Zone trigger prompt sent to target session"
             };
-            console.log(`\u2705 Zone trigger executed: task ${shortId10(task.task_id)}`);
+            console.log(`\u2705 Zone trigger executed: task ${shortId11(task.task_id)}`);
           }
         } else {
           promptResult = {
@@ -19768,7 +19763,7 @@ function registerBranchTools(server, ctx) {
         }
       } else if (isAlwaysNew) {
         console.log(
-          `\u{1F3AF} Zone has always_new trigger, auto-creating session for branch ${shortId10(branchId)}`
+          `\u{1F3AF} Zone has always_new trigger, auto-creating session for branch ${shortId11(branchId)}`
         );
         try {
           const user = await ctx.app.service("users").get(ctx.userId, ctx.baseServiceParams);
@@ -19783,13 +19778,13 @@ function registerBranchTools(server, ctx) {
             userId: ctx.userId
           });
           const agenticTool = newSession.agentic_tool;
-          console.log(`\u2705 Auto-created session ${shortId10(newSession.session_id)} (${agenticTool})`);
+          console.log(`\u2705 Auto-created session ${shortId11(newSession.session_id)} (${agenticTool})`);
           promptResult = {
             taskId: task.task_id,
             sessionId: newSession.session_id,
-            note: `always_new trigger: created session ${shortId10(newSession.session_id)} (${agenticTool}) and sent prompt`
+            note: `always_new trigger: created session ${shortId11(newSession.session_id)} (${agenticTool}) and sent prompt`
           };
-          console.log(`\u2705 Zone trigger executed: task ${shortId10(task.task_id)}`);
+          console.log(`\u2705 Zone trigger executed: task ${shortId11(task.task_id)}`);
         } catch (error51) {
           const message = error51 instanceof Error ? error51.message : String(error51);
           if (message.includes("rendered to an empty prompt")) {
@@ -20524,7 +20519,11 @@ function registerEnvironmentTools(server, ctx) {
           branchId,
           ctx.baseServiceParams
         );
-        return textResult({ success: true, branch });
+        return textResult({
+          success: true,
+          branch,
+          message: "Environment start requested. Poll agor_environment_health and agor_environment_logs for readiness, progress, or failures."
+        });
       } catch (error51) {
         const errorMessage = error51 instanceof Error ? error51.message : "Unknown error";
         const commandOutput = error51 instanceof Error ? error51.commandOutput : void 0;
@@ -20553,7 +20552,11 @@ function registerEnvironmentTools(server, ctx) {
           branchId,
           ctx.baseServiceParams
         );
-        return textResult({ success: true, branch });
+        return textResult({
+          success: true,
+          branch,
+          message: "Environment stop requested. Poll agor_environment_health for final status and agor_environment_logs for command output."
+        });
       } catch (error51) {
         return textResult({
           success: false,
@@ -20595,7 +20598,7 @@ function registerEnvironmentTools(server, ctx) {
   server.registerTool(
     "agor_environment_logs",
     {
-      description: "Fetch recent logs from a branch environment (non-streaming, last ~100 lines; shell command by default, or HTTP(S) GET webhook when URL-shaped / webhook-only mode)",
+      description: "Fetch recent logs from a branch environment (non-streaming, last ~500 lines; shell command by default, or HTTP(S) GET webhook when URL-shaped / webhook-only mode)",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
         branchId: mcpRequiredId("branchId", "Branch")
@@ -20684,7 +20687,7 @@ function registerEnvironmentTools(server, ctx) {
           return textResult({
             success: true,
             branch: started,
-            message: `Environment variant set to "${updated.environment_variant}" and started.`
+            message: `Environment variant set to "${updated.environment_variant}" and start requested. Poll agor_environment_health and agor_environment_logs for readiness, progress, or failures.`
           });
         } catch (startError) {
           const startMessage = startError instanceof Error ? startError.message : "Unknown error";
@@ -20728,7 +20731,7 @@ function registerEnvironmentTools(server, ctx) {
         return textResult({
           success: true,
           branch,
-          message: "Environment nuked successfully - all data and volumes destroyed"
+          message: "Environment nuke requested. Poll agor_environment_health for final status and agor_environment_logs for command output."
         });
       } catch (error51) {
         return textResult({
@@ -20841,7 +20844,7 @@ var init_markdown_outline = __esm({
 import {
   BranchRepository as BranchRepository4,
   KnowledgeNamespaceRepository,
-  shortId as shortId11
+  shortId as shortId12
 } from "@agor/core/db";
 import { getAssistantConfig as getAssistantConfig2, isAssistant as isAssistant2 } from "@agor/core/types";
 var ASSISTANT_MEMORY_PATH_TEMPLATE, ASSISTANT_NAMESPACE_MISSING_MESSAGE;
@@ -23713,7 +23716,11 @@ var init_search = __esm({
 });
 
 // src/mcp/tools/sessions.ts
-import { BranchRepository as BranchRepository6, shortId as shortId12 } from "@agor/core/db";
+import {
+  BranchRepository as BranchRepository6,
+  SessionRelationshipRepository,
+  shortId as shortId13
+} from "@agor/core/db";
 import {
   AVAILABLE_CLAUDE_MODEL_ALIASES,
   CODEX_MODEL_METADATA,
@@ -24219,10 +24226,70 @@ function registerSessionTools(server, ctx) {
       return textResult({ error: `Unknown mode: ${mode}` });
     }
   );
+  server.registerTool(
+    "agor_session_relationships_list",
+    {
+      description: "List durable non-genealogy relationships for a session, including cross-branch remote-created child/parent links. Defaults to the current session.",
+      annotations: { readOnlyHint: true },
+      inputSchema: external_exports.object({
+        sessionId: mcpOptionalId(
+          "sessionId",
+          "Session",
+          "Session ID to inspect (defaults to current session)"
+        )
+      })
+    },
+    async (args) => {
+      const sessionId = args.sessionId ? await resolveSessionId(ctx, args.sessionId) : ctx.sessionId;
+      if (!sessionId) return sessionContextRequiredResult();
+      await ctx.app.service("sessions").get(sessionId, ctx.baseServiceParams);
+      const relationships = await new SessionRelationshipRepository(ctx.db).findForSession(
+        sessionId
+      );
+      return textResult({ relationships });
+    }
+  );
+  server.registerTool(
+    "agor_session_relationships_set_callback",
+    {
+      description: "Enable or disable callback/report-back delivery for a durable session relationship without deleting the relationship itself.",
+      inputSchema: external_exports.object({
+        relationshipId: mcpRequiredString(
+          "relationshipId",
+          "Session relationship ID returned by agor_session_relationships_list"
+        ),
+        callbackEnabled: external_exports.boolean().describe("Whether the remote child should report back.")
+      })
+    },
+    async (args) => {
+      const repo = new SessionRelationshipRepository(ctx.db);
+      const relationshipId = args.relationshipId;
+      const existingRelationship = await repo.get(relationshipId);
+      await ctx.app.service("sessions").get(existingRelationship.source_session_id, ctx.baseServiceParams);
+      const targetSession = await ctx.app.service("sessions").get(existingRelationship.target_session_id, ctx.baseServiceParams);
+      const relationship = await repo.setCallbackEnabled(relationshipId, args.callbackEnabled);
+      const callbackSessionId = relationship.callback_session_id ?? relationship.source_session_id;
+      await ctx.app.service("sessions").patch(
+        relationship.target_session_id,
+        {
+          callback_config: {
+            ...targetSession.callback_config ?? {},
+            enabled: args.callbackEnabled,
+            callback_session_id: callbackSessionId
+          }
+        },
+        {
+          ...ctx.baseServiceParams,
+          _skipRelationshipCallbackSync: true
+        }
+      );
+      return textResult({ relationship });
+    }
+  );
   server.registerTool(
     "agor_sessions_create",
     {
-      description: 'Create a new session in an existing branch. Use for starting fresh work on a new task in the same codebase (e.g., new feature branch, separate investigation). Unlike spawn, this creates an independent session with no parent-child relationship. MCP servers are inherited from the branch (if configured) or user defaults, or can be overridden via `mcpServerIds`. Model selection falls back to user defaults and can be overridden via `modelConfig` (accepts either a model ID string like "claude-opus-4-6" or a full {mode, model, effort, advisorModel, provider} object \u2014 call `agor_models_list` to discover valid model IDs per agenticTool). Supports optional callbacks to notify the creating session when the new session completes.',
+      description: 'Create a new session in an existing branch. When called from an MCP session context in the same target branch (the default for branch-local orchestrator agents), the new session is automatically linked to the calling session as its parent \u2014 pass `parentSessionId: null` to create an unlinked root session instead. Cross-branch sessions are not genealogy-linked automatically; use callbacks for remote completion routing. Use for starting work on a new task in the same codebase (e.g., new feature branch, separate investigation). MCP servers are inherited from the branch (if configured) or user defaults, or can be overridden via `mcpServerIds`. Model selection falls back to user defaults and can be overridden via `modelConfig` (accepts either a model ID string like "claude-opus-4-6" or a full {mode, model, effort, advisorModel, provider} object \u2014 call `agor_models_list` to discover valid model IDs per agenticTool). Supports optional callbacks to notify the creating session when the new session completes.',
       inputSchema: external_exports.object({
         branchId: mcpRequiredId(
           "branchId",
@@ -24252,6 +24319,9 @@ function registerSessionTools(server, ctx) {
         callbackMode: external_exports.enum(["once", "persistent"]).optional().describe(
           'Callback firing mode: "once" (default) fires on first completion then auto-disables, "persistent" fires on every completion'
         ),
+        parentSessionId: external_exports.string().min(1, "parentSessionId cannot be empty when provided.").nullish().describe(
+          "Parent session ID to link this session to in the branch-local genealogy tree. Must be in the target branch. When omitted and called from a session MCP context in the same branch, automatically defaults to the calling session. Pass null to explicitly create a root session with no parent; use callbackSessionId for cross-branch routing."
+        ),
         mcpServerIds: external_exports.array(mcpRequiredId("mcpServerIds[]", "MCP server")).optional().describe(
           "MCP server IDs to attach. Overrides branch and user default inheritance. Omit to use branch config > user defaults."
         ),
@@ -24306,6 +24376,37 @@ function registerSessionTools(server, ctx) {
       if (wantsCallback) {
         callbackConfig.callback_mode = args.callbackMode ?? "once";
       }
+      let resolvedParentSessionId;
+      let parentSessionForPatch;
+      let skippedAutoParentDueToBranchMismatch = false;
+      let remoteRelationshipSourceSessionId;
+      let remoteRelationshipSourceBranchId;
+      if (args.parentSessionId !== void 0) {
+        if (args.parentSessionId !== null) {
+          resolvedParentSessionId = await resolveSessionId(ctx, args.parentSessionId);
+          parentSessionForPatch = await ctx.app.service("sessions").get(resolvedParentSessionId, ctx.baseServiceParams);
+          if (parentSessionForPatch.branch_id !== branch.branch_id) {
+            throw new Error(
+              `parentSessionId must reference a session in the target branch (${shortId13(branch.branch_id)}). For cross-branch completion routing, use enableCallback/callbackSessionId instead of genealogy.`
+            );
+          }
+        }
+      } else if (ctx.sessionId) {
+        const callingSession = await ctx.app.service("sessions").get(ctx.sessionId, ctx.baseServiceParams);
+        if (callingSession.branch_id === branch.branch_id) {
+          resolvedParentSessionId = callingSession.session_id;
+          parentSessionForPatch = callingSession;
+        } else {
+          skippedAutoParentDueToBranchMismatch = true;
+          remoteRelationshipSourceSessionId = callingSession.session_id;
+          remoteRelationshipSourceBranchId = callingSession.branch_id;
+        }
+      }
+      if (remoteRelationshipSourceSessionId && effectiveCallbackSessionId) {
+        callbackConfig.enabled ??= Boolean(wantsCallback);
+        callbackConfig.callback_session_id ??= effectiveCallbackSessionId;
+        callbackConfig.callback_created_by ??= ctx.userId;
+      }
       const sessionData = {
         branch_id: branch.branch_id,
         agentic_tool: agenticTool,
@@ -24323,10 +24424,44 @@ function registerSessionTools(server, ctx) {
           base_sha: currentSha,
           current_sha: currentSha
         },
-        genealogy: { children: [] },
+        genealogy: {
+          ...resolvedParentSessionId && { parent_session_id: resolvedParentSessionId },
+          children: []
+        },
         tasks: []
       };
       const session = await ctx.app.service("sessions").create(sessionData, ctx.baseServiceParams);
+      const remoteRelationship = remoteRelationshipSourceSessionId ? await new SessionRelationshipRepository(ctx.db).create({
+        source_session_id: remoteRelationshipSourceSessionId,
+        target_session_id: session.session_id,
+        relationship_type: "remote_create",
+        created_by: ctx.userId,
+        callback_enabled: Boolean(wantsCallback),
+        // Keep the durable relationship target even when callbacks are
+        // muted. callback_enabled/callback_config.enabled are the delivery
+        // switches; callback_session_id is the stable endpoint to re-enable.
+        callback_session_id: effectiveCallbackSessionId ? effectiveCallbackSessionId : null,
+        data: {
+          source_branch_id: remoteRelationshipSourceBranchId,
+          target_branch_id: branch.branch_id
+        }
+      }) : null;
+      if (remoteRelationship && remoteRelationshipSourceSessionId) {
+        const sourceSession = await ctx.app.service("sessions").get(remoteRelationshipSourceSessionId, ctx.baseServiceParams);
+        ctx.app.service("sessions").emit?.("patched", sourceSession, ctx.baseServiceParams);
+      }
+      if (resolvedParentSessionId && parentSessionForPatch) {
+        await ctx.app.service("sessions").patch(
+          resolvedParentSessionId,
+          {
+            genealogy: {
+              ...parentSessionForPatch.genealogy,
+              children: [...parentSessionForPatch.genealogy?.children ?? [], session.session_id]
+            }
+          },
+          ctx.baseServiceParams
+        );
+      }
       const mcpAttachFailures = [];
       if (mcpServerIds && mcpServerIds.length > 0) {
         for (const mcpServerId of mcpServerIds) {
@@ -24354,12 +24489,14 @@ function registerSessionTools(server, ctx) {
           { ...ctx.baseServiceParams, route: { id: session.session_id } }
         );
       }
-      const callbackNote = callbackConfig.callback_session_id ? ` Callback will be sent to session ${shortId12(callbackConfig.callback_session_id)} on completion.` : "";
+      const callbackNote = callbackConfig.callback_session_id ? ` Callback will be sent to session ${shortId13(callbackConfig.callback_session_id)} on completion.` : "";
+      const parentNote = resolvedParentSessionId ? ` Linked to parent session ${shortId13(resolvedParentSessionId)}.` : skippedAutoParentDueToBranchMismatch ? " Not genealogy-linked because the target branch differs from the calling session branch." : "";
       const mcpFailureNote = mcpAttachFailures.length > 0 ? ` Warning: ${mcpAttachFailures.length} requested MCP server(s) failed to attach \u2014 see mcpAttachFailures.` : "";
       return textResult({
         session: redactSessionForMcp(session),
         taskId: initialTask?.task_id,
-        note: args.initialPrompt ? `Session created and initial prompt execution started.${callbackNote}${mcpFailureNote}` : `Session created successfully.${callbackNote}${mcpFailureNote}`,
+        note: args.initialPrompt ? `Session created and initial prompt execution started.${parentNote}${callbackNote}${mcpFailureNote}` : `Session created successfully.${parentNote}${callbackNote}${mcpFailureNote}`,
+        ...remoteRelationship && { remoteRelationship },
         ...mcpAttachFailures.length > 0 && { mcpAttachFailures }
       });
     }
@@ -24608,7 +24745,7 @@ function registerSessionTools(server, ctx) {
   server.registerTool(
     "agor_sessions_stop",
     {
-      description: "Stop a running session. Kills the executor process and sets the session to idle. Use this for emergency stops, timeout-based cancellation, or human-in-the-loop gates. Only works on sessions in active states (running, awaiting_permission, stopping).",
+      description: "Stop a running session. Kills the executor process and sets the session to idle. Use this for emergency stops, timeout-based cancellation, or human-in-the-loop gates. Only works on sessions in active states (running, stopping, awaiting_permission, awaiting_input).",
       annotations: { destructiveHint: true },
       inputSchema: external_exports.object({
         sessionId: mcpRequiredId("sessionId", "Session", "Session ID to stop (UUIDv7 or short ID)"),
@@ -25242,7 +25379,7 @@ __export(server_exports, {
   textResult: () => textResult
 });
 import { randomUUID as randomUUID2 } from "crypto";
-import { shortId as shortId13, UserApiKeysRepository } from "@agor/core/db";
+import { shortId as shortId14, UserApiKeysRepository } from "@agor/core/db";
 import { getServiceTier as getServiceTier2, SERVICE_GROUP_TO_MCP_DOMAINS, SERVICE_TIER_RANK } from "@agor/core/types";
 import { NotFoundError as NotFoundError3 } from "@agor/core/utils/errors";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -25553,7 +25690,7 @@ function setupMCPRoutes(app, db, toolSearchEnabled = true, servicesConfig) {
         }
       }
       mcpRequestDebug(
-        `\u{1F50C} MCP request authenticated (user: ${shortId13(userId)}, session: ${sessionId ? shortId13(sessionId) : "none"})`
+        `\u{1F50C} MCP request authenticated (user: ${shortId14(userId)}, session: ${sessionId ? shortId14(sessionId) : "none"})`
       );
       const mcpContext = {
         app,
@@ -25794,7 +25931,7 @@ import {
   ScheduleRepository as ScheduleRepository2,
   SessionMCPServerRepository as SessionMCPServerRepository2,
   SessionRepository as SessionRepository6,
-  shortId as shortId14,
+  shortId as shortId15,
   TaskRepository as TaskRepository2,
   UsersRepository as UsersRepository3
 } from "@agor/core/db";
@@ -25816,7 +25953,7 @@ import {
   MessageRole as MessageRole4,
   ROLES as ROLES9,
   SERVICE_GROUP_NAMES as SERVICE_GROUP_NAMES2,
-  SessionStatus as SessionStatus4,
+  SessionStatus as SessionStatus5,
   TaskStatus as TaskStatus5
 } from "@agor/core/types";
 import { NotFoundError as NotFoundError4 } from "@agor/core/utils/errors";
@@ -26972,24 +27109,97 @@ function ensureScheduleRunsAsCaller(options) {
   };
 }
 
+// src/utils/session-stop.ts
+init_session_tasks();
+import { shortId as shortId6 } from "@agor/core/db";
+import { isSessionExecuting, SessionStatus as SessionStatus2, TaskStatus } from "@agor/core/types";
+async function markStoppedSessionPromptableNoDrain(sessionsService, sessionId, params) {
+  await sessionsService.patch(
+    sessionId,
+    {
+      status: SessionStatus2.IDLE,
+      ready_for_prompt: true
+    },
+    {
+      ...params ?? {},
+      suppressTerminalQueueProcessing: true
+    }
+  );
+}
+async function stopSessionPreserveQueue(deps, sessionId, params = {}, options = {}) {
+  const session = await deps.sessionsService.get(sessionId, params);
+  if (!isSessionExecuting(session)) {
+    return {
+      success: false,
+      reason: `Session cannot be stopped (status: ${session.status})`
+    };
+  }
+  const targetTasksArray = await findActiveTasksForSession(deps.app, sessionId, params);
+  const queuedTasks = await deps.taskRepo.findQueued(sessionId);
+  if (targetTasksArray.length === 0) {
+    console.warn(
+      `\u26A0\uFE0F  [Stop] No active tasks for session ${shortId6(sessionId)}, resetting to IDLE${options.reason ? ` (reason: ${options.reason})` : ""}`
+    );
+    await markStoppedSessionPromptableNoDrain(deps.sessionsService, sessionId, params);
+    return {
+      success: true,
+      status: SessionStatus2.IDLE,
+      reason: "No active tasks found, session reset to idle",
+      queuedTasksPreserved: queuedTasks.length
+    };
+  }
+  const latestTask = targetTasksArray[0];
+  console.log(
+    `\u{1F6D1} [Stop] Stopping task ${shortId6(latestTask.task_id)} for session ${shortId6(sessionId)}${options.reason ? ` (reason: ${options.reason})` : ""}`
+  );
+  const processKilled = deps.killExecutorProcess(sessionId);
+  if (!processKilled) {
+    console.warn(
+      `\u26A0\uFE0F  [Stop] No tracked process for session ${shortId6(sessionId)} \u2014 executor may have already exited`
+    );
+  }
+  try {
+    await deps.tasksService.patch(
+      latestTask.task_id,
+      {
+        status: TaskStatus.STOPPED,
+        completed_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        ...params,
+        suppressTerminalQueueProcessing: true,
+        suppressCompletionCallbacks: true
+      }
+    );
+  } catch (error51) {
+    console.error(`\u274C [Stop] Failed to patch task to STOPPED:`, error51);
+  }
+  await markStoppedSessionPromptableNoDrain(deps.sessionsService, sessionId, params);
+  return {
+    success: true,
+    status: SessionStatus2.IDLE,
+    stoppedTaskId: latestTask.task_id,
+    queuedTasksPreserved: queuedTasks.length
+  };
+}
+
 // src/utils/session-task-state.ts
-import { isTerminalTaskStatus, SessionStatus as SessionStatus2, TaskStatus } from "@agor/core/types";
+import {
+  isTerminalTaskStatus,
+  SessionStatus as SessionStatus3,
+  sessionCanStartTask,
+  TaskStatus as TaskStatus2
+} from "@agor/core/types";
 function isTaskBlockingPrompt(task) {
-  return task.status !== TaskStatus.QUEUED && !isTerminalTaskStatus(task.status);
-}
-function sessionCanStartTask(status, readyForPrompt) {
-  return status === SessionStatus2.IDLE || status === SessionStatus2.FAILED && readyForPrompt === true;
+  return task.status !== TaskStatus2.QUEUED && !isTerminalTaskStatus(task.status);
 }
 function shouldReconcileSessionPromptState(session, tasks, options = {}) {
-  if (session.status !== SessionStatus2.FAILED) return false;
+  if (session.status !== SessionStatus3.FAILED) return false;
   if (session.ready_for_prompt === true) return false;
   const ignoredTaskIds = new Set(options.ignoredTaskIds ?? []);
   return !tasks.some((task) => !ignoredTaskIds.has(task.task_id) && isTaskBlockingPrompt(task));
 }
 
-// src/register-routes.ts
-init_session_tasks();
-
 // src/utils/session-turn-lock.ts
 async function withSessionTurnLock(locks, sessionId, fn) {
   while (locks.has(sessionId)) {
@@ -27009,7 +27219,7 @@ async function withSessionTurnLock(locks, sessionId, fn) {
 }
 
 // src/utils/task-runner.ts
-import { shortId as shortId6 } from "@agor/core/db";
+import { shortId as shortId7 } from "@agor/core/db";
 import { Conflict, NotFound as NotFound2 } from "@agor/core/feathers";
 import { TaskStatus as TaskStatus3 } from "@agor/core/types";
 async function runExistingTask(task, options, params, deps) {
@@ -27019,7 +27229,7 @@ async function runExistingTask(task, options, params, deps) {
   }
   if (fresh.status !== TaskStatus3.CREATED) {
     throw new Conflict(
-      `Task ${shortId6(task.task_id)} cannot be run: status is '${fresh.status}' (only 'created' tasks may be triggered; the task may have been started by another caller or drained from the queue).`
+      `Task ${shortId7(task.task_id)} cannot be run: status is '${fresh.status}' (only 'created' tasks may be triggered; the task may have been started by another caller or drained from the queue).`
     );
   }
   return await deps.spawnFn(fresh, options, params);
@@ -27035,7 +27245,7 @@ function normalizeMessageSource(input, params) {
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import { shortId as shortId7 } from "@agor/core/db";
+import { shortId as shortId8 } from "@agor/core/db";
 import multer from "multer";
 var ALLOWED_UPLOAD_MIME_TYPES = /* @__PURE__ */ new Set([
   // Images
@@ -27074,7 +27284,7 @@ function createUploadStorage(sessionRepo, branchRepo) {
         }
         if (DEBUG_UPLOAD) {
           console.log(
-            `\u{1F4C2} [Upload Storage] Processing upload for session ${sessionId ? shortId7(sessionId) : "unknown"}`
+            `\u{1F4C2} [Upload Storage] Processing upload for session ${sessionId ? shortId8(sessionId) : "unknown"}`
           );
           console.log(`   Destination type: ${destination}`);
         }
@@ -27084,16 +27294,16 @@ function createUploadStorage(sessionRepo, branchRepo) {
         }
         const session = await sessionRepo.findById(sessionId);
         if (!session) {
-          console.error(`\u274C [Upload Storage] Session not found: ${shortId7(sessionId)}`);
+          console.error(`\u274C [Upload Storage] Session not found: ${shortId8(sessionId)}`);
           return cb(new Error(`Session not found: ${sessionId}`), "");
         }
         if (!session.branch_id) {
-          console.error(`\u274C [Upload Storage] Session ${shortId7(sessionId)} has no branch`);
+          console.error(`\u274C [Upload Storage] Session ${shortId8(sessionId)} has no branch`);
           return cb(new Error(`Session ${sessionId} has no associated branch`), "");
         }
         const branch = await branchRepo.findById(session.branch_id);
         if (!branch) {
-          console.error(`\u274C [Upload Storage] Branch not found: ${shortId7(session.branch_id)}`);
+          console.error(`\u274C [Upload Storage] Branch not found: ${shortId8(session.branch_id)}`);
           return cb(new Error(`Branch not found: ${session.branch_id}`), "");
         }
         const paths = {
@@ -27358,6 +27568,9 @@ var AgorLocalStrategy = class extends LocalStrategy {
     return super.findEntity(username, params);
   }
 };
+function isServiceAccountRoute(params) {
+  return params.user?._isServiceAccount === true;
+}
 function isPaginated(result) {
   return !Array.isArray(result) && "data" in result && "total" in result;
 }
@@ -27632,6 +27845,12 @@ async function registerRoutes(ctx) {
     {
       async create(data, params) {
         app.service("messages").emit(data.event, data.data);
+        if (isServiceAccountRoute(params) && (data.event === "streaming:start" || data.event === "streaming:chunk" || data.event === "streaming:end" || data.event === "streaming:error")) {
+          void app.service("gateway").handleMessageStreamingEvent(
+            data.event,
+            data.data
+          );
+        }
         return { success: true };
       }
     },
@@ -27645,8 +27864,19 @@ async function registerRoutes(ctx) {
     "/tasks/streaming",
     {
       async create(data, params) {
-        const _ = params;
         app.service("tasks").emit(data.event, data.data);
+        if (isServiceAccountRoute(params) && data.event === "tool:start") {
+          const sessionId = typeof data.data.session_id === "string" ? data.data.session_id : void 0;
+          const toolName = typeof data.data.tool_name === "string" ? data.data.tool_name : void 0;
+          if (sessionId) {
+            void app.service("gateway").updateProgress({
+              session_id: sessionId,
+              state: "working",
+              task_id: typeof data.data.task_id === "string" ? data.data.task_id : void 0,
+              tool_name: toolName
+            });
+          }
+        }
         return { success: true };
       }
     },
@@ -27662,9 +27892,9 @@ async function registerRoutes(ctx) {
       async create(data, params) {
         const id = params.route?.id;
         if (!id) throw new Error("Session ID required");
-        console.log(`\u{1F500} Forking session: ${shortId14(id)}`);
+        console.log(`\u{1F500} Forking session: ${shortId15(id)}`);
         const forkedSession = await sessionsService.fork(id, data, params);
-        console.log(`\u2705 Fork created: ${shortId14(forkedSession.session_id)}`);
+        console.log(`\u2705 Fork created: ${shortId15(forkedSession.session_id)}`);
         console.log("\u{1F4E1} [FORK] Manually broadcasting created event to all clients");
         if (app.io) {
           app.io.emit("sessions created", forkedSession);
@@ -27684,9 +27914,9 @@ async function registerRoutes(ctx) {
       async create(data, params) {
         const id = params.route?.id;
         if (!id) throw new Error("Session ID required");
-        console.log(`\u{1F331} Spawning session from: ${shortId14(id)}`);
+        console.log(`\u{1F331} Spawning session from: ${shortId15(id)}`);
         const spawnedSession = await sessionsService.spawn(id, data, params);
-        console.log(`\u2705 Spawn created: ${shortId14(spawnedSession.session_id)}`);
+        console.log(`\u2705 Spawn created: ${shortId15(spawnedSession.session_id)}`);
         console.log("\u{1F4E1} [SPAWN] Manually broadcasting created event to all clients");
         if (app.io) {
           app.io.emit("sessions created", spawnedSession);
@@ -27737,7 +27967,7 @@ async function registerRoutes(ctx) {
         })) {
           throw new Forbidden9("You can only restart Claude CLI sessions you created.");
         }
-        const tabName = `cli-${shortId14(session.session_id)}`;
+        const tabName = `cli-${shortId15(session.session_id)}`;
         const channel = `user/${targetUserId}/terminal`;
         try {
           const { spawn: spawnProc } = await import("child_process");
@@ -27797,25 +28027,25 @@ async function registerRoutes(ctx) {
       return true;
     } catch (error51) {
       if (error51 instanceof NotFoundError4 || error51 instanceof Error && error51.message.includes("No record found")) {
-        console.log(`\u26A0\uFE0F  ${entityType} ${shortId14(id)} was deleted mid-execution - skipping update`);
+        console.log(`\u26A0\uFE0F  ${entityType} ${shortId15(id)} was deleted mid-execution - skipping update`);
         return false;
       }
       throw error51;
     }
   }
   async function reconcileSessionPromptStateIfStuck(session, taskRepo, params, options = {}) {
-    if (session.status !== SessionStatus4.FAILED || session.ready_for_prompt === true) {
+    if (session.status !== SessionStatus5.FAILED || session.ready_for_prompt === true) {
       return session;
     }
     const sessionTasks = await taskRepo.findBySession(session.session_id);
     if (!shouldReconcileSessionPromptState(session, sessionTasks, options)) return session;
     console.warn(
-      `\u{1F9F9} [PromptState] Repairing stuck session ${shortId14(session.session_id)} (status=${session.status}, ready_for_prompt=${session.ready_for_prompt})`
+      `\u{1F9F9} [PromptState] Repairing stuck session ${shortId15(session.session_id)} (status=${session.status}, ready_for_prompt=${session.ready_for_prompt})`
     );
     return await app.service("sessions").patch(
       session.session_id,
       {
-        status: SessionStatus4.IDLE,
+        status: SessionStatus5.IDLE,
         ready_for_prompt: true
       },
       params
@@ -27871,7 +28101,7 @@ async function registerRoutes(ctx) {
         await app.service("messages").create(userMessage, params);
       } catch (msgErr) {
         console.warn(
-          `\u26A0\uFE0F  [Daemon] Failed to write initial user-message row for task ${shortId14(task.task_id)} (executor will retry):`,
+          `\u26A0\uFE0F  [Daemon] Failed to write initial user-message row for task ${shortId15(task.task_id)} (executor will retry):`,
           msgErr
         );
       }
@@ -27879,7 +28109,7 @@ async function registerRoutes(ctx) {
     await app.service("sessions").patch(
       task.session_id,
       {
-        status: SessionStatus4.RUNNING,
+        status: SessionStatus5.RUNNING,
         ready_for_prompt: false,
         tasks: [...session.tasks, task.task_id]
       },
@@ -27904,7 +28134,7 @@ async function registerRoutes(ctx) {
             throw new Error("CLI session has no created_by \u2014 cannot route PTY injection");
           }
           const channel = `user/${targetUserId}/terminal`;
-          const tabName = `cli-${shortId14(session.session_id)}`;
+          const tabName = `cli-${shortId15(session.session_id)}`;
           const io = app.io;
           io?.to(channel).emit("terminal:tab", {
             userId: targetUserId,
@@ -27915,11 +28145,11 @@ async function registerRoutes(ctx) {
           const payload = `${promptForExecutor}\r`;
           io?.to(channel).emit("terminal:input", { userId: targetUserId, input: payload });
           console.log(
-            `[claude-cli] PTY-injected prompt into ${channel} \u2192 tab ${tabName} (task ${shortId14(taskId)}, ${promptForExecutor.length} chars)`
+            `[claude-cli] PTY-injected prompt into ${channel} \u2192 tab ${tabName} (task ${shortId15(taskId)}, ${promptForExecutor.length} chars)`
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          console.error(`[claude-cli] PTY injection failed for task ${shortId14(taskId)}: ${msg}`);
+          console.error(`[claude-cli] PTY injection failed for task ${shortId15(taskId)}: ${msg}`);
           await safePatch(
             "tasks",
             taskId,
@@ -27931,7 +28161,7 @@ async function registerRoutes(ctx) {
             "Task",
             params
           );
-          await app.service("sessions").patch(sessionId, { status: SessionStatus4.IDLE, ready_for_prompt: true }, params).catch(() => {
+          await app.service("sessions").patch(sessionId, { status: SessionStatus5.IDLE, ready_for_prompt: true }, params).catch(() => {
           });
         }
       });
@@ -27940,7 +28170,7 @@ async function registerRoutes(ctx) {
     setImmediate(async () => {
       try {
         console.log(
-          `\u{1F680} [Daemon] Routing ${session.agentic_tool} to Feathers/WebSocket executor (task ${shortId14(taskId)})`
+          `\u{1F680} [Daemon] Routing ${session.agentic_tool} to Feathers/WebSocket executor (task ${shortId15(taskId)})`
         );
         await sessionsService.executeTask(
           sessionId,
@@ -27954,12 +28184,12 @@ async function registerRoutes(ctx) {
           params
         );
         console.log(
-          `\u2705 [Daemon] Executor spawned for session ${shortId14(sessionId)}, waiting for task completion`
+          `\u2705 [Daemon] Executor spawned for session ${shortId15(sessionId)}, waiting for task completion`
         );
       } catch (error51) {
         const errorMessage = error51 instanceof Error ? error51.message : String(error51);
         console.error(
-          `\u274C [Daemon] Executor spawn failed for session=${shortId14(sessionId)} task=${shortId14(taskId)} agent=${session.agentic_tool} unix_username=${session.unix_username ?? "null"}: ${errorMessage}`,
+          `\u274C [Daemon] Executor spawn failed for session=${shortId15(sessionId)} task=${shortId15(taskId)} agent=${session.agentic_tool} unix_username=${session.unix_username ?? "null"}: ${errorMessage}`,
           error51
         );
         await safePatch(
@@ -28012,7 +28242,7 @@ ${errorMessage}`;
     {
       async create(data, params) {
         console.log(
-          `\u{1F4E8} [Daemon] Prompt request for session ${params.route?.id ? shortId14(params.route.id) : "unknown"}`
+          `\u{1F4E8} [Daemon] Prompt request for session ${params.route?.id ? shortId15(params.route.id) : "unknown"}`
         );
         console.log(`   Permission mode: ${data.permissionMode || "not specified"}`);
         console.log(`   Streaming: ${data.stream !== false}`);
@@ -28040,7 +28270,7 @@ ${errorMessage}`;
         }
         if (session.archived) {
           console.log(
-            `\u{1F4E6} [Prompt] Auto-unarchiving session ${shortId14(id)} (was archived: ${session.archived_reason || "unknown reason"})`
+            `\u{1F4E6} [Prompt] Auto-unarchiving session ${shortId15(id)} (was archived: ${session.archived_reason || "unknown reason"})`
           );
           session = await sessionsService.patch(
             id,
@@ -28048,7 +28278,7 @@ ${errorMessage}`;
             params
           );
         }
-        if (session.status === SessionStatus4.STOPPING) {
+        if (session.status === SessionStatus5.STOPPING) {
           throw new Error("Cannot send prompt: session is currently stopping");
         }
         const taskRepo = new TaskRepository2(db);
@@ -28058,7 +28288,7 @@ ${errorMessage}`;
         const createdBy = params.user.user_id;
         return await withSessionTurnLock(sessionTurnLocks, id, async () => {
           let lockedSession = await sessionsService.get(id, params);
-          if (lockedSession.status === SessionStatus4.STOPPING) {
+          if (lockedSession.status === SessionStatus5.STOPPING) {
             throw new Error("Cannot send prompt: session is currently stopping");
           }
           lockedSession = await reconcileSessionPromptStateIfStuck(lockedSession, taskRepo, params);
@@ -28077,7 +28307,7 @@ ${errorMessage}`;
               }
             });
             console.log(
-              `\u{1F4EC} [Prompt] Auto-queued task for session ${shortId14(id)} at position ${queuedTask.queue_position} (session status: ${lockedSession.status}, existing queue items: ${queuedTasks.length})`
+              `\u{1F4EC} [Prompt] Auto-queued task for session ${shortId15(id)} at position ${queuedTask.queue_position} (session status: ${lockedSession.status}, existing queue items: ${queuedTasks.length})`
             );
             app.service("tasks").emit("queued", queuedTask);
             if (sessionCanStartTask(lockedSession.status, lockedSession.ready_for_prompt)) {
@@ -28142,7 +28372,7 @@ ${errorMessage}`;
         if (task.status !== TaskStatus5.CREATED) {
           const hint = task.status === TaskStatus5.QUEUED ? `Queued tasks drain automatically in queue-position order when the session becomes idle \u2014 wait for it, or stop the currently running task to free the queue.` : `Only 'created' tasks may be triggered.`;
           throw new Conflict2(
-            `Task ${shortId14(taskId)} cannot be run: status is '${task.status}'. ${hint}`
+            `Task ${shortId15(taskId)} cannot be run: status is '${task.status}'. ${hint}`
           );
         }
         const isInternalCall = !params.provider;
@@ -28184,12 +28414,12 @@ ${errorMessage}`;
             params,
             { ignoredTaskIds: [task.task_id] }
           );
-          if (session.status === SessionStatus4.STOPPING) {
+          if (session.status === SessionStatus5.STOPPING) {
             throw new BadRequest5("Cannot run task: session is currently stopping");
           }
           if (!sessionCanStartTask(session.status, session.ready_for_prompt)) {
             throw new Conflict2(
-              `Cannot run task ${shortId14(taskId)}: session is '${session.status}'. To enqueue a prompt on a busy session, POST to /sessions/:id/prompt instead \u2014 it creates and queues a task atomically.`
+              `Cannot run task ${shortId15(taskId)}: session is '${session.status}'. To enqueue a prompt on a busy session, POST to /sessions/:id/prompt instead \u2014 it creates and queues a task atomically.`
             );
           }
           return await runExistingTask(
@@ -28308,7 +28538,7 @@ ${errorMessage}`;
       const files = req.files;
       if (DEBUG_UPLOAD2) {
         console.log(
-          `\u{1F4CE} [Upload Handler] Processing for session ${sessionId ? shortId14(sessionId) : "unknown"}`
+          `\u{1F4CE} [Upload Handler] Processing for session ${sessionId ? shortId15(sessionId) : "unknown"}`
         );
         console.log(`   Destination: ${destination || "branch"}`);
         console.log(`   Notify agent: ${notifyAgent === "true" || notifyAgent === true}`);
@@ -28318,14 +28548,14 @@ ${errorMessage}`;
       if (DEBUG_UPLOAD2) {
         console.log(`   Auth params:`, {
           hasUser: !!params?.user,
-          userId: params?.user?.user_id ? shortId14(params.user.user_id) : void 0,
+          userId: params?.user?.user_id ? shortId15(params.user.user_id) : void 0,
           provider: params?.provider
         });
       }
       ensureMinimumRole(params, ROLES9.MEMBER, "upload files");
       const session = await sessionsService.get(sessionId, params);
       if (!session) {
-        console.error(`\u274C [Upload Handler] Session not found: ${shortId14(sessionId)}`);
+        console.error(`\u274C [Upload Handler] Session not found: ${shortId15(sessionId)}`);
         return res.status(404).json({ error: "Session not found" });
       }
       if (branchRbacEnabled) {
@@ -28350,7 +28580,7 @@ ${errorMessage}`;
         const canUpload = PERMISSION_RANK[effectiveLevel] >= PERMISSION_RANK.prompt || effectiveLevel === "session" && session.created_by === userId;
         if (!canUpload) {
           console.error(
-            `\u274C [Upload Handler] User ${shortId14(userId)} has '${effectiveLevel}' permission, cannot upload to branch ${shortId14(wt.branch_id)}`
+            `\u274C [Upload Handler] User ${shortId15(userId)} has '${effectiveLevel}' permission, cannot upload to branch ${shortId15(wt.branch_id)}`
           );
           return res.status(403).json({ error: "Not authorized to upload to this session" });
         }
@@ -28418,7 +28648,7 @@ ${errorMessage}`;
       console.log("   Has auth header:", !!req.headers.authorization);
       console.log(
         "   Session ID param:",
-        req.params.sessionId ? shortId14(req.params.sessionId) : "unknown"
+        req.params.sessionId ? shortId15(req.params.sessionId) : "unknown"
       );
     }
     next();
@@ -28444,7 +28674,7 @@ ${errorMessage}`;
       });
       if (DEBUG_UPLOAD2) {
         console.log("\u2705 [Upload Auth] Authentication successful");
-        console.log("   User:", result.user?.user_id ? shortId14(result.user.user_id) : "unknown");
+        console.log("   User:", result.user?.user_id ? shortId15(result.user.user_id) : "unknown");
       }
       req.feathers = {
         user: result.user,
@@ -28467,7 +28697,7 @@ ${errorMessage}`;
         console.log("\u2705 [Upload Route] Authentication passed");
         console.log(
           "   User:",
-          req.feathers?.user?.user_id ? shortId14(req.feathers.user.user_id) : "unknown"
+          req.feathers?.user?.user_id ? shortId15(req.feathers.user.user_id) : "unknown"
         );
       }
       next();
@@ -28509,68 +28739,36 @@ ${errorMessage}`;
         const id = params.route?.id;
         if (!id) throw new Error("Session ID required");
         const stopReason = data && typeof data === "object" && "reason" in data && typeof data.reason === "string" ? data.reason : void 0;
-        const session = await sessionsService.get(id, params);
-        const activeStates = [
-          SessionStatus4.RUNNING,
-          SessionStatus4.AWAITING_PERMISSION,
-          SessionStatus4.STOPPING
-        ];
-        if (!activeStates.includes(session.status)) {
-          return {
-            success: false,
-            reason: `Session cannot be stopped (status: ${session.status})`
-          };
-        }
-        const targetTasksArray = await findActiveTasksForSession(app, id);
-        if (targetTasksArray.length === 0) {
-          console.warn(
-            `\u26A0\uFE0F  [Stop] No active tasks for session ${shortId14(id)}, resetting to IDLE${stopReason ? ` (reason: ${stopReason})` : ""}`
-          );
-          await app.service("sessions").patch(
-            id,
+        const sessionsServiceWithHooks = app.service("sessions");
+        const result = await withSessionTurnLock(
+          sessionTurnLocks,
+          id,
+          async () => stopSessionPreserveQueue(
             {
-              status: SessionStatus4.IDLE,
-              ready_for_prompt: true
+              app,
+              taskRepo: new TaskRepository2(db),
+              sessionsService: sessionsServiceWithHooks,
+              tasksService,
+              killExecutorProcess
             },
-            params
-          );
-          return {
-            success: true,
-            status: SessionStatus4.IDLE,
-            reason: "No active tasks found, session reset to idle"
-          };
-        }
-        const latestTask = targetTasksArray[0];
-        console.log(
-          `\u{1F6D1} [Stop] Stopping task ${shortId14(latestTask.task_id)} for session ${shortId14(id)}${stopReason ? ` (reason: ${stopReason})` : ""}`
+            id,
+            params,
+            { reason: stopReason }
+          )
         );
-        const processKilled = killExecutorProcess(id);
-        if (!processKilled) {
-          console.warn(
-            `\u26A0\uFE0F  [Stop] No tracked process for session ${shortId14(id)} \u2014 executor may have already exited`
-          );
-        }
-        try {
-          await tasksService.patch(latestTask.task_id, {
-            status: TaskStatus5.STOPPED,
-            completed_at: (/* @__PURE__ */ new Date()).toISOString()
+        if (result.success) {
+          setImmediate(async () => {
+            try {
+              await sessionsServiceWithHooks.triggerQueueProcessing(id, params);
+            } catch (error51) {
+              console.error(
+                `\u274C [Stop] Failed to process queue after stopping session ${shortId15(id)}:`,
+                error51
+              );
+            }
           });
-        } catch (error51) {
-          console.error(`\u274C [Stop] Failed to patch task to STOPPED:`, error51);
         }
-        try {
-          await app.service("sessions").patch(
-            id,
-            {
-              status: SessionStatus4.IDLE,
-              ready_for_prompt: true
-            },
-            params
-          );
-        } catch (error51) {
-          console.error(`\u274C [Stop] Failed to patch session to IDLE:`, error51);
-        }
-        return { success: true, status: SessionStatus4.IDLE };
+        return result;
       }
     },
     {
@@ -28603,7 +28801,7 @@ ${errorMessage}`;
   async function processNextQueuedTask(sessionId, params) {
     const existingLock = sessionTurnLocks.get(sessionId);
     if (existingLock) {
-      console.log(`\u23F3 [Queue] Session turn in progress for ${shortId14(sessionId)}, waiting...`);
+      console.log(`\u23F3 [Queue] Session turn in progress for ${shortId15(sessionId)}, waiting...`);
       await existingLock.catch(() => void 0);
       if (!queueRetryScheduled.has(sessionId)) {
         queueRetryScheduled.add(sessionId);
@@ -28612,7 +28810,7 @@ ${errorMessage}`;
           try {
             await processNextQueuedTask(sessionId, params);
           } catch (error51) {
-            console.error(`\u274C [Queue] Retry failed for session ${shortId14(sessionId)}:`, error51);
+            console.error(`\u274C [Queue] Retry failed for session ${shortId15(sessionId)}:`, error51);
           }
         });
       }
@@ -28634,7 +28832,7 @@ ${errorMessage}`;
     const taskRepo = new TaskRepository2(db);
     const nextTask = await taskRepo.getNextQueued(sessionId);
     if (!nextTask) {
-      taskQueueDebug(`\u{1F4ED} No queued tasks for session ${shortId14(sessionId)}`);
+      taskQueueDebug(`\u{1F4ED} No queued tasks for session ${shortId15(sessionId)}`);
       return;
     }
     const userId = nextTask.metadata?.queued_by_user_id;
@@ -28645,7 +28843,7 @@ ${errorMessage}`;
       user: queuedByUser
     } : params;
     console.log(
-      `\u{1F4EC} Processing queued task ${shortId14(nextTask.task_id)} (position ${nextTask.queue_position}) with user context: ${queuedByUser ? shortId14(queuedByUser.user_id) : "none"}`
+      `\u{1F4EC} Processing queued task ${shortId15(nextTask.task_id)} (position ${nextTask.queue_position}) with user context: ${queuedByUser ? shortId15(queuedByUser.user_id) : "none"}`
     );
     const session = await reconcileSessionPromptStateIfStuck(
       await sessionsService.get(sessionId, taskParams),
@@ -28654,13 +28852,13 @@ ${errorMessage}`;
     );
     if (!sessionCanStartTask(session.status, session.ready_for_prompt)) {
       console.log(
-        `\u23F8\uFE0F  [Queue] Session ${shortId14(sessionId)} is ${session.status}, task ${shortId14(nextTask.task_id)} waiting in queue (will be processed when session becomes IDLE via patch hook)`
+        `\u23F8\uFE0F  [Queue] Session ${shortId15(sessionId)} is ${session.status}, task ${shortId15(nextTask.task_id)} waiting in queue (will be processed when session becomes IDLE via patch hook)`
       );
       return;
     }
     const stillQueued = await taskRepo.findById(nextTask.task_id);
     if (!stillQueued || stillQueued.status !== TaskStatus5.QUEUED) {
-      console.log(`\u26A0\uFE0F  Queued task ${shortId14(nextTask.task_id)} no longer queued, skipping`);
+      console.log(`\u26A0\uFE0F  Queued task ${shortId15(nextTask.task_id)} no longer queued, skipping`);
       return;
     }
     const source = nextTask.metadata?.source;
@@ -28672,7 +28870,7 @@ ${errorMessage}`;
       },
       taskParams
     );
-    console.log(`\u2705 Queued task drained for session ${shortId14(sessionId)}`);
+    console.log(`\u2705 Queued task drained for session ${shortId15(sessionId)}`);
   }
   sessionsService.setQueueProcessor(async (sessionId, params) => {
     try {