instar 1.3.445 → 1.3.447

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;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,CAyvUtE;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,CA20UtE;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

@@ -4255,7 +4255,7 @@ export async function startServer(options) {
                     const slackCfg = slackConfig.config;
                     const pgCfg = slackCfg.permissionGate;
                     if (pgCfg && (pgCfg.observeOnly || pgCfg.enforce)) {
-                        const { SlackPermissionObserver, SlackPrincipalResolver, SlackPermissionGate, PermissionDecisionLedger, RolePolicy, HeuristicIntentClassifier, LlmIntentClassifier, HeuristicAnomalyScorer, MandateBackedGrantStore, } = await import('../permissions/index.js');
+                        const { SlackPermissionObserver, SlackPrincipalResolver, SlackPermissionGate, PermissionDecisionLedger, RolePolicy, HeuristicIntentClassifier, LlmIntentClassifier, HeuristicAnomalyScorer, RelationshipBehaviorStore, RelationshipAnomalyScorer, MandateBackedGrantStore, } = await import('../permissions/index.js');
                         // Own UserManager instance for verified-principal resolution (the
                         // Telegram-block userManager is out of scope here). Reads users.json.
                         const slackUserManager = new UserManager(config.stateDir, config.users);
@@ -4314,6 +4314,24 @@ export async function startServer(options) {
                         else {
                             intentClassifier = new HeuristicIntentClassifier();
                         }
+                        // ── Pillar 3 relationship-aware anomaly second factor (DARK by default) ──
+                        // With `relationshipAnomaly.enabled`, wire the durable behavioral baseline
+                        // store + the RelationshipAnomalyScorer. The baseline grows from observed
+                        // traffic (recorded SHAPE only, never content) via the observer. With the
+                        // flag OFF, we keep the placeholder HeuristicAnomalyScorer (urgency-only)
+                        // exactly as before — nothing changes.
+                        const raCfg = pgCfg.relationshipAnomaly;
+                        let anomalyScorer = new HeuristicAnomalyScorer();
+                        let behaviorStore;
+                        if (raCfg?.enabled && config.stateDir) {
+                            behaviorStore = new RelationshipBehaviorStore(config.stateDir);
+                            anomalyScorer = new RelationshipAnomalyScorer(behaviorStore, {
+                                useLlmStyleCheck: raCfg.useLlmStyleCheck === true,
+                                // Fail-closed LLM style check uses the shared internal provider when present.
+                                intelligence: sharedIntelligence ?? undefined,
+                            });
+                            console.log(`[slack] relationship-aware anomaly scorer attached (observe-only baseline; LLM style check ${raCfg.useLlmStyleCheck ? 'ON' : 'off'})`);
+                        }
                         const observer = new SlackPermissionObserver({
                             resolver: new SlackPrincipalResolver({
                                 resolveFromSlackUserId: (id) => slackUserManager.resolveFromSlackUserId(id),
@@ -4321,11 +4339,13 @@ export async function startServer(options) {
                             gate: new SlackPermissionGate({
                                 rolePolicy: new RolePolicy(),
                                 classifier: intentClassifier,
-                                anomalyScorer: new HeuristicAnomalyScorer(),
+                                anomalyScorer,
                                 grants: grantStore,
+                                ...(raCfg?.stepUpThreshold !== undefined ? { stepUpThreshold: raCfg.stepUpThreshold } : {}),
                             }),
                             ledger: new PermissionDecisionLedger(config.stateDir),
                             enforce: pgCfg.enforce === true,
+                            behaviorStore,
                         });
                         slackAdapter.setPermissionObserver(observer);
                         console.log(`[slack] permission gate attached (${pgCfg.enforce ? 'ENFORCE' : 'observe-only'})`);
@@ -4373,6 +4393,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 {
@@ -4390,7 +4424,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(() => { });
@@ -4447,9 +4481,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.');
@@ -4485,8 +4526,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();
@@ -4524,20 +4565,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) {
@@ -5550,17 +5597,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.`);
@@ -5581,25 +5635,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) {