aegis-bridge 2.15.1 → 2.15.3

package/README.md

@@ -7,6 +7,7 @@
   <img src="https://img.shields.io/github/actions/workflow/status/OneStepAt4time/aegis/ci.yml?branch=main" alt="CI" />
   <img src="https://img.shields.io/npm/l/aegis-bridge.svg" alt="license" />
   <img src="https://img.shields.io/badge/node-%3E%3D20.0.0-blue.svg" alt="node" />
+  <img src="https://img.shields.io/badge/MCP-ready-green.svg" alt="MCP ready" />
 </p>
 
 <p align="center">
@@ -96,6 +97,14 @@ Or via `.mcp.json`:
 
 **3 prompts** — `implement_issue`, `review_pr`, `debug_session`
 
+## Ecosystem Integrations
+
+Aegis works beyond Claude Code anywhere an MCP host can launch a local stdio server.
+
+- [Cursor integration](docs/integrations/cursor.md)
+- [Windsurf integration](docs/integrations/windsurf.md)
+- [MCP Registry preparation](docs/integrations/mcp-registry.md)
+
 ---
 
 ## REST API

package/dist/api-contracts.d.ts

@@ -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;

package/dist/consensus.d.ts

@@ -0,0 +1,16 @@
+export type ConsensusFocusArea = 'correctness' | 'security' | 'performance';
+export interface ConsensusRequest {
+    id: string;
+    targetSessionId: string;
+    reviewerIds: string[];
+    focusAreas: ConsensusFocusArea[];
+    status: 'running' | 'completed' | 'failed';
+    createdAt: number;
+}
+export interface ConsensusReview {
+    reviewerId: string;
+    focusArea: ConsensusFocusArea;
+    findings: string[];
+}
+export declare function buildConsensusPrompt(targetSessionId: string, focusArea: ConsensusFocusArea): string;
+export declare function mergeConsensusFindings(reviews: ConsensusReview[]): string[];

package/dist/consensus.js

@@ -0,0 +1,19 @@
+export function buildConsensusPrompt(targetSessionId, focusArea) {
+    return [
+        `Review Aegis session ${targetSessionId}.`,
+        `Focus area: ${focusArea}.`,
+        'Return concise findings ordered by severity.',
+        'Prefer concrete regressions, risks, and missing verification.',
+    ].join(' ');
+}
+export function mergeConsensusFindings(reviews) {
+    const merged = new Set();
+    for (const review of reviews) {
+        for (const finding of review.findings) {
+            const normalized = finding.trim();
+            if (normalized)
+                merged.add(normalized);
+        }
+    }
+    return Array.from(merged.values());
+}

package/dist/hooks.js

@@ -15,6 +15,7 @@
  * Issue #169: Phase 3 — Hook-driven status detection.
  */
 import { isValidUUID, hookBodySchema, parseIntSafe } from './validation.js';
+import { evaluatePermissionProfile } from './permission-evaluator.js';
 /** CC hook events that require a decision response. */
 const DECISION_EVENTS = new Set(['PreToolUse', 'PermissionRequest']);
 /** Permission modes that should be auto-approved via hook response. */
@@ -289,6 +290,37 @@ export function registerHookRoutes(app, deps) {
                     // Timeout: allow without answer (CC shows question to user in terminal)
                     console.log(`Hooks: AskUserQuestion timeout for session ${sessionId} — allowing without answer`);
                 }
