npm - aegis-bridge - Versions diffs - 2.6.3 → 2.7.0 - Mend

aegis-bridge 2.6.3 → 2.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dashboard/dist/assets/{index-Bfabq3q-.js → index-SoKhTCVa.js} +25 -25
package/dashboard/dist/index.html +1 -1
package/dist/hook-settings.d.ts +12 -3
package/dist/hook-settings.js +63 -2
package/dist/monitor.d.ts +10 -0
package/dist/monitor.js +53 -31
package/dist/server.js +87 -3
package/dist/session.d.ts +9 -0
package/dist/session.js +38 -2
package/dist/tool-registry.d.ts +40 -0
package/dist/tool-registry.js +83 -0
package/dist/transcript.js +16 -6
package/dist/validation.d.ts +36 -0
package/dist/validation.js +15 -0
package/package.json +1 -1
package/dist/dashboard/assets/index-9Hkkvm_I.css +0 -32
package/dist/dashboard/assets/index-Bfabq3q-.js +0 -262
package/dist/dashboard/index.html +0 -14

package/dashboard/dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Aegis Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🛡️</text></svg>" />
-    <script type="module" crossorigin src="/dashboard/assets/index-Bfabq3q-.js"></script>
+    <script type="module" crossorigin src="/dashboard/assets/index-SoKhTCVa.js"></script>
     <link rel="stylesheet" crossorigin href="/dashboard/assets/index-9Hkkvm_I.css">
   </head>
   <body class="bg-[#0a0a0f] text-gray-200 antialiased">

package/dist/hook-settings.d.ts CHANGED Viewed

@@ -19,12 +19,11 @@
  * for Aegis status detection and event forwarding.
  *
  * Excluded (low value for Aegis):
- *   - InstructionsLoaded, ConfigChange, CwdChanged, FileChanged (informational)
+ *   - InstructionsLoaded, ConfigChange (informational)
  *   - WorktreeCreate, WorktreeRemove (worktree management)
  *   - Elicitation, ElicitationResult (MCP-specific)
- *   - PreCompact, PostCompact (internal optimization)
  */
