aegis-bridge 2.15.0 → 2.15.2

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;
@@ -157,6 +157,7 @@ export interface CreateSessionRequest {
     workDir: string;
     name?: string;
     prompt?: string;
+    prd?: string;
     resumeSessionId?: string;
     claudeCommand?: string;
     env?: Record<string, string>;
@@ -182,6 +183,7 @@ export interface SessionSummary {
     createdAt: number;
     lastActivity: number;
     permissionMode: string;
+    prd?: string;
 }
 export interface OkResponse {
     ok: boolean;
@@ -203,3 +205,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/mcp-server.d.ts

@@ -57,6 +57,16 @@ interface SessionLatencyResponse {
     realtime: SessionLatency | null;
     aggregated: SessionLatencySummary | null;
 }
+interface MemoryEntryResponse {
+    entry: {
+        key: string;
+        value: string;
+        namespace: string;
+        created_at: number;
+        updated_at: number;
+        expires_at?: number;
+    };
+}
 export declare class AegisClient {
     private baseUrl;
     private authToken?;
@@ -103,6 +113,9 @@ export declare class AegisClient {
         }>;
     }): Promise<PipelineState>;
     getSwarm(): Promise<Record<string, unknown>>;
+    setMemory(key: string, value: string, ttlSeconds?: number): Promise<MemoryEntryResponse>;
+    getMemory(key: string): Promise<MemoryEntryResponse>;
+    deleteMemory(key: string): Promise<OkResponse>;
 }
 export declare function createMcpServer(aegisPort: number, authToken?: string): McpServer;
 export declare function startMcpServer(port: number, authToken?: string): Promise<void>;

package/dist/mcp-server.js

@@ -175,6 +175,20 @@ export class AegisClient {
     async getSwarm() {
         return this.request('/v1/swarm');
     }
+    async setMemory(key, value, ttlSeconds) {
+        return this.request('/v1/memory', {
+            method: 'POST',
+            body: JSON.stringify({ key, value, ttlSeconds }),
+        });
+    }
+    async getMemory(key) {
+        return this.request(`/v1/memory/${encodeURIComponent(key)}`);
+    }
+    async deleteMemory(key) {
+        return this.request(`/v1/memory/${encodeURIComponent(key)}`, {
+            method: 'DELETE',
+        });
+    }
 }
 function formatToolError(e) {
     if (e instanceof Error) {
@@ -665,6 +679,59 @@ export function createMcpServer(aegisPort, authToken) {
             return formatToolError(e);
         }
     });
