instar 0.28.33 → 0.28.41

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;AA2PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA81CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAupItE;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;AA2PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA81CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA4uItE;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

@@ -1789,23 +1789,55 @@ export async function startServer(options) {
         _topicResumeMap = new TopicResumeMap(config.stateDir, config.sessions.projectDir, config.sessions.tmuxPath);
         _projectDir = config.sessions.projectDir;
         // Shared intelligence provider — lightweight LLM for internal classification tasks.
-        // Prefer Anthropic API (faster, no tmux) → Claude CLI fallback.
+        // Priority: Claude CLI subscription (zero extra cost, default) → Anthropic API (explicit opt-in)
         // Components that need LLM intelligence (Sentinel, TelegramAdapter, etc.) share this.
+        //
+        // Rationale: Instar must not depend on an API key. The subscription path is the default so
+        // every agent gets LLM-gated features out of the box. Users who prefer direct API access can
+        // set `intelligenceProvider: "anthropic-api"` in config.json.
         let sharedIntelligence;
-        try {
-            const apiProvider = AnthropicIntelligenceProvider.fromEnv();
-            if (apiProvider) {
-                sharedIntelligence = apiProvider;
+        const explicitIntelligenceProvider = config.intelligenceProvider;
+        let intelligenceSource = 'none';
+        if (explicitIntelligenceProvider === 'anthropic-api') {
+            try {
+                const apiProvider = AnthropicIntelligenceProvider.fromEnv();
+                if (apiProvider) {
+                    sharedIntelligence = apiProvider;
+                    intelligenceSource = 'Anthropic API (explicit opt-in)';
+                }
+                else {
+                    console.log(pc.yellow('  intelligenceProvider: "anthropic-api" set but ANTHROPIC_API_KEY not found — falling back to Claude CLI'));
+                }
             }
+            catch { /* no API key available */ }
         }
-        catch { /* no API key available */ }
         if (!sharedIntelligence) {
             try {
                 sharedIntelligence = new ClaudeCliIntelligenceProvider(config.sessions.claudePath);
+                intelligenceSource = 'Claude CLI subscription';
             }
             catch { /* CLI not available */ }
         }
+        if (!sharedIntelligence && explicitIntelligenceProvider !== 'anthropic-api') {
+            // Last resort: if user has API key but didn't explicitly opt in, use it rather than
+            // leaving the agent flying blind. We prefer subscription, but degrading to heuristics
+            // is worse than using whatever LLM is available.
+            try {
+                const apiProvider = AnthropicIntelligenceProvider.fromEnv();
+                if (apiProvider) {
+                    sharedIntelligence = apiProvider;
+                    intelligenceSource = 'Anthropic API (CLI unavailable — last resort)';
+                }
+            }
+            catch { /* no API key available */ }
+        }
         _sharedIntelligence = sharedIntelligence ?? null;
+        if (sharedIntelligence) {
+            console.log(pc.gray(`  Intelligence: ${intelligenceSource}`));
+        }
+        else {
+            console.log(pc.yellow('  Intelligence: none (no Claude CLI, no API key) — LLM-gated features degraded'));
+        }
         // Wire intelligence into git sync for LLM conflict resolution (Tier 1 → 2)
         if (gitSync && sharedIntelligence) {
             gitSync.setIntelligence(sharedIntelligence);
@@ -3765,15 +3797,31 @@ export async function startServer(options) {
         const hookEventReceiver = new HookEventReceiver({ stateDir: config.stateDir });
         console.log(pc.green('  Hook event receiver enabled'));
         // ── Compaction Resume: unified recovery for one session ──────────────
-        // Robust against subsystem misconfiguration: works with or without
-        // triageOrchestrator. If the orchestrator is available we prefer it
-        // (richer recovery semantics); otherwise we fall back to a direct
-        // tmux re-injection of the unanswered user message.
+        // After compaction, the session's working context is gone. Rather than
+        // replaying the user's last message (which assumes the agent still has
+        // thread context), we inject a prompt telling the agent to re-read recent
+        // topic messages and continue. The agent fetches its own history, so this
+        // restores continuity without pretending no compaction happened.
+        //
+        // Note: we deliberately bypass triageOrchestrator here. Its reinject_message
+        // heuristic unconditionally re-sends the last user message from topic
+        // history — fine for "message lost mid-flight" stalls, wrong for compaction
+        // recovery where the agent needs to re-orient first.
         //
         // Three independent triggers call into this:
         //   1. PreCompact hook event (Claude Code fires it — unreliable)
         //   2. SessionWatchdog 'compaction-idle' polling (default-enabled)
         //   3. POST /internal/compaction-resume (compaction-recovery.sh hook)
+        // After compaction the agent needs three things: orientation, user-facing
+        // transparency, and a clear handoff back to whatever they were doing.
+        // (1) "read previous messages" ensures re-orientation on the current thread
+        //     before responding — if the agent just replies from a blank slate it
+        //     will answer the wrong question.
+        // (2) "let the user know compaction occurred" keeps the user informed so
+        //     a sudden shift in tone or awareness isn't mysterious.
+        // (3) "continue where you left off" tells the agent not to re-ask or
+        //     re-litigate, just pick up.
+        const COMPACTION_RESUME_PROMPT = 'Your session just went through context compaction. Read the recent messages in this topic to re-orient, briefly let the user know compaction occurred, then continue where you left off.';
         const recoverCompactedSession = async (sessionName, triggerLabel) => {
             if (!sessionManager.isSessionAlive(sessionName))
                 return false;
@@ -3785,17 +3833,8 @@ export async function startServer(options) {
                     const lastMsg = history[history.length - 1];
                     if (lastMsg?.fromUser) {
                         console.log(`[CompactionResume] (${triggerLabel}) topic ${topicId} session "${sessionName}" has unanswered message — recovering`);
-                        if (triageOrchestrator) {
-                            try {
-                                await triageOrchestrator.activate(topicId, sessionName, 'watchdog', lastMsg.text, Date.now());
-                                return true;
-                            }
-                            catch (err) {
-                                console.warn(`[CompactionResume] orchestrator failed, falling back to direct inject:`, err);
-                            }
-                        }
-                        // Fallback: direct injection with topic tag so InputGuard accepts it.
-                        const tagged = `[telegram:${topicId}] ${lastMsg.text}`;
+                        // Direct injection with topic tag so InputGuard accepts it.
+                        const tagged = `[telegram:${topicId}] ${COMPACTION_RESUME_PROMPT}`;
                         const ok = sessionManager.injectMessage(sessionName, tagged);
                         if (ok) {
                             console.log(`[CompactionResume] (${triggerLabel}) direct re-inject OK for topic ${topicId}`);
@@ -3816,7 +3855,26 @@ export async function startServer(options) {
             }
             return false;
         };
-        // Trigger 1: PreCompact hook event — wired unconditionally now.
+        // ── CompactionSentinel ────────────────────────────────────────────
+        // Owns the full recovery lifecycle: detect → inject → verify (jsonl
+        // growth) → retry on failure → finalize. Replaces the fire-and-forget
+        // calls that used to live here. Dedupes across the three triggers and
+        // vetoes zombie cleanup while a recovery is in flight.
+        const { CompactionSentinel } = await import('../monitoring/CompactionSentinel.js');
+        const compactionSentinel = new CompactionSentinel({
+            recoverFn: recoverCompactedSession,
+            projectDir: config.projectDir,
+            getClaudeSessionId: (sessionName) => {
+                const session = sessionManager.listRunningSessions()
+                    .find(s => s.tmuxSession === sessionName);
+                return session?.claudeSessionId;
+            },
+        }, 
+        // Defaults are production-sensible; override here only if needed.
+        {});
+        sessionManager.setActiveRecoveryChecker(session => compactionSentinel.isRecoveryActive(session.tmuxSession));
+        console.log(pc.green('  CompactionSentinel enabled (verified recovery lifecycle)'));
+        // Trigger 1: PreCompact hook event — report to sentinel.
         hookEventReceiver.on('PreCompact', () => {
             // Delay to let compaction + recovery hooks finish
             setTimeout(() => {
@@ -3824,22 +3882,26 @@ export async function startServer(options) {
                     return;
                 const topicSessions = telegram.getAllTopicSessions();
                 for (const [, sessionName] of topicSessions) {
-                    recoverCompactedSession(sessionName, 'PreCompact').catch(() => { });
+                    compactionSentinel.report(sessionName, 'PreCompact');
                 }
             }, 10_000);
         });
         console.log(pc.green('  Compaction auto-resume wired (PreCompact hook event)'));
-        // Trigger 2: Watchdog 'compaction-idle' polling — wired unconditionally.
+        // Trigger 2: Watchdog 'compaction-idle' polling — report to sentinel.
         if (watchdog) {
             watchdog.on('compaction-idle', (sessionName) => {
-                recoverCompactedSession(sessionName, 'watchdog-poll').catch(() => { });
+                compactionSentinel.report(sessionName, 'watchdog-poll');
             });
             console.log(pc.green('  Compaction auto-resume wired (watchdog poll)'));
         }
-        // Trigger 3: stash the recovery function on globalThis so the HTTP route
-        // (registered later in AgentServer) and the compaction-recovery.sh hook
-        // can invoke it via POST /internal/compaction-resume.
-        globalThis.__instarCompactionRecover = recoverCompactedSession;
+        // Trigger 3: stash a function on globalThis so the HTTP route (registered
+        // later in AgentServer) and the compaction-recovery.sh hook can invoke it
+        // via POST /internal/compaction-resume. Routes into the sentinel so the
+        // dedupe/verify/retry lifecycle applies to this path too.
+        globalThis.__instarCompactionRecover = (sessionName, triggerLabel) => {
+            compactionSentinel.report(sessionName, triggerLabel || 'recovery-hook');
+            return Promise.resolve(true);
+        };
         // Subagent Tracker — monitors subagent lifecycle via hook events
         const { SubagentTracker } = await import('../monitoring/SubagentTracker.js');
         const subagentTracker = new SubagentTracker({ stateDir: config.stateDir });
@@ -3983,7 +4045,6 @@ export async function startServer(options) {
                 const channelId = _slack.getChannelForSession(sessionName);
                 if (!channelId)
                     return false;
-                const syntheticId = slackChannelToSyntheticId(channelId);
                 const slackLogPath = path.join(config.stateDir, 'slack-messages.jsonl');
                 let lastUserMsg = null;
                 try {
@@ -4004,18 +4065,9 @@ export async function startServer(options) {
                 catch { /* no log */ }
                 if (!lastUserMsg)
                     return false;
-                const text = lastUserMsg.text || 'message after compaction';
                 console.log(`[CompactionResume] (${triggerLabel}) Slack channel ${channelId} has unanswered message — recovering`);
-                if (triageOrchestrator) {
-                    try {
-                        await triageOrchestrator.activate(syntheticId, sessionName, 'watchdog', text, Date.now());
-                        return true;
-                    }
-                    catch (err) {
-                        console.warn(`[CompactionResume] Slack orchestrator failed, falling back to direct inject:`, err);
-                    }
-                }
-                const ok = sessionManager.injectMessage(sessionName, text);
+                // Direct injection — bypass triage (see comment on recoverCompactedSession).
+                const ok = sessionManager.injectMessage(sessionName, COMPACTION_RESUME_PROMPT);
                 if (ok) {
                     console.log(`[CompactionResume] (${triggerLabel}) Slack direct re-inject OK for channel ${channelId}`);
                     return true;
@@ -5022,23 +5074,43 @@ export async function startServer(options) {
             // Non-fatal — agent works without Threadline
             console.warn(pc.yellow(`  Threadline: failed to bootstrap — ${err instanceof Error ? err.message : String(err)}`));
         }
-        // Response Review Pipeline (Coherence Gate) — evaluates agent responses before delivery
+        // Messaging Tone Gate — always-on tone check on outbound messaging routes.
+        // Uses the shared IntelligenceProvider (Claude CLI subscription by default,
+        // Anthropic API if key is set). No opt-in. Catches CLI commands, file paths,
+        // config syntax, and other technical leakage in agent-to-user messages.
+        let messagingToneGate;
+        if (sharedIntelligence) {
+            const { MessagingToneGate } = await import('../core/MessagingToneGate.js');
+            messagingToneGate = new MessagingToneGate(sharedIntelligence);
+            console.log(pc.green('  Messaging tone gate: active (Haiku via shared IntelligenceProvider)'));
+        }
+        else {
+            console.log(pc.yellow('  Messaging tone gate: inactive (no IntelligenceProvider available)'));
+        }
+        // Response Review Pipeline (Coherence Gate) — evaluates agent responses before delivery.
+        // Prefers the shared IntelligenceProvider (subscription-compatible) so the gate works
+        // even without ANTHROPIC_API_KEY. Falls back to direct Anthropic API if a key is set
+        // and no intelligence is available.
         let responseReviewGate;
         if (config.responseReview?.enabled) {
-            const anthropicKey = process.env['ANTHROPIC_API_KEY']?.trim();
-            if (anthropicKey) {
+            const anthropicKey = process.env['ANTHROPIC_API_KEY']?.trim() ?? '';
+            if (sharedIntelligence || anthropicKey) {
                 const { CoherenceGate } = await import('../core/CoherenceGate.js');
                 responseReviewGate = new CoherenceGate({
                     config: config.responseReview,
                     stateDir: config.stateDir,
                     apiKey: anthropicKey,
+                    intelligence: sharedIntelligence,
                     relationships: relationships ?? undefined,
                     adaptiveTrust: adaptiveTrust ?? undefined,
                 });
-                console.log(pc.green(`  Response review pipeline: enabled (${Object.keys(config.responseReview.reviewers ?? {}).length} reviewers configured)`));
+                const backend = sharedIntelligence
+                    ? 'via shared IntelligenceProvider'
+                    : 'via Anthropic API (direct)';
+                console.log(pc.green(`  Response review pipeline: enabled ${backend} (${Object.keys(config.responseReview.reviewers ?? {}).length} reviewers configured)`));
             }
             else {
-                console.warn(pc.yellow(`  Response review pipeline: configured but ANTHROPIC_API_KEY not set`));
+                console.warn(pc.yellow(`  Response review pipeline: configured but no IntelligenceProvider or ANTHROPIC_API_KEY available`));
             }
         }
         // Feature Registry (Consent & Discovery Framework — Phase 1)
@@ -5114,7 +5186,7 @@ export async function startServer(options) {
                 return { content: lines.join('\n'), truncated: false, elapsedMs: Date.now() - start };
             }, { description: 'Feature discovery state and behavioral contract summary' });
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig });
         await server.start();
         // Connect DegradationReporter downstream systems now that everything is initialized.
         // Any degradation events queued during startup will drain to feedback + telegram.