-declare const HTTP_HOOK_EVENTS: readonly ["Stop", "StopFailure", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest", "TaskCompleted", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart", "SubagentStop", "Notification", "TeammateIdle"];
+declare const HTTP_HOOK_EVENTS: readonly ["Stop", "StopFailure", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest", "TaskCompleted", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "FileChanged", "CwdChanged", "Notification", "TeammateIdle"];
 export { HTTP_HOOK_EVENTS };
 export type HttpHookEvent = typeof HTTP_HOOK_EVENTS[number];
 /** Shape of a single HTTP hook entry in CC settings.json. */
@@ -66,3 +65,13 @@ export declare function writeHookSettingsFile(baseUrl: string, sessionId: string
  * @param filePath - Path to the temporary settings file
  */
 export declare function cleanupHookSettingsFile(filePath: string): Promise<void>;
+/**
+ * Issue #936: Clean stale session hooks from settings.local.json before writing new hooks.
+ *
+ * When sessions die, their hook URLs remain in settings.local.json.
+ * On restart, CC loads these dead hooks and crashes.
+ *
+ * @param workDir - Project working directory
+ * @param activeSessionIds - Set of currently active session IDs
+ */
+export declare function cleanupStaleSessionHooks(workDir: string, activeSessionIds: Set<string>): Promise<void>;

package/dist/hook-settings.js CHANGED Viewed

@@ -43,10 +43,9 @@ function validateWorkDirPath(workDir) {
  * for Aegis status detection and event forwarding.
  *
  * Excluded (low value for Aegis):
- *   - InstructionsLoaded, ConfigChange, CwdChanged, FileChanged (informational)
+ *   - InstructionsLoaded, ConfigChange (informational)
  *   - WorktreeCreate, WorktreeRemove (worktree management)
  *   - Elicitation, ElicitationResult (MCP-specific)
- *   - PreCompact, PostCompact (internal optimization)
  */
 const HTTP_HOOK_EVENTS = [
     // Status detection (highest value)
@@ -64,6 +63,12 @@ const HTTP_HOOK_EVENTS = [
     // Subagent tracking
     'SubagentStart',
     'SubagentStop',
+    // Context management
+    'PreCompact',
+    'PostCompact',
+    // File & directory changes
+    'FileChanged',
+    'CwdChanged',
     // Notifications
     'Notification',
     'TeammateIdle',
@@ -135,6 +140,10 @@ export async function writeHookSettingsFile(baseUrl, sessionId, hookSecret, work
         mergedHooks[event] = [...(existingHooks[event] ?? []), ...entries];
     }
     const combined = { ...merged, hooks: mergedHooks };
+    // Issue #931: Always inject MCP_CONNECTION_NONBLOCKING so CC does not block
+    // on MCP server connections when launched via Aegis orchestration.
+    (combined.env = (combined.env || {}));
+    (combined.env || {})["MCP_CONNECTION_NONBLOCKING"] = "true";
     // Issue #648: Use unpredictable directory name and restrictive permissions
     // to prevent symlink attacks and information disclosure in /tmp.
     const suffix = randomBytes(4).toString('hex');
@@ -164,3 +173,55 @@ export async function cleanupHookSettingsFile(filePath) {
         // Non-fatal: temp file cleanup failed
     }
 }
+/**
+ * Issue #936: Clean stale session hooks from settings.local.json before writing new hooks.
+ *
+ * When sessions die, their hook URLs remain in settings.local.json.
+ * On restart, CC loads these dead hooks and crashes.
+ *
+ * @param workDir - Project working directory
+ * @param activeSessionIds - Set of currently active session IDs
+ */
+export async function cleanupStaleSessionHooks(workDir, activeSessionIds) {
+    const safeWorkDir = workDir ? validateWorkDirPath(workDir) : undefined;
+    if (!safeWorkDir)
+        return;
+    const projectSettingsPath = join(safeWorkDir, '.claude', 'settings.local.json');
+    if (!existsSync(projectSettingsPath))
+        return;
+    try {
+        const raw = await readFile(projectSettingsPath, 'utf-8');
+        const parsed = ccSettingsSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success)
+            return;
+        const settings = parsed.data;
+        const hooks = settings.hooks;
+        if (!hooks)
+            return;
+        let changed = false;
+        for (const [event, eventHooks] of Object.entries(hooks)) {
+            const filtered = eventHooks.filter(entry => {
+                const httpHook = entry.hooks?.find(h => h.type === 'http');
+                if (!httpHook)
+                    return true;
+                const url = httpHook.url;
+                const match = url.match(/[?&]sessionId=([^&]+)/);
+                if (!match)
+                    return true;
+                const sessionId = match[1];
+                if (!activeSessionIds.has(sessionId)) {
+                    changed = true;
+                    return false;
+                }
+                return true;
+            });
+            hooks[event] = filtered;
+        }
+        if (changed) {
+            await writeFile(projectSettingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        }
+    }
+    catch {
+        // Non-fatal: cleanup failed
+    }
+}

package/dist/monitor.d.ts CHANGED Viewed

@@ -31,6 +31,16 @@ export declare class SessionMonitor {
     private lastStatus;
     private lastBytesSeen;
     private stallNotified;
+    /** Issue #663: O(1) stall notification check. */
+    private stallHas;
+    /** Issue #663: O(1) stall notification add. */
+    private stallAdd;
+    /** Issue #663: O(1) stall notification delete. */
+    private stallDelete;
+    /** Issue #663: Delete all stall notifications for a session. */
+    private stallDeleteAll;
+    /** Issue #663: Delete specific stall types for a session. */
+    private stallDeleteTypes;
     private lastStallCheck;
     private lastDeadCheck;
     private idleNotified;

package/dist/monitor.js CHANGED Viewed

@@ -34,7 +34,38 @@ export class SessionMonitor {
     running = false;
     lastStatus = new Map();
     lastBytesSeen = new Map();
-    stallNotified = new Set(); // don't spam stall events
+    // Issue #663: Nested Map for O(1) per-session stall lookup (was Set with O(n) prefix scan)
+    stallNotified = new Map(); // sessionId → Set<stallType>
+    /** Issue #663: O(1) stall notification check. */
+    stallHas(sessionId, stallType) {
+        return this.stallNotified.get(sessionId)?.has(stallType) ?? false;
+    }
+    /** Issue #663: O(1) stall notification add. */
+    stallAdd(sessionId, stallType) {
+        const set = this.stallNotified.get(sessionId);
+        if (set) {
+            set.add(stallType);
+        }
+        else {
+            this.stallNotified.set(sessionId, new Set([stallType]));
+        }
+    }
+    /** Issue #663: O(1) stall notification delete. */
+    stallDelete(sessionId, stallType) {
+        this.stallNotified.get(sessionId)?.delete(stallType);
+    }
+    /** Issue #663: Delete all stall notifications for a session. */
+    stallDeleteAll(sessionId) {
+        this.stallNotified.delete(sessionId);
+    }
+    /** Issue #663: Delete specific stall types for a session. */
+    stallDeleteTypes(sessionId, types) {
+        const set = this.stallNotified.get(sessionId);
+        if (!set)
+            return;
+        for (const t of types)
+            set.delete(t);
+    }
     lastStallCheck = 0;
     lastDeadCheck = 0;
     idleNotified = new Set(); // prevent idle spam
@@ -196,13 +227,13 @@ export class SessionMonitor {
                 }
                 if (currentBytes > prev.bytes) {
                     this.lastBytesSeen.set(session.id, { bytes: currentBytes, at: now });
-                    this.stallNotified.delete(`${session.id}:stall:jsonl`);
+                    this.stallDelete(session.id, 'jsonl');
                 }
                 else {
                     const stallDuration = now - prev.at;
                     const threshold = session.stallThresholdMs || this.config.stallThresholdMs;
-                    if (stallDuration >= threshold && !this.stallNotified.has(`${session.id}:stall:jsonl`)) {
-                        this.stallNotified.add(`${session.id}:stall:jsonl`);
+                    if (stallDuration >= threshold && !this.stallHas(session.id, 'jsonl')) {
+                        this.stallAdd(session.id, 'jsonl');
                         const minutes = Math.round(stallDuration / 60000);
                         const detail = `Session stalled: "working" for ${minutes}min with no new output. ` +
                             `Last activity: ${new Date(session.lastActivity).toISOString()}`;
@@ -213,15 +244,15 @@ export class SessionMonitor {
             }
             else {
                 // Reset JSONL stall tracking when not working
-                this.stallNotified.delete(`${session.id}:stall:jsonl`);
+                this.stallDelete(session.id, 'jsonl');
             }
             // --- Type 2: Permission stall (waiting for approval too long) ---
             if (currentStatus === 'permission_prompt' || currentStatus === 'bash_approval') {
                 const entry = this.stateSince.get(session.id);
                 const permDuration = entry ? now - entry.since : 0;
                 if (permDuration >= this.config.permissionStallMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:permission`)) {
-                        this.stallNotified.add(`${session.id}:stall:permission`);
+                    if (!this.stallHas(session.id, 'permission')) {
+                        this.stallAdd(session.id, 'permission');
                         const minutes = Math.round(permDuration / 60000);
                         const detail = `Session stalled: waiting for permission approval for ${minutes}min. ` +
                             `Auto-approve this session or POST /v1/sessions/${session.id}/approve`;
@@ -231,8 +262,8 @@ export class SessionMonitor {
                 }
                 // L9: Auto-reject permission after timeout
                 if (permDuration >= this.config.permissionTimeoutMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:permission_timeout`)) {
-                        this.stallNotified.add(`${session.id}:stall:permission_timeout`);
+                    if (!this.stallHas(session.id, 'permission_timeout')) {
+                        this.stallAdd(session.id, 'permission_timeout');
                         const minutes = Math.round(permDuration / 60000);
                         logger.warn({
                             component: 'monitor',
@@ -264,8 +295,8 @@ export class SessionMonitor {
                 const entry = this.stateSince.get(session.id);
                 const unkDuration = entry ? now - entry.since : 0;
                 if (unkDuration >= this.config.unknownStallMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:unknown`)) {
-                        this.stallNotified.add(`${session.id}:stall:unknown`);
+                    if (!this.stallHas(session.id, 'unknown')) {
+                        this.stallAdd(session.id, 'unknown');
                         const minutes = Math.round(unkDuration / 60000);
                         const detail = `Session stalled: in "unknown" state for ${minutes}min. ` +
                             `CC may be stuck. Try: POST /v1/sessions/${session.id}/interrupt or /kill`;
@@ -280,8 +311,8 @@ export class SessionMonitor {
                 const stateDuration = entry ? now - entry.since : 0;
                 const extendedThreshold = this.config.stallThresholdMs * 2;
                 if (stateDuration >= extendedThreshold) {
-                    if (!this.stallNotified.has(`${session.id}:stall:extended`)) {
-                        this.stallNotified.add(`${session.id}:stall:extended`);
+                    if (!this.stallHas(session.id, 'extended')) {
+                        this.stallAdd(session.id, 'extended');
                         const minutes = Math.round(stateDuration / 60000);
                         const detail = `Session stalled: "${currentStatus}" state for ${minutes}min. ` +
                             `May need intervention: /interrupt, /approve, or /kill`;
@@ -297,8 +328,8 @@ export class SessionMonitor {
                 if (entry && entry.state === 'working') {
                     const workingDuration = now - entry.since;
                     const maxWorkingMs = this.config.stallThresholdMs * 3; // 15 min default
-                    if (workingDuration >= maxWorkingMs && !this.stallNotified.has(`${session.id}:stall:extended_working`)) {
-                        this.stallNotified.add(`${session.id}:stall:extended_working`);
+                    if (workingDuration >= maxWorkingMs && !this.stallHas(session.id, 'extended_working')) {
+                        this.stallAdd(session.id, 'extended_working');
                         const minutes = Math.round(workingDuration / 60000);
                         const detail = `Session stalled: in "working" state for ${minutes}min. ` +
                             `CC may be stuck in an internal loop (e.g., Misting). Consider: POST /v1/sessions/${session.id}/interrupt or /kill`;
@@ -312,23 +343,18 @@ export class SessionMonitor {
                 const exitedPermission = prevStallStatus === 'permission_prompt' || prevStallStatus === 'bash_approval';
                 const exitedUnknown = prevStallStatus === 'unknown';
                 if (exitedPermission) {
-                    this.stallNotified.delete(`${session.id}:stall:permission`);
-                    this.stallNotified.delete(`${session.id}:stall:permission_timeout`);
+                    this.stallDeleteTypes(session.id, ['permission', 'permission_timeout']);
                 }
                 if (exitedUnknown) {
-                    this.stallNotified.delete(`${session.id}:stall:unknown`);
+                    this.stallDelete(session.id, 'unknown');
                 }
             }
             // Clean up all state tracking when idle (catch-all)
             if (currentStatus === 'idle') {
                 this.rateLimitedSessions.delete(session.id);
                 this.stateSince.delete(session.id);
-                // Clean stall notifications (session recovered)
-                for (const key of this.stallNotified) {
-                    if (key.startsWith(session.id)) {
-                        this.stallNotified.delete(key);
-                    }
-                }
+                // Clean stall notifications (session recovered) — O(1) with Map
+                this.stallDeleteAll(session.id);
             }
             // Update prevStatusForStall for next cycle
             if (currentStatus) {
@@ -432,7 +458,7 @@ export class SessionMonitor {
             if (event.messages.length > 0) {
                 // Real output — reset stall timer
                 this.lastBytesSeen.set(event.sessionId, { bytes: event.newOffset, at: now });
-                this.stallNotified.delete(`${event.sessionId}:stall:jsonl`);
+                this.stallDelete(event.sessionId, 'jsonl');
             }
             else {
                 // File grew but no messages — only update bytes, keep timestamp
@@ -666,12 +692,8 @@ export class SessionMonitor {
             clearTimeout(pending);
             this.statusChangeDebounce.delete(sessionId);
         }
-        // Clean all stall notifications for this session
-        for (const key of this.stallNotified) {
-            if (key.startsWith(sessionId)) {
-                this.stallNotified.delete(key);
-            }
-        }
+        // Clean all stall notifications for this session — O(1) with Map
+        this.stallDeleteAll(sessionId);
         this.idleNotified.delete(sessionId);
         this.idleSince.delete(sessionId);
         this.stateSince.delete(sessionId);

package/dist/server.js CHANGED Viewed

@@ -24,11 +24,12 @@ import { ChannelManager, TelegramChannel, WebhookChannel, } from './channels/ind
 import { loadConfig } from './config.js';
 import { captureScreenshot, isPlaywrightAvailable } from './screenshot.js';
 import { validateScreenshotUrl, resolveAndCheckIp, buildHostResolverRule } from './ssrf.js';
-import { validateWorkDir } from './validation.js';
+import { validateWorkDir, permissionRuleSchema } from './validation.js';
 import { SessionEventBus } from './events.js';
 import { SSEWriter } from './sse-writer.js';
 import { SSEConnectionLimiter } from './sse-limiter.js';
 import { PipelineManager } from './pipeline.js';
+import { ToolRegistry } from './tool-registry.js';
 import { AuthManager } from './auth.js';
 import { MetricsCollector } from './metrics.js';
 import { registerPermissionRoutes } from './permission-routes.js';
@@ -57,6 +58,7 @@ const channels = new ChannelManager();
 const eventBus = new SessionEventBus();
 let sseLimiter;
 let pipelines;
+let toolRegistry;
 let auth;
 let metrics;
 let swarmMonitor;
@@ -320,6 +322,7 @@ const createSessionSchema = z.object({
     stallThresholdMs: z.number().int().positive().max(3_600_000).optional(),
     permissionMode: z.enum(['default', 'bypassPermissions', 'plan', 'acceptEdits', 'dontAsk', 'auto']).optional(),
     autoApprove: z.boolean().optional(),
+    parentId: z.string().uuid().optional(),
 }).strict();
 // Health — Issue #397: includes tmux server health check
 async function healthHandler() {
@@ -420,6 +423,29 @@ app.get('/v1/sessions/:id/metrics', async (req, reply) => {
         return reply.status(404).send({ error: 'No metrics for this session' });
     return m;
 });
+// Issue #704: Tool usage endpoints
+app.get('/v1/sessions/:id/tools', async (req, reply) => {
+    const session = sessions.getSession(req.params.id);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    // Parse JSONL on-demand for tool usage
+    const { readNewEntries } = await import('./transcript.js');
+    if (session.jsonlPath) {
+        try {
+            const result = await readNewEntries(session.jsonlPath, 0);
+            const entries = result.entries;
+            toolRegistry.processEntries(req.params.id, entries);
+        }
+        catch { /* JSONL not available */ }
+    }
+    const tools = toolRegistry.getSessionTools(req.params.id);
+    return { sessionId: req.params.id, tools, totalCalls: tools.reduce((sum, t) => sum + t.count, 0) };
+});
+app.get('/v1/tools', async () => {
+    const definitions = toolRegistry.getToolDefinitions();
+    const categories = [...new Set(definitions.map(t => t.category))];
+    return { tools: definitions, categories, totalTools: definitions.length };
+});
 // Issue #89 L14: Webhook dead letter queue
 app.get('/v1/webhooks/dead-letter', async () => {
     for (const ch of channels.getChannels()) {
@@ -550,7 +576,7 @@ async function createSessionHandler(req, reply) {
     if (!parsed.success) {
         return reply.status(400).send({ error: 'Invalid request body', details: parsed.error.issues });
     }
-    const { workDir, name, prompt, resumeSessionId, claudeCommand, env, stallThresholdMs, permissionMode, autoApprove } = parsed.data;
+    const { workDir, name, prompt, resumeSessionId, claudeCommand, env, stallThresholdMs, permissionMode, autoApprove, parentId } = parsed.data;
     if (!workDir)
         return reply.status(400).send({ error: 'workDir is required' });
     // Issue #564: Validate installed Claude Code version
@@ -588,7 +614,7 @@ async function createSessionHandler(req, reply) {
         }
     }
     console.time("POST_CREATE_SESSION");
-    const session = await sessions.createSession({ workDir: safeWorkDir, name, resumeSessionId, claudeCommand, env, stallThresholdMs, permissionMode, autoApprove });
+    const session = await sessions.createSession({ workDir: safeWorkDir, name, resumeSessionId, claudeCommand, env, stallThresholdMs, permissionMode, autoApprove, parentId });
     console.timeEnd("POST_CREATE_SESSION");
     console.time("POST_CHANNEL_CREATED");
     // Issue #625: Track session in metrics so sessionsCreated counter is accurate
@@ -682,6 +708,61 @@ async function sendMessageHandler(req, reply) {
 }
 app.post('/v1/sessions/:id/send', sendMessageHandler);
 app.post('/sessions/:id/send', sendMessageHandler);
+// Issue #702: GET children sessions
+async function getChildrenHandler(req, reply) {
+    const session = sessions.getSession(req.params.id);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    const children = (session.children ?? []).map(id => {
+        const child = sessions.getSession(id);
+        if (!child)
+            return null;
+        return { id: child.id, windowName: child.windowName, status: child.status, createdAt: child.createdAt };
+    }).filter(Boolean);
+    return { children };
+}
+app.get('/v1/sessions/:id/children', getChildrenHandler);
+app.get('/sessions/:id/children', getChildrenHandler);
+async function spawnChildHandler(req, reply) {
+    const parentId = req.params.id;
+    const parent = sessions.getSession(parentId);
+    if (!parent)
+        return reply.status(404).send({ error: 'Parent session not found' });
+    const { name, prompt, workDir, permissionMode } = req.body ?? {};
+    const childName = name ?? `${parent.windowName ?? 'session'}-child`;
+    const childWorkDir = workDir ?? parent.workDir;
+    const childPermMode = permissionMode ?? parent.permissionMode ?? 'bypassPermissions';
+    const childSession = await sessions.createSession({ workDir: childWorkDir, name: childName, parentId, permissionMode: childPermMode });
+    let promptDelivery;
+    if (prompt) {
+        promptDelivery = await sessions.sendInitialPrompt(childSession.id, prompt);
+    }
+    return reply.status(201).send({ ...childSession, promptDelivery });
+}
+app.post('/v1/sessions/:id/spawn', spawnChildHandler);
+app.post('/sessions/:id/spawn', spawnChildHandler);
+async function getPermissionPolicyHandler(req, reply) {
+    const session = sessions.getSession(req.params.id);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    return { permissionPolicy: session.permissionPolicy ?? [] };
+}
+async function updatePermissionPolicyHandler(req, reply) {
+    const session = sessions.getSession(req.params.id);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    const policy = req.body ?? [];
+    const result = permissionRuleSchema.array().safeParse(policy);
+    if (!result.success)
+        return reply.status(400).send({ error: 'Invalid permission policy', details: result.error.issues });
+    session.permissionPolicy = policy;
+    await sessions.save();
+    return { permissionPolicy: policy };
+}
+app.get('/v1/sessions/:id/permissions', getPermissionPolicyHandler);
+app.put('/v1/sessions/:id/permissions', updatePermissionPolicyHandler);
+app.get('/sessions/:id/permissions', getPermissionPolicyHandler);
+app.put('/sessions/:id/permissions', updatePermissionPolicyHandler);
 // Read messages
 async function readMessagesHandler(req, reply) {
     try {
@@ -1109,6 +1190,7 @@ async function reapStaleSessions(maxAgeMs) {
                 });
                 monitor.removeSession(session.id);
                 metrics.cleanupSession(session.id);
+                toolRegistry.cleanupSession(session.id);
             }
             catch (e) {
                 console.error(`Reaper: failed to kill session ${session.id}:`, e);
@@ -1138,6 +1220,7 @@ async function reapZombieSessions() {
             eventBus.cleanupSession(session.id);
             await sessions.killSession(session.id);
             metrics.cleanupSession(session.id);
+            toolRegistry.cleanupSession(session.id);
             await channels.sessionEnded({
                 event: 'session.ended',
                 timestamp: new Date().toISOString(),
@@ -1537,6 +1620,7 @@ async function main() {
     monitor.start();
     // Issue #81: Start swarm monitor for agent swarm awareness
     swarmMonitor = new SwarmMonitor(sessions);
+    toolRegistry = new ToolRegistry();
     swarmMonitor.onEvent((event) => {
         if (!event.swarm.parentSession)
             return;

package/dist/session.d.ts CHANGED Viewed

@@ -8,6 +8,7 @@ import { TmuxManager } from './tmux.js';
 import { type ParsedEntry } from './transcript.js';
 import { type UIState } from './terminal-parser.js';
 import type { Config } from './config.js';
+import { type PermissionPolicy } from './validation.js';
 export interface SessionInfo {
     id: string;
     windowId: string;
@@ -35,6 +36,9 @@ export interface SessionInfo {
     model?: string;
     lastDeadAt?: number;
     ccPid?: number;
+    parentId?: string;
+    children?: string[];
+    permissionPolicy?: PermissionPolicy;
 }
 export interface SessionState {
     sessions: Record<string, SessionInfo>;
@@ -66,6 +70,7 @@ export declare class SessionManager {
     private pendingQuestions;
     private static readonly MAX_CACHE_ENTRIES_PER_SESSION;
     private parsedEntriesCache;
+    private sessionsListCache;
     private readonly sessionAcquireMutex;
     constructor(tmux: TmuxManager, config: Config);
     /**
@@ -135,6 +140,8 @@ export declare class SessionManager {
         permissionMode?: string;
         /** @deprecated Use permissionMode instead. Maps true→bypassPermissions, false→default. */
         autoApprove?: boolean;
+        /** Issue #702: Parent session ID for sub-agent hierarchy */
+        parentId?: string;
     }): Promise<SessionInfo>;
     /** Get a session by ID. */
     getSession(id: string): SessionInfo | null;
@@ -165,6 +172,8 @@ export declare class SessionManager {
      *  so the current pane PID is the shell (alive). Checking ccPid catches
      *  the crash within seconds instead of waiting for the 5-min stall timer. */
     isWindowAlive(id: string): Promise<boolean>;
+    /** Issue #657: Invalidate the sessions list cache. Call on any mutation. */
+    private invalidateSessionsListCache;
     /** List all sessions. */
     listSessions(): SessionInfo[];
     /** Issue #607: Find an idle session for the given workDir.

package/dist/session.js CHANGED Viewed

@@ -16,7 +16,7 @@ import { computeStallThreshold } from './config.js';
 import { neutralizeBypassPermissions, restoreSettings, cleanOrphanedBackup } from './permission-guard.js';
 import { persistedStateSchema } from './validation.js';
 import { loadContinuationPointers } from './continuation-pointer.js';
-import { writeHookSettingsFile, cleanupHookSettingsFile } from './hook-settings.js';
+import { writeHookSettingsFile, cleanupHookSettingsFile, cleanupStaleSessionHooks } from './hook-settings.js';
 import { Mutex } from 'async-mutex';
 import { maybeInjectFault } from './fault-injection.js';
 /** Convert parsed JSON arrays to Sets for activeSubagents (#668). */
@@ -67,6 +67,8 @@ export class SessionManager {
     // #424: Evict oldest entries when cache exceeds max to prevent unbounded growth
     static MAX_CACHE_ENTRIES_PER_SESSION = 10_000;
     parsedEntriesCache = new Map();
+    // Issue #657: Cached session list to avoid allocating a new array per call
+    sessionsListCache = null;
     // Issue #840/#880: Explicit mutex to prevent TOCTOU races in session acquisition.
     sessionAcquireMutex = new Mutex();
     constructor(tmux, config) {
@@ -168,6 +170,8 @@ export class SessionManager {
             await writeFile(`${this.stateFile}.bak`, JSON.stringify(this.state, null, 2));
         }
         catch { /* non-critical */ }
+        // Issue #657: Invalidate sessions list cache after loading state
+        this.invalidateSessionsListCache();
         // Reconcile: verify tmux windows still exist, clean up dead sessions
         await this.reconcile();
     }
@@ -190,6 +194,7 @@ export class SessionManager {
                     await cleanOrphanedBackup(session.workDir);
                 }
                 delete this.state.sessions[id];
+                this.invalidateSessionsListCache();
                 changed = true;
             }
             else if (!windowIdAlive && windowNameAlive) {
@@ -245,6 +250,7 @@ export class SessionManager {
                 permissionMode: 'default',
             };
             this.state.sessions[id] = session;
+            this.invalidateSessionsListCache();
             console.log(`Reconcile: adopted orphaned window ${win.windowName} (${win.windowId}) as ${id.slice(0, 8)}`);
             this.startSessionIdDiscovery(id);
             this.startFilesystemDiscovery(id, session.workDir);
@@ -506,6 +512,17 @@ export class SessionManager {
         const hookSecret = randomBytes(32).toString('hex');
         // Issue #169 Phase 2: Generate HTTP hook settings for this session.
         // Writes a temp file with hooks pointing to Aegis's hook receiver.
+        // Issue #936: Clean stale session hooks from settings.local.json before writing new hooks.
+        // This prevents CC from loading dead hook URLs on restart.
+        try {
+            const activeIds = new Set(this.listSessions().map(s => s.id));
+            if (activeIds.size > 0) {
+                await cleanupStaleSessionHooks(opts.workDir, activeIds);
+            }
+        }
+        catch (e) {
+            console.warn(`Hook cleanup: failed to clean stale hooks: ${e.message}`);
+        }
         let hookSettingsFile;
         try {
             const baseUrl = `http://${this.config.host}:${this.config.port}`;
@@ -545,7 +562,18 @@ export class SessionManager {
             hookSecret,
         };
         this.state.sessions[id] = session;
+        this.invalidateSessionsListCache();
         await this.save();
+        // Issue #702: Register child with parent
+        if (opts.parentId) {
+            const parent = this.state.sessions[opts.parentId];
+            if (parent) {
+                if (!parent.children)
+                    parent.children = [];
+                parent.children.push(id);
+                await this.save();
+            }
+        }
         // Issue #353: Fetch CC process PID for swarm parent matching.
         // Fire-and-forget — PID is not needed synchronously.
         // Issue #574: Add .catch() to prevent unhandled rejection if tmux fails mid-lookup.
@@ -744,9 +772,16 @@ export class SessionManager {
             return false;
         }
     }
+    /** Issue #657: Invalidate the sessions list cache. Call on any mutation. */
+    invalidateSessionsListCache() {
+        this.sessionsListCache = null;
+    }
     /** List all sessions. */
     listSessions() {
-        return Object.values(this.state.sessions);
+        if (!this.sessionsListCache) {
+            this.sessionsListCache = Object.values(this.state.sessions);
+        }
+        return this.sessionsListCache;
     }
     /** Issue #607: Find an idle session for the given workDir.
      *  Returns the most recently active idle session, or null if none found.
@@ -1320,6 +1355,7 @@ export class SessionManager {
         // #405: Clean up all tracking maps (pollTimers, pendingPermissions, pendingQuestions, parsedEntriesCache)
         this.cleanupSession(id);
         delete this.state.sessions[id];
+        this.invalidateSessionsListCache();
         // #357: Cancel any pending debounced save before doing an immediate save
         if (this.saveDebounceTimer !== null) {
             clearTimeout(this.saveDebounceTimer);