aegis-bridge 2.15.0 → 2.15.1

package/dist/api-contracts.d.ts

@@ -138,7 +138,7 @@ export interface GlobalMetrics {
         channel_delivery_ms: LatencySummaryStat;
     };
 }
-export type SSEEventType = 'status' | 'message' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'system' | 'hook' | 'subagent_start' | 'subagent_stop' | 'verification';
+export type SSEEventType = 'status' | 'message' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'system' | 'hook' | 'subagent_start' | 'subagent_stop' | 'verification' | 'permission_denied';
 export interface SessionSSEEvent {
     event: SSEEventType;
     sessionId: string;
@@ -203,3 +203,22 @@ export interface SessionsListResponse {
     };
 }
 export type SessionStatusCounts = Record<SessionStatusFilter, number>;
+/** Issue #754: Aggregated session statistics. */
+export interface SessionStats {
+    active: number;
+    byStatus: Partial<Record<UIState, number>>;
+    totalCreated: number;
+    totalCompleted: number;
+    totalFailed: number;
+}
+/** Issue #754: Bulk-delete request body. */
+export interface BatchDeleteRequest {
+    ids?: string[];
+    status?: UIState;
+}
+/** Issue #754: Bulk-delete response. */
+export interface BatchDeleteResponse {
+    deleted: number;
+    notFound: string[];
+    errors: string[];
+}

package/dist/events.d.ts

@@ -6,7 +6,7 @@
  * The monitor pushes events; the SSE route consumes them.
  */
 export interface SessionSSEEvent {
-    event: 'status' | 'message' | 'system' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'hook' | 'subagent_start' | 'subagent_stop' | 'verification';
+    event: 'status' | 'message' | 'system' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'hook' | 'subagent_start' | 'subagent_stop' | 'verification' | 'permission_denied';
     sessionId: string;
     timestamp: string;
     data: Record<string, unknown>;

package/dist/hooks.js

@@ -49,12 +49,23 @@ const KNOWN_HOOK_EVENTS = new Set([
     'ElicitationResult',
     'FileChanged',
     'CwdChanged',
+    // Issue #703 Phase 1: additional lifecycle events
+    'PermissionDenied',
+    'TaskCreated',
+    'Setup',
+    'ConfigChange',
+    'InstructionsLoaded',
 ]);
 /** Hook events that are informational (logged + forwarded to SSE, no status change). */
 const INFORMATIONAL_EVENTS = new Set([
     'Notification',
     'FileChanged',
     'CwdChanged',
+    // Issue #703 Phase 1: informational lifecycle events
+    'Setup',
+    'ConfigChange',
+    'InstructionsLoaded',
+    'PermissionDenied',
 ]);
 /** Map hook event names to the UIState they imply. */
 function hookToUIState(eventName) {
@@ -76,6 +87,8 @@ function hookToUIState(eventName) {
         case 'PreCompact': return 'compacting';
         case 'PermissionRequest': return 'permission_prompt';
         case 'TeammateIdle': return 'idle';
+        // Issue #703 Phase 1
+        case 'TaskCreated': return 'working';
         default: return null;
     }
 }
@@ -146,6 +159,18 @@ export function registerHookRoutes(app, deps) {
                 data: { agentName },
             });
         }