+                if (session.permissionProfile) {
+                    const evaluation = evaluatePermissionProfile(session.permissionProfile, {
+                        toolName,
+                        toolInput: hookBody.tool_input,
+                    });
+                    if (evaluation.behavior === 'deny') {
+                        deps.eventBus.emit(sessionId, {
+                            event: 'permission_denied',
+                            sessionId,
+                            timestamp: new Date().toISOString(),
+                            data: { toolName, reason: evaluation.reason },
+                        });
+                        return reply.status(200).send({
+                            hookSpecificOutput: {
+                                hookEventName: 'PreToolUse',
+                                permissionDecision: 'deny',
+                                reason: evaluation.reason,
+                            },
+                        });
+                    }
+                    if (evaluation.behavior === 'ask') {
+                        deps.eventBus.emitApproval(sessionId, `Permission profile requires approval for ${toolName}`);
+                        const decision = await deps.sessions.waitForPermissionDecision(sessionId, PERMISSION_TIMEOUT_MS, toolName, evaluation.reason);
+                        return reply.status(200).send({
+                            hookSpecificOutput: {
+                                hookEventName: 'PreToolUse',
+                                permissionDecision: decision,
+                            },
+                        });
+                    }
+                }
                 // Default: allow without modification
                 return reply.status(200).send({
                     hookSpecificOutput: {

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/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/permission-evaluator.d.ts

@@ -0,0 +1,10 @@
+import type { PermissionProfile } from './validation.js';
+export interface PermissionEvaluationInput {
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+}
+export interface PermissionEvaluationResult {
+    behavior: 'allow' | 'deny' | 'ask';
+    reason: string;
+}
+export declare function evaluatePermissionProfile(profile: PermissionProfile, input: PermissionEvaluationInput): PermissionEvaluationResult;

package/dist/permission-evaluator.js

@@ -0,0 +1,48 @@
+function globToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`, 'i');
+}
+function extractCandidatePaths(toolInput) {
+    if (!toolInput)
+        return [];
+    const values = [toolInput.path, toolInput.file_path, toolInput.target, ...(Array.isArray(toolInput.paths) ? toolInput.paths : [])];
+    return values.filter((v) => typeof v === 'string');
+}
+function extractContentSize(toolInput) {
+    const content = toolInput?.content;
+    return typeof content === 'string' ? content.length : null;
+}
+function isLikelyWriteTool(toolName) {
+    return /write|edit|delete|rename|move|create/i.test(toolName);
+}
+export function evaluatePermissionProfile(profile, input) {
+    for (const rule of profile.rules) {
+        if (rule.tool !== input.toolName)
+            continue;
+        if (rule.pattern) {
+            const candidate = typeof input.toolInput?.command === 'string'
+                ? input.toolInput.command
+                : JSON.stringify(input.toolInput ?? {});
+            if (!globToRegExp(rule.pattern).test(candidate))
+                continue;
+        }
+        if (rule.constraints?.readOnly && isLikelyWriteTool(input.toolName)) {
+            return { behavior: 'deny', reason: `Denied by readOnly constraint for ${input.toolName}` };
+        }
+        if (rule.constraints?.paths && rule.constraints.paths.length > 0) {
+            const paths = extractCandidatePaths(input.toolInput);
+            const allowed = paths.every((candidate) => rule.constraints.paths.some((prefix) => candidate.startsWith(prefix)));
+            if (!allowed) {
+                return { behavior: 'deny', reason: `Denied by path constraint for ${input.toolName}` };
+            }
+        }
+        if (rule.constraints?.maxFileSize) {
+            const size = extractContentSize(input.toolInput);
+            if (size !== null && size > rule.constraints.maxFileSize) {
+                return { behavior: 'deny', reason: `Denied by maxFileSize constraint for ${input.toolName}` };
+            }
+        }
+        return { behavior: rule.behavior, reason: `Matched rule for ${input.toolName}` };
+    }
+    return { behavior: profile.defaultBehavior, reason: 'No matching permission rule' };
+}

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

@@ -37,6 +37,7 @@ import { registerHookRoutes } from './hooks.js';
 import { registerWsTerminalRoute } from './ws-terminal.js';
 import { registerMemoryRoutes } from './memory-routes.js';
 import { registerModelRouterRoutes } from './model-router.js';
+import { buildConsensusPrompt } from './consensus.js';
 import * as templateStore from './template-store.js';
 import { SwarmMonitor } from './swarm-monitor.js';
 import { killAllSessions } from './signal-cleanup-helper.js';
@@ -48,9 +49,10 @@ import { MemoryBridge } from './memory-bridge.js';
 import { cleanupTerminatedSessionState } from './session-cleanup.js';
 import { normalizeApiErrorPayload } from './api-error-envelope.js';
 import { listenWithRetry, removePidFile, writePidFile } from './startup.js';
-import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, handshakeRequestSchema, parseIntSafe, isValidUUID, compareSemver, extractCCVersion, MIN_CC_VERSION, } from './validation.js';
+import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, handshakeRequestSchema, parseIntSafe, isValidUUID, compareSemver, extractCCVersion, MIN_CC_VERSION, permissionProfileSchema, } from './validation.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const consensusRequests = new Map();
 // ── Configuration ────────────────────────────────────────────────────
 // Issue #349: CSP policy for dashboard responses (shared between static and SPA fallback)
 const DASHBOARD_CSP = "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' ws: wss:";
@@ -349,6 +351,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(),
@@ -680,7 +683,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
@@ -729,7 +732,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
@@ -903,6 +906,48 @@ async function forkSessionHandler(req, reply) {
 }
 app.post('/v1/sessions/:id/fork', forkSessionHandler);
 app.post('/sessions/:id/fork', forkSessionHandler);
+async function createConsensusHandler(req, reply) {
+    const targetSessionId = req.params.id;
+    const target = sessions.getSession(targetSessionId);
+    if (!target)
+        return reply.status(404).send({ error: 'Target session not found' });
+    const focusAreas = (req.body?.focusAreas && req.body.focusAreas.length > 0)
+        ? req.body.focusAreas
+        : ['correctness', 'security', 'performance'];
+    const reviewerCount = Math.min(5, Math.max(1, req.body?.reviewerCount ?? focusAreas.length));
+    const selectedFocus = focusAreas.slice(0, reviewerCount);
+    const reviewerIds = [];
+    for (let i = 0; i < selectedFocus.length; i += 1) {
+        const focus = selectedFocus[i];
+        const child = await sessions.createSession({
+            workDir: target.workDir,
+            name: `consensus-${focus}-${targetSessionId.slice(0, 6)}`,
+            parentId: targetSessionId,
+            permissionMode: target.permissionMode,
+        });
+        reviewerIds.push(child.id);
+        await sessions.sendInitialPrompt(child.id, buildConsensusPrompt(targetSessionId, focus));
+    }
+    const consensusId = crypto.randomUUID();
+    const record = {
+        id: consensusId,
+        targetSessionId,
+        reviewerIds,
+        focusAreas: selectedFocus,
+        status: 'running',
+        createdAt: Date.now(),
+    };
+    consensusRequests.set(consensusId, record);
+    return reply.status(202).send(record);
+}
+function getConsensusHandler(req, reply) {
+    const item = consensusRequests.get(req.params.id);
+    if (!item)
+        return reply.status(404).send({ error: 'Consensus request not found' });
+    return item;
+}
+app.post('/v1/sessions/:id/consensus', createConsensusHandler);
+app.get('/v1/consensus/:id', getConsensusHandler);
 async function getPermissionPolicyHandler(req, reply) {
     const sessionId = req.params.id;
     const session = sessions.getSession(sessionId);
@@ -927,6 +972,29 @@ 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);
+async function getPermissionProfileHandler(req, reply) {
+    const sessionId = req.params.id;
+    const session = sessions.getSession(sessionId);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    return { permissionProfile: session.permissionProfile ?? null };
+}
+async function updatePermissionProfileHandler(req, reply) {
+    const sessionId = req.params.id;
+    const session = sessions.getSession(sessionId);
+    if (!session)
+        return reply.status(404).send({ error: 'Session not found' });
+    const parsed = permissionProfileSchema.safeParse(req.body ?? {});
+    if (!parsed.success)
+        return reply.status(400).send({ error: 'Invalid permission profile', details: parsed.error.issues });
+    session.permissionProfile = parsed.data;
+    await sessions.save();
+    return { permissionProfile: parsed.data };
+}
+app.get('/v1/sessions/:id/permission-profile', getPermissionProfileHandler);
+app.put('/v1/sessions/:id/permission-profile', updatePermissionProfileHandler);
+app.get('/sessions/:id/permission-profile', getPermissionProfileHandler);
+app.put('/sessions/:id/permission-profile', updatePermissionProfileHandler);
 // Read messages
 async function readMessagesHandler(req, reply) {
     try {

package/dist/session.d.ts

@@ -8,7 +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';
+import { type PermissionPolicy, type PermissionProfile } from './validation.js';
 import { type PermissionDecision } from './permission-request-manager.js';
 export interface SessionInfo {
     id: string;
@@ -40,6 +40,8 @@ export interface SessionInfo {
     parentId?: string;
     children?: string[];
     permissionPolicy?: PermissionPolicy;
+    permissionProfile?: PermissionProfile;
+    prd?: string;
 }
 export interface SessionState {
     sessions: Record<string, SessionInfo>;
@@ -135,6 +137,7 @@ export declare class SessionManager {
     createSession(opts: {
         workDir: string;
         name?: string;
+        prd?: string;
         resumeSessionId?: string;
         claudeCommand?: string;
         env?: Record<string, string>;
@@ -304,6 +307,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/dist/validation.d.ts

@@ -141,6 +141,48 @@ export declare const permissionRuleSchema: z.ZodObject<{
     commandPattern: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type PermissionPolicy = z.infer<typeof permissionRuleSchema>[];
+/** Issue #742: richer per-session permission profile. */
+export declare const permissionConstraintSchema: z.ZodObject<{
+    readOnly: z.ZodOptional<z.ZodBoolean>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxFileSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const permissionProfileRuleSchema: z.ZodObject<{
+    tool: z.ZodString;
+    behavior: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+    }>;
+    pattern: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        readOnly: z.ZodOptional<z.ZodBoolean>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxFileSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const permissionProfileSchema: z.ZodObject<{
+    defaultBehavior: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+    }>;
+    rules: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        behavior: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>;
+        pattern: z.ZodOptional<z.ZodString>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            readOnly: z.ZodOptional<z.ZodBoolean>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxFileSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PermissionProfile = z.infer<typeof permissionProfileSchema>;
 /** Schema for persisted SessionState (sessions: { [id]: SessionInfo }). */
 export declare const persistedStateSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     id: z.ZodString;
@@ -206,6 +248,27 @@ export declare const persistedStateSchema: z.ZodRecord<z.ZodString, z.ZodObject<
         toolName: z.ZodOptional<z.ZodString>;
         commandPattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    permissionProfile: z.ZodOptional<z.ZodObject<{
+        defaultBehavior: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>;
+        rules: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            behavior: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                ask: "ask";
+            }>;
+            pattern: z.ZodOptional<z.ZodString>;
+            constraints: z.ZodOptional<z.ZodObject<{
+                readOnly: z.ZodOptional<z.ZodBoolean>;
+                paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxFileSize: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>>;
 /** Schema for a single continuation pointer entry in session_map.json (Issue #900). */
 export declare const sessionMapEntrySchema: z.ZodObject<{

package/dist/validation.js

@@ -138,6 +138,22 @@ export const permissionRuleSchema = z.object({
     toolName: z.string().optional(),
     commandPattern: z.string().optional(),
 });
+/** Issue #742: richer per-session permission profile. */
+export const permissionConstraintSchema = z.object({
+    readOnly: z.boolean().optional(),
+    paths: z.array(z.string().min(1)).max(50).optional(),
+    maxFileSize: z.number().int().positive().max(10_000_000).optional(),
+}).strict();
+export const permissionProfileRuleSchema = z.object({
+    tool: z.string().min(1),
+    behavior: z.enum(['allow', 'deny', 'ask']),
+    pattern: z.string().optional(),
+    constraints: permissionConstraintSchema.optional(),
+}).strict();
+export const permissionProfileSchema = z.object({
+    defaultBehavior: z.enum(['allow', 'deny', 'ask']),
+    rules: z.array(permissionProfileRuleSchema).max(100),
+}).strict();
 /** Schema for persisted SessionState (sessions: { [id]: SessionInfo }). */
 export const persistedStateSchema = z.record(z.string(), z.object({
     id: z.string(),
@@ -173,6 +189,7 @@ export const persistedStateSchema = z.record(z.string(), z.object({
         toolName: z.string().optional(),
         commandPattern: z.string().optional(),
     })).optional(),
+    permissionProfile: permissionProfileSchema.optional(),
 }));
 /** Schema for a single continuation pointer entry in session_map.json (Issue #900). */
 export const sessionMapEntrySchema = z.object({

package/package.json

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