+    // ── state_set ──
+    server.tool('state_set', 'Set a shared state key/value entry via Aegis memory bridge.', {
+        key: z.string().describe('State key in namespace/key format (e.g., pipeline/run-123)'),
+        value: z.string().describe('State payload as string'),
+        ttlSeconds: z.number().int().positive().max(86400 * 30).optional().describe('Optional TTL in seconds (max 30 days)'),
+    }, async ({ key, value, ttlSeconds }) => {
+        try {
+            const result = await client.setMemory(key, value, ttlSeconds);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (e) {
+            return formatToolError(e);
+        }
+    });
+    // ── state_get ──
+    server.tool('state_get', 'Get a shared state key/value entry via Aegis memory bridge.', {
+        key: z.string().describe('State key in namespace/key format (e.g., pipeline/run-123)'),
+    }, async ({ key }) => {
+        try {
+            const result = await client.getMemory(key);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (e) {
+            return formatToolError(e);
+        }
+    });
+    // ── state_delete ──
+    server.tool('state_delete', 'Delete a shared state key/value entry via Aegis memory bridge.', {
+        key: z.string().describe('State key in namespace/key format (e.g., pipeline/run-123)'),
+    }, async ({ key }) => {
+        try {
+            const result = await client.deleteMemory(key);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (e) {
+            return formatToolError(e);
+        }
+    });
     // ── MCP Prompts (Issue #443) ────────────────────────────────────────
     server.prompt('implement_issue', 'Create a session and generate a structured implementation prompt for a GitHub issue.', {
         issueNumber: z.string().describe('GitHub issue number'),

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/path-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * path-utils.ts — path helpers shared across session/tmux logic.
+ */
+/**
+ * Compute the Claude project hash folder from a workDir path.
+ *
+ * Examples:
+ * - /home/user/project -> -home-user-project
+ * - D:\\Users\\me\\project -> -d-Users-me-project
+ */
+export declare function computeProjectHash(workDir: string): string;

package/dist/path-utils.js

@@ -0,0 +1,21 @@
+/**
+ * path-utils.ts — path helpers shared across session/tmux logic.
+ */
+/**
+ * Compute the Claude project hash folder from a workDir path.
+ *
+ * Examples:
+ * - /home/user/project -> -home-user-project
+ * - D:\\Users\\me\\project -> -d-Users-me-project
+ */
+export function computeProjectHash(workDir) {
+    const normalized = workDir.replace(/\\/g, '/').trim();
+    const withLowerDrive = normalized.replace(/^[A-Za-z]:/, (m) => `${m[0].toLowerCase()}`);
+    const segments = withLowerDrive
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => segment.replace(/:/g, '').replace(/\s+/g, '-'));
+    if (segments.length === 0)
+        return '-';
+    return `-${segments.join('-')}`;
+}

package/dist/pipeline.d.ts

@@ -46,7 +46,16 @@ export type PipelineStageStatus = 'pending' | 'running' | 'completed' | 'failed'
 export interface PipelineState {
     id: string;
     name: string;
+    currentStage: 'plan' | 'execute' | 'verify' | 'fix' | 'submit' | 'done';
     status: 'running' | 'completed' | 'failed';
+    retryCount: number;
+    maxRetries: number;
+    stageHistory: Array<{
+        stage: string;
+        enteredAt: number;
+        exitedAt?: number;
+        output?: unknown;
+    }>;
     stages: Array<{
         name: string;
         status: PipelineStageStatus;
@@ -62,6 +71,7 @@ export declare class PipelineManager {
     private sessions;
     private eventBus?;
     private static readonly PIPELINE_RETRY_MAX_ATTEMPTS;
+    private static readonly PIPELINE_FIX_MAX_RETRIES;
     private pipelines;
     private pipelineConfigs;
     private pollInterval;
@@ -78,6 +88,7 @@ export declare class PipelineManager {
     private advancePipeline;
     /** Poll running pipelines and advance stages. */
     private pollPipelines;
+    private transitionPipelineStage;
     /** Detect circular dependencies. Throws if found. */
     private detectCycles;
     /** Clean up. */

package/dist/pipeline.js

@@ -11,6 +11,7 @@ export class PipelineManager {
     sessions;
     eventBus;
     static PIPELINE_RETRY_MAX_ATTEMPTS = 3;
+    static PIPELINE_FIX_MAX_RETRIES = 3;
     pipelines = new Map();
     pipelineConfigs = new Map(); // #219: preserve original stage config
     pollInterval = null;
@@ -72,7 +73,11 @@ export class PipelineManager {
         const pipeline = {
             id,
             name: config.name,
+            currentStage: 'plan',
             status: 'running',
+            retryCount: 0,
+            maxRetries: PipelineManager.PIPELINE_FIX_MAX_RETRIES,
+            stageHistory: [{ stage: 'plan', enteredAt: Date.now() }],
             stages: config.stages.map(s => ({
                 name: s.name,
                 status: 'pending',
@@ -108,11 +113,14 @@ export class PipelineManager {
         // If any stage failed, fail the pipeline
         if (failedStages.length > 0) {
             pipeline.status = 'failed';
+            this.transitionPipelineStage(pipeline, 'fix', { reason: 'stage_failed', failedStages: failedStages.map(s => s.name) });
             return;
         }
         // Check if all stages are completed
         if (pipeline.stages.every(s => s.status === 'completed')) {
             pipeline.status = 'completed';
+            this.transitionPipelineStage(pipeline, 'submit', { reason: 'all_stages_completed' });
+            this.transitionPipelineStage(pipeline, 'done', { status: 'completed' });
             if (this.eventBus) {
                 this.eventBus.emitEnded(id, 'pipeline_completed');
             }
@@ -148,13 +156,23 @@ export class PipelineManager {
                 stage.sessionId = session.id;
                 stage.status = 'running';
                 stage.startedAt = Date.now();
+                this.transitionPipelineStage(pipeline, 'execute', { stage: stage.name, sessionId: session.id });
             }
             catch (e) {
                 stage.status = 'failed';
                 stage.error = getErrorMessage(e);
                 pipeline.status = 'failed';
+                this.transitionPipelineStage(pipeline, 'fix', { stage: stage.name, error: stage.error });
             }
         }
+        const hasRunning = pipeline.stages.some(s => s.status === 'running');
+        const hasPending = pipeline.stages.some(s => s.status === 'pending');
+        if (hasRunning) {
+            this.transitionPipelineStage(pipeline, 'verify', { runningStages: pipeline.stages.filter(s => s.status === 'running').map(s => s.name) });
+        }
+        else if (hasPending) {
+            this.transitionPipelineStage(pipeline, 'plan', { pendingStages: pipeline.stages.filter(s => s.status === 'pending').map(s => s.name) });
+        }
     }
     /** Poll running pipelines and advance stages. */
     async pollPipelines() {
@@ -184,6 +202,7 @@ export class PipelineManager {
                 if (session.status === 'idle') {
                     stage.status = 'completed';
                     stage.completedAt = Date.now();
+                    this.transitionPipelineStage(pipeline, 'verify', { stageCompleted: stage.name });
                 }
             }
             // #219: Use stored original config so stage prompt/permissionMode/autoApprove/workDir are preserved
@@ -207,6 +226,25 @@ export class PipelineManager {
             }
         }
     }
+    transitionPipelineStage(pipeline, stage, output) {
+        if (pipeline.currentStage === stage)
+            return;
+        const now = Date.now();
+        const previous = pipeline.stageHistory[pipeline.stageHistory.length - 1];
+        if (previous && previous.exitedAt === undefined) {
+            previous.exitedAt = now;
+            if (output !== undefined)
+                previous.output = output;
+        }
+        pipeline.currentStage = stage;
+        pipeline.stageHistory.push({ stage, enteredAt: now });
+        if (stage === 'fix') {
+            pipeline.retryCount += 1;
+            if (pipeline.retryCount > pipeline.maxRetries) {
+                pipeline.status = 'failed';
+            }
+        }
+    }
     /** Detect circular dependencies. Throws if found. */
     detectCycles(stages) {
         const graph = new Map();

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';
@@ -348,6 +349,7 @@ const createSessionSchema = z.object({
     workDir: z.string().min(1),
     name: z.string().max(200).optional(),
     prompt: z.string().max(100_000).optional(),
+    prd: z.string().max(100_000).optional(),
     resumeSessionId: z.string().uuid().optional(),
     claudeCommand: z.string().max(10_000).optional(),
     env: z.record(z.string(), z.string()).optional(),
@@ -581,15 +583,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 +609,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). */
@@ -611,7 +681,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, parentId, memoryKeys } = parsed.data;
+    const { workDir, name, prompt, prd, resumeSessionId, claudeCommand, env, stallThresholdMs, permissionMode, autoApprove, parentId, memoryKeys } = parsed.data;
     if (!workDir)
         return reply.status(400).send({ error: 'workDir is required' });
     // Issue #564: Validate installed Claude Code version
@@ -660,7 +730,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, parentId });
+    const session = await sessions.createSession({ workDir: safeWorkDir, name, prd, 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
@@ -1606,6 +1676,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/dist/session.d.ts

@@ -40,6 +40,7 @@ export interface SessionInfo {
     parentId?: string;
     children?: string[];
     permissionPolicy?: PermissionPolicy;
+    prd?: string;
 }
 export interface SessionState {
     sessions: Record<string, SessionInfo>;
@@ -135,6 +136,7 @@ export declare class SessionManager {
     createSession(opts: {
         workDir: string;
         name?: string;
+        prd?: string;
         resumeSessionId?: string;
         claudeCommand?: string;
         env?: Record<string, string>;
@@ -304,6 +306,7 @@ export declare class SessionManager {
         createdAt: number;
         lastActivity: number;
         permissionMode: string;
+        prd?: string;
     }>;
     /** Paginated transcript read — does NOT advance the session's byteOffset. */
     readTranscript(id: string, page?: number, limit?: number, roleFilter?: 'user' | 'assistant' | 'system'): Promise<{

package/dist/session.js

@@ -21,6 +21,7 @@ import { PermissionRequestManager } from './permission-request-manager.js';
 import { QuestionManager } from './question-manager.js';
 import { Mutex } from 'async-mutex';
 import { maybeInjectFault } from './fault-injection.js';
+import { computeProjectHash } from './path-utils.js';
 /** Convert parsed JSON arrays to Sets for activeSubagents (#668). */
 function hydrateSessions(raw) {
     const sessions = {};
@@ -562,6 +563,7 @@ export class SessionManager {
             settingsPatched,
             hookSettingsFile,
             hookSecret,
+            prd: opts.prd,
         };
         this.state.sessions[id] = session;
         this.invalidateSessionsListCache();
@@ -1207,6 +1209,7 @@ export class SessionManager {
             createdAt: session.createdAt,
             lastActivity: session.lastActivity,
             permissionMode: session.permissionMode,
+            prd: session.prd,
         };
     }
     /** Paginated transcript read — does NOT advance the session's byteOffset. */
@@ -1400,7 +1403,7 @@ export class SessionManager {
     }
     /** Attempt filesystem-based discovery for a single session poll tick. */
     async maybeDiscoverFromFilesystem(session, workDir) {
-        const projectHash = '-' + workDir.replace(/^\//, '').replace(/\//g, '-');
+        const projectHash = computeProjectHash(workDir);
         const projectDir = join(this.config.claudeProjectsDir, projectHash);
         if (!existsSync(projectDir))
             return false;

package/dist/tmux.js

@@ -11,6 +11,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { randomBytes } from 'node:crypto';
+import { computeProjectHash } from './path-utils.js';
 /** Shell-escape a string by wrapping in single quotes and escaping embedded single quotes. */
 function shellEscape(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
@@ -360,7 +361,7 @@ export class TmuxManager {
      */
     async archiveStaleSessionFiles(workDir) {
         // Compute the project hash the same way Claude CLI does
-        const projectHash = '-' + workDir.replace(/^\//, '').replace(/\//g, '-');
+        const projectHash = computeProjectHash(workDir);
         const projectDir = join(homedir(), '.claude', 'projects', projectHash);
         if (!existsSync(projectDir))
             return;

package/package.json

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