+        // Issue #703 Phase 1: PermissionDenied — emit denied event for dashboard/agents
+        if (eventName === 'PermissionDenied') {
+            deps.eventBus.emit(sessionId, {
+                event: 'permission_denied',
+                sessionId,
+                timestamp: new Date().toISOString(),
+                data: {
+                    toolName: hookBody.tool_name || '',
+                    reason: hookBody.reason || '',
+                },
+            });
+        }
         // Issue #89 L26: WorktreeCreate/Remove hooks — informational tracking only
         if (eventName === 'WorktreeCreate' || eventName === 'WorktreeRemove') {
             console.log(`Hooks: ${eventName} for session ${sessionId}`);

package/dist/memory-routes.js

@@ -1,3 +1,4 @@
+import { isValidUUID } from './validation.js';
 import { z } from 'zod';
 const setMemorySchema = z.object({
     key: z.string().max(256),
@@ -50,4 +51,50 @@ export function registerMemoryRoutes(app, bridge) {
             return reply.status(404).send({ error: `Key not found: ${key}` });
         return { ok: true };
     });
+    // Issue #705: Scoped memory retrieval — GET /v1/memories?scope=project|user|team
+    const VALID_SCOPES = new Set(['project', 'user', 'team']);
+    app.get('/v1/memories', async (req, reply) => {
+        const { scope } = req.query;
+        if (!scope || !VALID_SCOPES.has(scope)) {
+            return reply.status(400).send({ error: 'scope must be one of: project, user, team' });
+        }
+        const entries = bridge.list(`${scope}/`);
+        return { scope, entries };
+    });
+    // Issue #705: Session-linked memories — POST /v1/sessions/:id/memories
+    const sessionMemoryWriteSchema = z.object({
+        key: z.string().min(1).max(200),
+        value: z.string().max(100 * 1024),
+        ttlSeconds: z.number().int().positive().max(86400 * 30).optional(),
+    }).strict();
+    app.post('/v1/sessions/:id/memories', async (req, reply) => {
+        const { id } = req.params;
+        if (!isValidUUID(id))
+            return reply.status(400).send({ error: 'Invalid session ID — must be a UUID' });
+        const parsed = sessionMemoryWriteSchema.safeParse(req.body ?? {});
+        if (!parsed.success)
+            return reply.status(400).send({ error: 'Invalid body', details: parsed.error.issues });
+        const { key, value, ttlSeconds } = parsed.data;
+        const fullKey = `session:${id}/${key}`;
+        try {
+            const entry = bridge.set(fullKey, value, ttlSeconds);
+            return { ok: true, entry };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('Invalid key format'))
+                return reply.status(400).send({ error: msg });
+            if (msg.includes('exceeds maximum size'))
+                return reply.status(413).send({ error: msg });
+            throw e;
+        }
+    });
+    // Issue #705: Session-linked memories — GET /v1/sessions/:id/memories
+    app.get('/v1/sessions/:id/memories', async (req, reply) => {
+        const { id } = req.params;
+        if (!isValidUUID(id))
+            return reply.status(400).send({ error: 'Invalid session ID — must be a UUID' });
+        const entries = bridge.list(`session:${id}/`);
+        return { sessionId: id, entries };
+    });
 }

package/dist/model-router.d.ts

@@ -0,0 +1,53 @@
+/**
+ * model-router.ts — Issue #743: Tiered Model Routing
+ *
+ * Scores task complexity from metadata (title, labels, description) and routes
+ * to the optimal model tier: fast | standard | power.
+ *
+ * Scoring (0–100):
+ *   0–30  → fast     (cheapest, e.g. Haiku-class)
+ *   31–70 → standard (balanced, e.g. Sonnet-class)
+ *   71–100 → power   (most capable, e.g. Opus-class)
+ *
+ * Concrete model names are configurable via environment variables:
+ *   MODEL_FAST, MODEL_STANDARD, MODEL_POWER
+ */
+import type { FastifyInstance } from 'fastify';
+export type ModelTier = 'fast' | 'standard' | 'power';
+export interface RoutingDecision {
+    tier: ModelTier;
+    model: string;
+    score: number;
+    reasoning: string[];
+}
+/** Default model names per tier (overridable via env vars). */
+export declare const MODEL_TIERS: Record<ModelTier, string>;
+/**
+ * Score a task 0–100 based on its metadata.
+ * Returns the score and a human-readable reasoning list.
+ */
+export declare function scoreTaskComplexity(title: string, labels: string[], description: string): {
+    score: number;
+    reasoning: string[];
+};
+/** Map a 0–100 score to a model tier. */
+export declare function scoreToTier(score: number): ModelTier;
+/**
+ * Route a task to the optimal model tier and concrete model name.
+ *
+ * @example
+ *   routeTask({ title: 'fix typo in README', labels: ['docs'] })
+ *   // → { tier: 'fast', model: 'claude-haiku-4-5', score: 15, reasoning: [...] }
+ */
+export declare function routeTask(opts: {
+    title: string;
+    labels?: string[];
+    description?: string;
+}): RoutingDecision;
+/**
+ * Register the model-routing endpoint on the Fastify app.
+ *
+ * POST /v1/dev/route-task — score a task and return model recommendation.
+ * GET  /v1/dev/model-tiers — return current model-tier configuration.
+ */
+export declare function registerModelRouterRoutes(app: FastifyInstance): void;

