instar 1.3.444 → 1.3.446

package/README.md

@@ -18,7 +18,7 @@
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/instar">npm</a> · <a href="https://github.com/JKHeadley/instar">GitHub</a> · <a href="https://instar.sh">instar.sh</a> · <a href="https://instar.sh/introduction/">Docs</a>
+  <a href="https://www.npmjs.com/package/instar">npm</a> · <a href="https://github.com/JKHeadley/instar">GitHub</a> · <a href="https://instar.sh">instar.sh</a> · <a href="https://instar.sh/introduction/">Docs</a> · <a href="https://instar.sh/exo3">EXO&nbsp;3.0</a>
 </p>
 
 ---
@@ -116,6 +116,14 @@ An agent that forgets what you discussed yesterday, doesn't recognize someone it
 
 > **Deep dive:** [The Coherence Problem](https://instar.sh/concepts/coherence/) · [Values & Identity](https://instar.sh/concepts/values/) · [Coherence Is Safety](https://instar.sh/concepts/safety/)
 
+## EXO 3.0 — governed by your organization's intent
+
+Instar independently converged on Salim Ismail's **EXO 3.0 / "The Organizational Singularity"** framework: the idea that an organization's purpose should be encoded as *machine-readable* intent — "in code, not culture" — that actually **governs** its agents rather than just inspiring them. Instar was built around coherence before the framework existed, and the overlap turned out to be close to the line.
+
+We didn't just claim it works. We ran controlled experiments — same model, same requests, with the organization's intent switched off as the control — to show the intent itself is what changes the agent's behavior. The engine stays **neutral**: it enforces whatever intent a deploying organization gives it, never Instar's own values. Two case studies enforce two very different fictional companies' values equally well, neither of them ours.
+
+> **See the controlled proof → [instar.sh/exo3](https://instar.sh/exo3)** — two governed-vs-ungoverned case studies, with full transcripts.
+
 ## Features
 
 | Feature | Description | Docs |

package/dist/commands/server.d.ts

@@ -12,6 +12,25 @@ import { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import { TopicMemory } from '../memory/TopicMemory.js';
 import { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import { UserManager } from '../users/UserManager.js';
+/**
+ * Pure: should the emergency "fix command" gate intercept this message?
+ *
+ * Fix commands ("fix auth", "restart sessions", "clean processes", …) are
+ * mechanical server-side operations that only make sense in the Agent Attention
+ * topic, where the agent posts actionable notifications the user taps to resolve.
+ * In ANY other topic, a message that merely starts with "restart" / "fix " /
+ * "clean " is ordinary conversation ("restart the build", "fix the login page",
+ * "clean up this function") and must route to the session — never be swallowed.
+ *
+ * The previous logic ran this verb test in every topic and, on a non-attention
+ * topic, bounced the message back with "I didn't recognize that command" while
+ * also swallowing it (the gate `return`s). That is exactly why a user trying to
+ * revive a stuck session by typing "restart sessions" in that session's own
+ * topic never reached the session: the gate ate the message and replied with a
+ * help list that even advertised "restart sessions" as valid. Scoping the gate
+ * to the attention topic closes that hole.
+ */
+export declare function shouldInterceptFixCommand(text: string, topicId: number, attentionTopicId: number | null | undefined): boolean;
 interface StartOptions {
     foreground?: boolean;
     dir?: string;
@@ -19,7 +38,7 @@ interface StartOptions {
      *  Commander maps --no-telegram to telegram: false. */
     telegram?: boolean;
 }
-export declare function wireTelegramRouting(telegram: TelegramAdapter, sessionManager: SessionManager, quotaTracker?: QuotaTracker, topicMemory?: TopicMemory, userManager?: UserManager, fixCommandHandler?: (topicId: number, text: string) => Promise<boolean>, getHubDeps?: () => import('../threadline/hubCommands.js').HubBindDeps | null, getTopicOperatorStore?: () => import('../users/TopicOperatorStore.js').TopicOperatorStore | null): void;
+export declare function wireTelegramRouting(telegram: TelegramAdapter, sessionManager: SessionManager, quotaTracker?: QuotaTracker, topicMemory?: TopicMemory, userManager?: UserManager, fixCommandHandler?: (topicId: number, text: string) => Promise<boolean>, getHubDeps?: () => import('../threadline/hubCommands.js').HubBindDeps | null, getTopicOperatorStore?: () => import('../users/TopicOperatorStore.js').TopicOperatorStore | null, getAttentionTopicId?: () => number | null | undefined): void;
 export declare function startServer(options: StartOptions): Promise<void>;
 export declare function stopServer(options: {
     dir?: string;

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAS3D,OAAO,EAAE,eAAe,EAAiC,MAAM,iCAAiC,CAAC;AAuBjG,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAiG7D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AA6JtD,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA05BD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,eAAe,EACzB,cAAc,EAAE,cAAc,EAC9B,YAAY,CAAC,EAAE,YAAY,EAC3B,WAAW,CAAC,EAAE,WAAW,EACzB,WAAW,CAAC,EAAE,WAAW,EACzB,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EAGvE,UAAU,CAAC,EAAE,MAAM,OAAO,8BAA8B,EAAE,WAAW,GAAG,IAAI,EAK5E,qBAAqB,CAAC,EAAE,MAAM,OAAO,gCAAgC,EAAE,kBAAkB,GAAG,IAAI,GAC/F,IAAI,CAyUN;AA2lBD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAuvUtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAS3D,OAAO,EAAE,eAAe,EAAiC,MAAM,iCAAiC,CAAC;AAuBjG,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAiG7D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAsBtD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC1C,OAAO,CAUT;AAyID,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA05BD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,eAAe,EACzB,cAAc,EAAE,cAAc,EAC9B,YAAY,CAAC,EAAE,YAAY,EAC3B,WAAW,CAAC,EAAE,WAAW,EACzB,WAAW,CAAC,EAAE,WAAW,EACzB,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EAGvE,UAAU,CAAC,EAAE,MAAM,OAAO,8BAA8B,EAAE,WAAW,GAAG,IAAI,EAK5E,qBAAqB,CAAC,EAAE,MAAM,OAAO,gCAAgC,EAAE,kBAAkB,GAAG,IAAI,EAKhG,mBAAmB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,GACpD,IAAI,CA0UN;AA2lBD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAoyUtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -144,6 +144,34 @@ import { toInjection } from '../types/pipeline.js';
 import { UserManager } from '../users/UserManager.js';
 import { formatUserContextForSession, hasUserContext } from '../users/UserContextBuilder.js';
 import { SafeFsExecutor } from '../core/SafeFsExecutor.js';
+/**
+ * Pure: should the emergency "fix command" gate intercept this message?
+ *
+ * Fix commands ("fix auth", "restart sessions", "clean processes", …) are
+ * mechanical server-side operations that only make sense in the Agent Attention
+ * topic, where the agent posts actionable notifications the user taps to resolve.
+ * In ANY other topic, a message that merely starts with "restart" / "fix " /
+ * "clean " is ordinary conversation ("restart the build", "fix the login page",
+ * "clean up this function") and must route to the session — never be swallowed.
+ *
+ * The previous logic ran this verb test in every topic and, on a non-attention
+ * topic, bounced the message back with "I didn't recognize that command" while
+ * also swallowing it (the gate `return`s). That is exactly why a user trying to
+ * revive a stuck session by typing "restart sessions" in that session's own
+ * topic never reached the session: the gate ate the message and replied with a
+ * help list that even advertised "restart sessions" as valid. Scoping the gate
+ * to the attention topic closes that hole.
+ */
+export function shouldInterceptFixCommand(text, topicId, attentionTopicId) {
+    if (!attentionTopicId || topicId !== attentionTopicId)
+        return false;
+    const cmd = text.trim().toLowerCase();
+    return (cmd.startsWith('fix ') ||
+        cmd.startsWith('clean ') ||
+        cmd.startsWith('restart') ||
+        cmd === 'fix' ||
+        cmd === 'clean');
+}
 /**
  * Handle "fix X" and "clean X" commands from Agent Attention notifications.
  * These are mechanical server-side operations — no Claude session needed.
@@ -1100,7 +1128,12 @@ getHubDeps,
 // the SAME instance the routes use (a second instance on the same file would
 // lose updates between the two in-memory caches). Know Your Principal #898,
 // increment 2e: the polling-path operator auto-bind.
-getTopicOperatorStore) {
+getTopicOperatorStore, 
+// Late-bound resolver for the Agent Attention topic id. The emergency
+// fix-command gate (below) only fires in that topic; everywhere else a
+// message starting with restart/fix/clean is normal conversation and must
+// route to the session instead of being swallowed.
+getAttentionTopicId) {
     // Guard: tracks which topic IDs have a spawn in progress.
     // Prevents duplicate concurrent spawns for the same topic when messages
     // arrive faster than the async spawn completes.
@@ -1214,34 +1247,35 @@ getTopicOperatorStore) {
         // ── Fix commands from notification messages ──────────────────────
         // Handle "fix auth", "clean processes", "restart", etc. directly
         // in the server process — no need to spawn a Claude session for these.
-        if (fixCommandHandler) {
-            const cmdText = text.trim().toLowerCase();
-            const isFixCommand = cmdText.startsWith('fix ') || cmdText.startsWith('clean ') ||
-                cmdText.startsWith('restart') || cmdText === 'fix' || cmdText === 'clean';
-            if (isFixCommand) {
-                (async () => {
-                    try {
-                        const handled = await fixCommandHandler(topicId, text);
-                        if (!handled) {
-                            // Not a recognized fix command — fall through to session routing
-                            // Re-trigger the normal routing by calling the topic message handler again
-                            // Actually, since we can't re-trigger, just send a help message
-                            await telegram.sendToTopic(topicId, `I didn't recognize that command. Available fix commands:\n` +
-                                `• "fix auth" — Generate an API security token\n` +
-                                `• "fix lifeline" — Restart the crash-recovery system\n` +
-                                `• "fix shadow" — Remove shadow installation\n` +
-                                `• "clean processes" — Kill external Claude processes\n` +
-                                `• "restart" — Restart the server\n` +
-                                `• "restart sessions" — Restart stuck sessions`);
-                        }
-                    }
-                    catch (err) {
-                        console.error(`[telegram] Fix command error:`, err);
-                        await telegram.sendToTopic(topicId, `Something went wrong while trying to fix that: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+        //
+        // These ONLY apply in the Agent Attention topic. Scoping the gate there
+        // (shouldInterceptFixCommand) is deliberate: previously the verb test ran
+        // in every topic, so a message starting with restart/fix/clean in a normal
+        // conversation was swallowed and bounced back with an "I didn't recognize
+        // that command" help list — which is exactly why typing "restart sessions"
+        // in a stuck session's own topic never reached the session. Outside the
+        // attention topic the message now falls through to session routing below.
+        if (fixCommandHandler && shouldInterceptFixCommand(text, topicId, getAttentionTopicId?.())) {
+            (async () => {
+                try {
+                    const handled = await fixCommandHandler(topicId, text);
+                    if (!handled) {
+                        // In the attention topic, but not a recognized fix command — show help.
+                        await telegram.sendToTopic(topicId, `I didn't recognize that command. Available fix commands:\n` +
+                            `• "fix auth" — Generate an API security token\n` +
+                            `• "fix lifeline" — Restart the crash-recovery system\n` +
+                            `• "fix shadow" — Remove shadow installation\n` +
+                            `• "clean processes" — Kill external Claude processes\n` +
+                            `• "restart" — Restart the server\n` +
+                            `• "restart sessions" — Restart stuck sessions`);
                     }
-                })();
-                return;
-            }
+                }
+                catch (err) {
+                    console.error(`[telegram] Fix command error:`, err);
+                    await telegram.sendToTopic(topicId, `Something went wrong while trying to fix that: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+                }
+            })();
+            return;
         }
         // ── Pipeline-typed routing ──────────────────────────────────────
         // Convert to PipelineMessage — types enforce that sender identity
@@ -3717,7 +3751,7 @@ export async function startServer(options) {
             // reached the AI session as plain chat text.
             const userManagerSendOnly = new UserManager(config.stateDir, config.users);
             _fixDeps = { state, liveConfig, sessionManager, telegram, config };
-            wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory, userManagerSendOnly, (topicId, text) => handleFixCommand(topicId, text, _fixDeps), () => (collaborationSurfacer && conversationStore && telegram) ? { collaborationSurfacer, conversationStore, commitmentTracker, telegram, brief: briefDeps } : null, () => _agentServerRef?.getTopicOperatorStore() ?? null);
+            wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory, userManagerSendOnly, (topicId, text) => handleFixCommand(topicId, text, _fixDeps), () => (collaborationSurfacer && conversationStore && telegram) ? { collaborationSurfacer, conversationStore, commitmentTracker, telegram, brief: briefDeps } : null, () => _agentServerRef?.getTopicOperatorStore() ?? null, () => state.get('agent-attention-topic'));
             wireTelegramCallbacks(telegram, sessionManager, state, quotaTracker, undefined, config.sessions.claudePath, topicMemory);
             console.log(pc.green('  Telegram routing + command callbacks wired (send-only)'));
         }
@@ -3843,7 +3877,7 @@ export async function startServer(options) {
                 config,
             };
             // Wire up topic → session routing and session management callbacks
-            wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory, userManager, (topicId, text) => handleFixCommand(topicId, text, _fixDeps), () => (collaborationSurfacer && conversationStore && telegram) ? { collaborationSurfacer, conversationStore, commitmentTracker, telegram, brief: briefDeps } : null, () => _agentServerRef?.getTopicOperatorStore() ?? null);
+            wireTelegramRouting(telegram, sessionManager, quotaTracker, topicMemory, userManager, (topicId, text) => handleFixCommand(topicId, text, _fixDeps), () => (collaborationSurfacer && conversationStore && telegram) ? { collaborationSurfacer, conversationStore, commitmentTracker, telegram, brief: briefDeps } : null, () => _agentServerRef?.getTopicOperatorStore() ?? null, () => state.get('agent-attention-topic'));
             wireTelegramCallbacks(telegram, sessionManager, state, quotaTracker, accountSwitcher, config.sessions.claudePath, topicMemory);
             // Wire up unknown-user handling (Multi-User Setup Wizard Phase 4.5)
             telegram.onGetRegistrationPolicy = () => ({
@@ -4339,6 +4373,20 @@ export async function startServer(options) {
                     const channelId = message.channel.identifier;
                     const isDM = message.metadata?.isDM;
                     const senderName = message.metadata?.senderName || 'User';
+                    // ── Thread → session routing (§5.3) ──────────────────────────────────
+                    // The Slack channelId is ALWAYS the address we talk to the Slack API with
+                    // (replies, reactions, history). The session REGISTRY + resume map are
+                    // keyed on a routing key that, when thread routing is opted in for this
+                    // channel and the message is a reply inside a thread, becomes
+                    // `<channelId>:<thread_ts>` — giving that thread its own isolated session,
+                    // mirroring Telegram topic→session. Default (no opt-in / no thread_ts):
+                    // routingKey === channelId, byte-for-byte today's behavior.
+                    const messageTs = message.metadata?.ts;
+                    const threadTs = message.metadata?.threadTs;
+                    const routingKey = slackAdapter.resolveRoutingKey(channelId, threadTs, messageTs);
+                    const isThreadSession = slackAdapter.isThreadRoutingKey(routingKey);
+                    // The thread_ts to thread replies under (only when this is a thread session).
+                    const replyThreadTs = isThreadSession ? threadTs : undefined;
                     // Sentinel intercept — classify message for emergency stop/pause
                     if (sentinel) {
                         try {
@@ -4356,7 +4404,7 @@ export async function startServer(options) {
                                 return;
                             }
                             else if (classification.category === 'pause') {
-                                const existingSession = slackAdapter.getSessionForChannel(channelId);
+                                const existingSession = slackAdapter.getSessionForChannel(routingKey);
                                 if (existingSession) {
                                     sessionManager.sendKey(existingSession, 'Escape');
                                     slackAdapter.sendToChannel(channelId, '⏸️ Session paused.').catch(() => { });
@@ -4413,9 +4461,16 @@ export async function startServer(options) {
                     contextLines.push('CRITICAL: You MUST relay your response back to Slack after responding.');
                     contextLines.push('Use the relay script (write ONLY your reply text — do NOT pipe or cat this file into the script):');
                     contextLines.push('');
-                    contextLines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${channelId}`);
+                    // Thread session: pass the thread_ts as the 2nd arg so the reply lands IN
+                    // the thread (not the channel root). Channel session: channelId only.
+                    const replyTarget = replyThreadTs ? `${channelId} ${replyThreadTs}` : `${channelId}`;
+                    contextLines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${replyTarget}`);
                     contextLines.push('Your response text here');
                     contextLines.push('EOF');
+                    if (replyThreadTs) {
+                        contextLines.push('');
+                        contextLines.push('(This is a THREAD conversation — keep your reply in this thread by passing the thread id shown above as the 2nd argument.)');
+                    }
                     contextLines.push('');
                     contextLines.push('Strip the [slack:] prefix before interpreting the message.');
                     contextLines.push('Only relay conversational text — not tool output, file contents, or internal reasoning.');
@@ -4451,8 +4506,8 @@ export async function startServer(options) {
                     else {
                         bootstrapMessage = fullMessage;
                     }
-                    // Check for existing session bound to this channel
-                    const existingSession = slackAdapter.getSessionForChannel(channelId);
+                    // Check for existing session bound to this channel/thread (routing key)
+                    const existingSession = slackAdapter.getSessionForChannel(routingKey);
                     if (existingSession) {
                         // Try to inject into existing session via tmux
                         const sessions = sessionManager.listRunningSessions();
@@ -4490,20 +4545,26 @@ export async function startServer(options) {
                         }
                         console.log(`[slack→session] Session "${existingSession}" died, respawning...`);
                     }
-                    // Check resume map for session continuity
-                    const resumeInfo = slackAdapter.getChannelResume(channelId);
+                    // Check resume map for session continuity (keyed on routing key, so a
+                    // thread resumes its OWN session and not the channel-root one).
+                    const resumeInfo = slackAdapter.getChannelResume(routingKey);
                     const resumeSessionId = resumeInfo?.uuid ?? undefined;
                     if (resumeInfo) {
-                        slackAdapter.removeChannelResume(channelId);
+                        slackAdapter.removeChannelResume(routingKey);
                     }
-                    // Route: DMs go to lifeline session, channels spawn new sessions
-                    const targetSession = isDM ? 'lifeline' : undefined;
+                    // Route: DMs go to lifeline session, channels/threads spawn new sessions.
+                    // A thread session NEVER folds into the DM lifeline — it is its own
+                    // isolated work session (DMs don't carry thread_ts anyway).
+                    const targetSession = (isDM && !isThreadSession) ? 'lifeline' : undefined;
                     try {
-                        const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, targetSession, { resumeSessionId, slackChannelId: channelId });
+                        const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, targetSession, { resumeSessionId, slackChannelId: channelId, slackThreadTs: replyThreadTs });
                         if (newSessionName) {
-                            slackAdapter.registerChannelSession(channelId, newSessionName);
+                            // Register on the routing key (channelId for a channel session,
+                            // `<channelId>:<thread_ts>` for a thread session). channelName carries
+                            // a thread hint so the registry stays human-readable.
+                            slackAdapter.registerChannelSession(routingKey, newSessionName, isThreadSession ? `${channelId} (thread ${replyThreadTs})` : undefined);
                             slackAdapter.trackMessageInjection(channelId, newSessionName, message.content);
-                            console.log(`[slack→session] ${resumeSessionId ? 'Resumed' : 'Spawned'} "${newSessionName}" for channel ${channelId}`);
+                            console.log(`[slack→session] ${resumeSessionId ? 'Resumed' : 'Spawned'} "${newSessionName}" for ${isThreadSession ? `thread ${routingKey}` : `channel ${channelId}`}`);
                         }
                     }
                     catch (err) {
@@ -5516,17 +5577,24 @@ export async function startServer(options) {
                     }
                     console.log(`[respawnSessionFresh] topicId=${topicId} slackChId=${slackChId || 'none'} slackAdapter=${!!_slackAdapter} session=${_sessionName} mapSize=${slackProxyChannelMap.size}`);
                     if (slackChId && _slackAdapter) {
+                        // Thread→session (§5.3): slackChId may be a routing key
+                        // (`<channelId>:<thread_ts>`). The registry + resume map are keyed on
+                        // the routing key (slackChId); the Slack API + reply instruction need
+                        // the RAW channel id, and a thread reply needs the embedded thread_ts.
+                        const parsedTarget = _slackAdapter.parseRoutingKey(slackChId);
+                        const slackApiChannel = parsedTarget.channelId;
+                        const slackReplyThread = parsedTarget.threadTs;
                         // Kill existing session (already flagged in contextExhaustionKills via event listener)
                         const session = sessionManager.listRunningSessions().find(s => s.tmuxSession === _sessionName);
                         if (session)
                             sessionManager.killSession(session.id);
-                        // Clear the channel resume so the new session starts fresh
+                        // Clear the channel/thread resume so the new session starts fresh
                         _slackAdapter.removeChannelResume(slackChId);
                         // Spawn a fresh session with recovery context
                         await new Promise(resolve => setTimeout(resolve, 2000));
                         // Build a recovery bootstrap message with thread history (inline, matching Telegram pattern)
                         // Use async fallback to fetch from Slack API if ring buffer is empty (race condition on restart)
-                        const history = await _slackAdapter.getChannelMessagesWithFallback(slackChId, 30);
+                        const history = await _slackAdapter.getChannelMessagesWithFallback(slackApiChannel, 30);
                         const botUserId = _slackAdapter.getBotUserId?.() ?? null;
                         const lines = [];
                         lines.push(`CONTINUATION — You are resuming an EXISTING Slack conversation after context exhaustion. Read the context below and pick up where you left off. Do NOT ask what was being discussed.`);
@@ -5547,25 +5615,28 @@ export async function startServer(options) {
                             lines.push('--- End Thread History ---');
                         }
                         else {
-                            console.warn(`[slack→recovery] WARNING: No history available for channel ${slackChId} — recovery context is empty. Ring buffer may not be populated yet.`);
+                            console.warn(`[slack→recovery] WARNING: No history available for channel ${slackApiChannel} — recovery context is empty. Ring buffer may not be populated yet.`);
                             lines.push('[WARNING: Thread history unavailable — ring buffer may not be populated. Check Slack channel for recent messages before responding.]');
                         }
                         lines.push('');
                         lines.push('CRITICAL: You MUST relay your response back to Slack.');
-                        lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${slackChId}`);
+                        // Thread session: include the thread_ts so the recovered reply threads.
+                        const recoveryReplyTarget = slackReplyThread ? `${slackApiChannel} ${slackReplyThread}` : `${slackApiChannel}`;
+                        lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${recoveryReplyTarget}`);
                         lines.push('Your response text here');
                         lines.push('EOF');
                         const tmpDir = '/tmp/instar-slack';
                         fs.mkdirSync(tmpDir, { recursive: true });
-                        const ctxPath = path.join(tmpDir, `recovery-${slackChId}-${Date.now()}.txt`);
+                        const ctxPath = path.join(tmpDir, `recovery-${slackApiChannel}-${Date.now()}.txt`);
                         const contextData = lines.join('\n');
                         fs.writeFileSync(ctxPath, contextData);
-                        const bootstrapMessage = `[slack:${slackChId}] ${contextData}`;
+                        const bootstrapMessage = `[slack:${slackApiChannel}] ${contextData}`;
                         try {
-                            const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, undefined, { slackChannelId: slackChId });
+                            // Spawn with the RAW channel (+ thread_ts) but register on the routing key.
+                            const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage, undefined, { slackChannelId: slackApiChannel, slackThreadTs: slackReplyThread });
                             if (newSessionName) {
                                 _slackAdapter.registerChannelSession(slackChId, newSessionName);
-                                console.log(`[slack→recovery] Fresh session "${newSessionName}" spawned for channel ${slackChId} (context exhaustion recovery)`);
+                                console.log(`[slack→recovery] Fresh session "${newSessionName}" spawned for ${slackReplyThread ? `thread ${slackChId}` : `channel ${slackApiChannel}`} (context exhaustion recovery)`);
                             }
                         }
                         catch (err) {