package/dist/model-router.js

@@ -0,0 +1,150 @@
+/**
+ * model-router.ts — Issue #743: Tiered Model Routing
+ *
+ * Scores task complexity from metadata (title, labels, description) and routes
+ * to the optimal model tier: fast | standard | power.
+ *
+ * Scoring (0–100):
+ *   0–30  → fast     (cheapest, e.g. Haiku-class)
+ *   31–70 → standard (balanced, e.g. Sonnet-class)
+ *   71–100 → power   (most capable, e.g. Opus-class)
+ *
+ * Concrete model names are configurable via environment variables:
+ *   MODEL_FAST, MODEL_STANDARD, MODEL_POWER
+ */
+import { z } from 'zod';
+/** Keyword signals mapped to model tier. First match in each tier wins. */
+const ROUTING_KEYWORDS = {
+    power: [
+        'security', 'auth', 'authentication', 'authorization',
+        'architecture', 'redesign', 'migration', 'critical',
+        'vulnerability', 'injection', 'cryptography', 'encryption',
+        'race condition', 'concurrency', 'breaking change',
+        'permission', 'privilege', 'escalation',
+    ],
+    standard: [
+        'feature', 'enhancement', 'refactor', 'type-safety',
+        'integration', 'api', 'endpoint', 'validation',
+        'test', 'coverage', 'hook', 'pipeline', 'routing',
+        'module', 'performance', 'optimization',
+    ],
+    fast: [
+        'typo', 'docs', 'documentation', 'label', 'rename',
+        'bump', 'chore', 'formatting', 'comment', 'readme',
+        'changelog', 'version', 'lint', 'whitespace',
+    ],
+};
+/** Default model names per tier (overridable via env vars). */
+export const MODEL_TIERS = {
+    fast: process.env.MODEL_FAST ?? 'claude-haiku-4-5',
+    standard: process.env.MODEL_STANDARD ?? 'claude-sonnet-4-6',
+    power: process.env.MODEL_POWER ?? 'claude-opus-4-6',
+};
+/**
+ * Score a task 0–100 based on its metadata.
+ * Returns the score and a human-readable reasoning list.
+ */
+export function scoreTaskComplexity(title, labels, description) {
+    const reasoning = [];
+    let score = 35; // baseline: low-standard
+    const text = `${title} ${description}`.toLowerCase();
+    // Power keywords → raise score to at least power tier threshold
+    for (const kw of ROUTING_KEYWORDS.power) {
+        if (text.includes(kw)) {
+            score = Math.max(score, 75);
+            reasoning.push(`power keyword: "${kw}"`);
+            break;
+        }
+    }
+    // Fast keywords → lower score to at most fast tier threshold
+    for (const kw of ROUTING_KEYWORDS.fast) {
+        if (text.includes(kw)) {
+            score = Math.min(score, 20);
+            reasoning.push(`fast keyword: "${kw}"`);
+            break;
+        }
+    }
+    // Standard keywords → minor boost (avoid staying at baseline)
+    if (reasoning.length === 0) {
+        for (const kw of ROUTING_KEYWORDS.standard) {
+            if (text.includes(kw)) {
+                score += 5;
+                reasoning.push(`standard keyword: "${kw}"`);
+                break;
+            }
+        }
+    }
+    // Label overrides — applied after keyword signals
+    for (const label of labels) {
+        const l = label.toLowerCase();
+        if (l === 'security' || l === 'critical' || l === 'breaking-change') {
+            score = Math.max(score, 80);
+            reasoning.push(`label override: "${l}" → power tier`);
+        }
+        else if (l === 'docs' || l === 'documentation' || l === 'chore') {
+            score = Math.min(score, 20);
+            reasoning.push(`label override: "${l}" → fast tier`);
+        }
+    }
+    // Priority labels
+    for (const label of labels) {
+        if (label === 'P0' || label === 'P1') {
+            score = Math.max(score, 72);
+            reasoning.push(`priority label: "${label}" → elevate to power`);
+        }
+        else if (label === 'P3') {
+            score = Math.min(score, 55);
+            reasoning.push(`priority label: "P3" → cap at standard`);
+        }
+    }
+    if (reasoning.length === 0)
+        reasoning.push('baseline score — no keyword or label signals');
+    return { score: Math.max(0, Math.min(100, score)), reasoning };
+}
+/** Map a 0–100 score to a model tier. */
+export function scoreToTier(score) {
+    if (score <= 30)
+        return 'fast';
+    if (score <= 70)
+        return 'standard';
+    return 'power';
+}
+/**
+ * Route a task to the optimal model tier and concrete model name.
+ *
+ * @example
+ *   routeTask({ title: 'fix typo in README', labels: ['docs'] })
+ *   // → { tier: 'fast', model: 'claude-haiku-4-5', score: 15, reasoning: [...] }
+ */
+export function routeTask(opts) {
+    const { title, labels = [], description = '' } = opts;
+    const { score, reasoning } = scoreTaskComplexity(title, labels, description);
+    const tier = scoreToTier(score);
+    const model = MODEL_TIERS[tier];
+    return { tier, model, score, reasoning };
+}
+/** Zod schema for POST /v1/dev/route-task request body. */
+const routeTaskSchema = z.object({
+    title: z.string().min(1).max(500),
+    labels: z.array(z.string().max(100)).max(50).optional(),
+    description: z.string().max(10_000).optional(),
+});
+/**
+ * Register the model-routing endpoint on the Fastify app.
+ *
+ * POST /v1/dev/route-task — score a task and return model recommendation.
+ * GET  /v1/dev/model-tiers — return current model-tier configuration.
+ */
+export function registerModelRouterRoutes(app) {
+    app.post('/v1/dev/route-task', async (req, reply) => {
+        const parsed = routeTaskSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.status(400).send({ error: 'Invalid body', details: parsed.error.issues });
+        }
+        const { title, labels, description } = parsed.data;
+        return routeTask({ title, labels, description });
+    });
+    app.get('/v1/dev/model-tiers', async () => {
+        return { tiers: MODEL_TIERS };
+    });
+}

package/dist/server.js

@@ -36,6 +36,7 @@ import { registerPermissionRoutes } from './permission-routes.js';
 import { registerHookRoutes } from './hooks.js';
 import { registerWsTerminalRoute } from './ws-terminal.js';
 import { registerMemoryRoutes } from './memory-routes.js';
+import { registerModelRouterRoutes } from './model-router.js';
 import * as templateStore from './template-store.js';
 import { SwarmMonitor } from './swarm-monitor.js';
 import { killAllSessions } from './signal-cleanup-helper.js';
@@ -581,15 +582,21 @@ app.get('/v1/events', async (req, reply) => {
     writer.startHeartbeat(30_000, 90_000, () => `data: ${JSON.stringify({ event: 'heartbeat', timestamp: new Date().toISOString() })}\n\n`);
     await reply;
 });
-// List sessions (with pagination and status filter)
+// List sessions (with pagination, status filter, and project filter)
 app.get('/v1/sessions', async (req) => {
     const page = Math.max(1, parseInt(req.query.page || '1', 10) || 1);
     const limit = Math.min(100, Math.max(1, parseInt(req.query.limit || '20', 10) || 20));
     const statusFilter = req.query.status;
+    const projectFilter = req.query.project;
     let all = sessions.listSessions();
     if (statusFilter) {
         all = all.filter(s => s.status === statusFilter);
     }
+    // Issue #754: filter by project (workDir prefix/substring match)
+    if (projectFilter) {
+        const lower = projectFilter.toLowerCase();
+        all = all.filter(s => s.workDir.toLowerCase().includes(lower));
+    }
     // Sort by createdAt descending (newest first)
     all.sort((a, b) => b.createdAt - a.createdAt);
     const total = all.length;
@@ -601,6 +608,68 @@ app.get('/v1/sessions', async (req) => {
         pagination: { page, limit, total, totalPages },
     };
 });
+// Issue #754: Session statistics endpoint
+app.get('/v1/sessions/stats', async () => {
+    const all = sessions.listSessions();
+    const byStatus = {};
+    for (const s of all) {
+        byStatus[s.status] = (byStatus[s.status] ?? 0) + 1;
+    }
+    const global = metrics.getGlobalMetrics(all.length);
+    return {
+        active: all.length,
+        byStatus,
+        totalCreated: global.sessions.total_created,
+        totalCompleted: global.sessions.completed,
+        totalFailed: global.sessions.failed,
+    };
+});
+// Issue #754: Bulk-delete sessions by IDs and/or status
+const batchDeleteSchema = z.object({
+    ids: z.array(z.string().uuid()).max(100).optional(),
+    status: z.enum([
+        'idle', 'working', 'compacting', 'context_warning', 'waiting_for_input',
+        'permission_prompt', 'plan_mode', 'ask_question', 'bash_approval',
+        'settings', 'error', 'unknown',
+    ]).optional(),
+}).refine(d => d.ids !== undefined || d.status !== undefined, {
+    message: 'At least one of "ids" or "status" is required',
+});
+app.delete('/v1/sessions/batch', async (req, reply) => {
+    const parsed = batchDeleteSchema.safeParse(req.body);
+    if (!parsed.success) {
+        return reply.status(400).send({ error: 'Invalid request body', details: parsed.error.issues });
+    }
+    const { ids, status } = parsed.data;
+    // Collect target session IDs
+    const targets = new Set(ids ?? []);
+    if (status) {
+        for (const s of sessions.listSessions()) {
+            if (s.status === status)
+                targets.add(s.id);
+        }
+    }
+    let deleted = 0;
+    const notFound = [];
+    const errors = [];
+    for (const id of targets) {
+        if (!sessions.getSession(id)) {
+            notFound.push(id);
+            continue;
+        }
+        try {
+            await sessions.killSession(id);
+            eventBus.emitEnded(id, 'killed');
+            void channels.sessionEnded(makePayload('session.ended', id, 'killed'));
+            cleanupTerminatedSessionState(id, { monitor, metrics, toolRegistry });
+            deleted++;
+        }
+        catch (e) {
+            errors.push(`${id}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return reply.status(200).send({ deleted, notFound, errors });
+});
 // Backwards compat: /sessions (no prefix) returns raw array
 app.get('/sessions', async () => sessions.listSessions());
 /** Validate workDir — delegates to validation.ts (Issue #435). */
@@ -1606,6 +1675,8 @@ async function main() {
     }
     // Register HTTP hook receiver (Issue #169, Issue #87: pass metrics for latency tracking)
     registerHookRoutes(app, { sessions, eventBus, metrics });
+    // Issue #743: Register model-routing endpoints
+    registerModelRouterRoutes(app);
     // Initialize pipeline manager (Issue #36)
     pipelines = new PipelineManager(sessions, eventBus);
     // Initialize batch rate limiter (Issue #583)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aegis-bridge",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "type": "module",
   "description": "Orchestrate Claude Code sessions via API. Create, brief, monitor, refine, ship.",
   "main": "dist/server.js",