@pickle-pee/runtime 0.0.0

package/dist/test/session-facade.test.js

@@ -0,0 +1,1011 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const create_app_runtime_js_1 = require("../create-app-runtime.js");
+const event_bus_js_1 = require("../events/event-bus.js");
+const tool_governor_js_1 = require("../governance/tool-governor.js");
+const plan_engine_js_1 = require("../planning/plan-engine.js");
+const runtime_context_js_1 = require("../runtime-context.js");
+const session_facade_js_1 = require("../session/session-facade.js");
+const session_state_js_1 = require("../session/session-state.js");
+const stub_kernel_session_adapter_js_1 = require("./stubs/stub-kernel-session-adapter.js");
+const stubId = { value: "facade-test" };
+const stubModel = { id: "test-model", provider: "test" };
+(0, vitest_1.describe)("SessionFacade", () => {
+    function createFacade() {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus);
+        return { facade, adapter, globalBus };
+    }
+    (0, vitest_1.it)("transitions to active on construction", () => {
+        const { facade } = createFacade();
+        (0, vitest_1.expect)(facade.state.status).toBe("active");
+    });
+    (0, vitest_1.it)("exposes session id", () => {
+        const { facade } = createFacade();
+        (0, vitest_1.expect)(facade.id).toEqual(stubId);
+    });
+    (0, vitest_1.it)("exposes runtime context", () => {
+        const { facade } = createFacade();
+        (0, vitest_1.expect)(facade.context.mode).toBe("print");
+        (0, vitest_1.expect)(facade.context.workingDirectory).toBe("/tmp");
+    });
+    (0, vitest_1.it)("processes prompt and emits normalized events", async () => {
+        const { facade, adapter, globalBus } = createFacade();
+        const globalEvents = [];
+        globalBus.onCategory("tool", (event) => globalEvents.push(event));
+        adapter.enqueueDefaultEvents([
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: { toolName: "read", toolCallId: "c1", parameters: {} },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "read", toolCallId: "c1", status: "success", durationMs: 100 },
+            },
+        ]);
+        await facade.prompt("Read the file");
+        (0, vitest_1.expect)(globalEvents).toHaveLength(2);
+        (0, vitest_1.expect)(globalEvents[0].type).toBe("tool_started");
+        (0, vitest_1.expect)(globalEvents[1].type).toBe("tool_completed");
+    });
+    (0, vitest_1.it)("updates task state during prompt", async () => {
+        const { facade, adapter } = createFacade();
+        adapter.enqueueDefaultEvents([{ type: "message_update", timestamp: 1000, payload: { content: "hi" } }]);
+        const stateHistory = [];
+        facade.onStateChange((s) => stateHistory.push(s.taskState.status));
+        await facade.prompt("test");
+        // Should have transitioned: idle → running → idle
+        (0, vitest_1.expect)(stateHistory).toContain("running");
+        (0, vitest_1.expect)(stateHistory.at(-1)).toBe("idle");
+    });
+    (0, vitest_1.it)("session events bus receives events", async () => {
+        const { facade, adapter } = createFacade();
+        const sessionEvents = [];
+        facade.events.on("text_delta", (e) => sessionEvents.push(e));
+        adapter.enqueueDefaultEvents([{ type: "message_update", timestamp: 1000, payload: { content: "Hello" } }]);
+        await facade.prompt("test");
+        (0, vitest_1.expect)(sessionEvents).toHaveLength(1);
+        if (sessionEvents[0].type === "text_delta") {
+            (0, vitest_1.expect)(sessionEvents[0].content).toBe("Hello");
+        }
+    });
+    (0, vitest_1.it)("emits compaction events when compact() is invoked", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const runtime = (0, create_app_runtime_js_1.createAppRuntime)({
+            workingDirectory: "/tmp",
+            mode: "interactive",
+            model: { id: "stub-model", provider: "stub" },
+            toolSet: ["read", "edit"],
+            adapter,
+        });
+        const session = runtime.createSession();
+        const seen = [];
+        session.events.onAny((event) => {
+            seen.push(event.type);
+        });
+        await session.compact();
+        (0, vitest_1.expect)(seen).toContain("compaction_started");
+        (0, vitest_1.expect)(seen).toContain("compaction_completed");
+        await session.close();
+        await runtime.shutdown();
+    });
+    (0, vitest_1.it)("close emits session_closed event", async () => {
+        const { facade, globalBus } = createFacade();
+        let closed = false;
+        globalBus.on("session_closed", () => {
+            closed = true;
+        });
+        await facade.close();
+        (0, vitest_1.expect)(closed).toBe(true);
+        (0, vitest_1.expect)(facade.state.status).toBe("closed");
+    });
+    (0, vitest_1.it)("close calls adapter close", async () => {
+        const { facade, adapter } = createFacade();
+        await facade.close();
+        (0, vitest_1.expect)(adapter.closed).toBe(true);
+    });
+    (0, vitest_1.it)("prompt throws after close", async () => {
+        const { facade } = createFacade();
+        await facade.close();
+        await (0, vitest_1.expect)(facade.prompt("test")).rejects.toThrow("Session is closed");
+    });
+    (0, vitest_1.it)("abort calls adapter abort for an active stream", async () => {
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        let releaseStream;
+        const streamBlocked = new Promise((r) => {
+            releaseStream = r;
+        });
+        let abortCalled = false;
+        const slowAdapter = {
+            async *sendPrompt(_input) {
+                await streamBlocked;
+                if (!abortCalled) {
+                    yield {
+                        type: "message_update",
+                        timestamp: 1000,
+                        payload: { content: "after abort" },
+                    };
+                }
+            },
+            async *sendContinue(_input) {
+                await streamBlocked;
+                if (!abortCalled) {
+                    yield {
+                        type: "message_update",
+                        timestamp: 1000,
+                        payload: { content: "" },
+                    };
+                }
+            },
+            abort() {
+                abortCalled = true;
+            },
+            async close() { },
+            getRecoveryData() {
+                return {
+                    sessionId: stubId,
+                    model: stubModel,
+                    toolSet: ["read"],
+                    planSummary: null,
+                    compactionSummary: null,
+                    taskState: { status: "idle", currentTaskId: null, startedAt: null },
+                };
+            },
+            resume() { },
+        };
+        const facade = new session_facade_js_1.SessionFacadeImpl(slowAdapter, state, context, globalBus);
+        const prompt = facade.prompt("test");
+        await new Promise((r) => setTimeout(r, 0));
+        facade.abort();
+        (0, vitest_1.expect)(abortCalled).toBe(true);
+        releaseStream();
+        await prompt;
+    });
+    (0, vitest_1.it)("onStateChange notifies listeners", async () => {
+        const { facade, adapter } = createFacade();
+        adapter.enqueueDefaultEvents([]);
+        const states = [];
+        facade.onStateChange((s) => states.push(s.taskState.status));
+        await facade.prompt("test");
+        (0, vitest_1.expect)(states.length).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(states).toContain("running");
+    });
+    // --- Fix 3: RuntimeContext.taskState sync ---
+    (0, vitest_1.it)("updates context.taskState during prompt", async () => {
+        const { facade, adapter } = createFacade();
+        adapter.enqueueDefaultEvents([{ type: "message_update", timestamp: 1000, payload: { content: "hi" } }]);
+        const contextStates = [];
+        facade.onStateChange(() => contextStates.push(facade.context.taskState.status));
+        await facade.prompt("test");
+        (0, vitest_1.expect)(contextStates).toContain("running");
+        (0, vitest_1.expect)(contextStates.at(-1)).toBe("idle");
+    });
+    // --- Fix 2: Concurrency guard ---
+    (0, vitest_1.it)("rejects concurrent prompt calls", async () => {
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        let releaseStream;
+        const streamBlocked = new Promise((r) => {
+            releaseStream = r;
+        });
+        const slowAdapter = {
+            async *sendPrompt(_input) {
+                await streamBlocked;
+                yield { type: "message_update", timestamp: 1000, payload: { content: "hi" } };
+            },
+            async *sendContinue(_input) {
+                await streamBlocked;
+                yield { type: "message_update", timestamp: 1000, payload: { content: "" } };
+            },
+            abort() { },
+            async close() { },
+            getRecoveryData() {
+                return {
+                    sessionId: stubId,
+                    model: stubModel,
+                    toolSet: ["read"],
+                    planSummary: null,
+                    compactionSummary: null,
+                    taskState: { status: "idle", currentTaskId: null, startedAt: null },
+                };
+            },
+            resume() { },
+        };
+        const facade = new session_facade_js_1.SessionFacadeImpl(slowAdapter, state, context, globalBus);
+        const first = facade.prompt("first");
+        // Give the event loop a tick so the first prompt enters the for-await
+        await new Promise((r) => setTimeout(r, 0));
+        await (0, vitest_1.expect)(facade.prompt("second")).rejects.toThrow("already running");
+        releaseStream();
+        await first;
+    });
+    (0, vitest_1.it)("keeps the running lock until an aborted stream settles", async () => {
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        let releaseStream;
+        const streamBlocked = new Promise((r) => {
+            releaseStream = r;
+        });
+        let aborted = false;
+        const slowAdapter = {
+            async *sendPrompt(_input) {
+                await streamBlocked;
+                if (!aborted) {
+                    yield { type: "message_update", timestamp: 1000, payload: { content: "hi" } };
+                }
+            },
+            async *sendContinue(_input) {
+                await streamBlocked;
+                if (!aborted) {
+                    yield { type: "message_update", timestamp: 1000, payload: { content: "" } };
+                }
+            },
+            abort() {
+                aborted = true;
+            },
+            async close() { },
+            getRecoveryData() {
+                return {
+                    sessionId: stubId,
+                    model: stubModel,
+                    toolSet: ["read"],
+                    planSummary: null,
+                    compactionSummary: null,
+                    taskState: { status: "idle", currentTaskId: null, startedAt: null },
+                };
+            },
+            resume() { },
+        };
+        const facade = new session_facade_js_1.SessionFacadeImpl(slowAdapter, state, context, globalBus);
+        const first = facade.prompt("first");
+        await new Promise((r) => setTimeout(r, 0));
+        facade.abort();
+        await (0, vitest_1.expect)(facade.prompt("second")).rejects.toThrow("already running");
+        releaseStream();
+        await first;
+    });
+    (0, vitest_1.it)("allows sequential prompt calls", async () => {
+        const { facade, adapter } = createFacade();
+        adapter.enqueueDefaultEvents([]);
+        await facade.prompt("first");
+        await facade.prompt("second");
+        // No error thrown
+    });
+    (0, vitest_1.it)("gates tool execution before emitting tool_started when adapter supports governance hooks", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["bash"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["bash"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "bash", category: "command-execution" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "unlimited",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "bash",
+        });
+        adapter.enqueueDefaultEvents([
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "bash",
+                    toolCallId: "bash_1",
+                    parameters: { command: "echo hello" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "bash", toolCallId: "bash_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const prompt = facade.prompt("run bash");
+        await new Promise((r) => setTimeout(r, 0));
+        (0, vitest_1.expect)(received).toHaveLength(1);
+        (0, vitest_1.expect)(received[0].type).toBe("permission_requested");
+        (0, vitest_1.expect)(governor.audit.size).toBe(0);
+        await facade.resolvePermission("bash_1", "deny");
+        await prompt;
+    });
+    (0, vitest_1.it)("resumes a gated tool after permission approval", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["bash"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["bash"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "bash", category: "command-execution" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "unlimited",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "bash",
+        });
+        adapter.enqueueDefaultEvents([
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "bash",
+                    toolCallId: "bash_1",
+                    parameters: { command: "echo hello" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "bash", toolCallId: "bash_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const prompt = facade.prompt("run bash");
+        await new Promise((r) => setTimeout(r, 0));
+        (0, vitest_1.expect)(received.map((event) => event.type)).toEqual(["permission_requested"]);
+        await facade.resolvePermission("bash_1", "allow_once");
+        await prompt;
+        (0, vitest_1.expect)(received.map((event) => event.type)).toEqual([
+            "permission_requested",
+            "permission_resolved",
+            "tool_started",
+            "tool_completed",
+        ]);
+        (0, vitest_1.expect)(governor.audit.size).toBe(1);
+    });
+    (0, vitest_1.it)("emits tool_denied when a gated tool is rejected by the user", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["bash"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["bash"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "bash", category: "command-execution" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "unlimited",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "bash",
+        });
+        adapter.enqueueDefaultEvents([
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "bash",
+                    toolCallId: "bash_2",
+                    parameters: { command: "echo hello" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "bash", toolCallId: "bash_2", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const prompt = facade.prompt("run bash");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("bash_2", "deny");
+        await prompt;
+        (0, vitest_1.expect)(received.map((event) => event.type)).toEqual([
+            "permission_requested",
+            "permission_resolved",
+            "tool_denied",
+        ]);
+    });
+    (0, vitest_1.it)("reuses allow_for_session approval for the same bash command within the session", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["bash"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["bash"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "bash", category: "command-execution" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "unlimited",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "bash",
+        });
+        adapter.enqueueEventsForPrompt("run bash once", [
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "bash",
+                    toolCallId: "bash_pwd_1",
+                    parameters: { command: "pwd" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "bash", toolCallId: "bash_pwd_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        adapter.enqueueEventsForPrompt("run bash twice", [
+            {
+                type: "tool_execution_start",
+                timestamp: 3000,
+                payload: {
+                    toolName: "bash",
+                    toolCallId: "bash_pwd_2",
+                    parameters: { command: "pwd" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 4000,
+                payload: { toolName: "bash", toolCallId: "bash_pwd_2", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const firstPrompt = facade.prompt("run bash once");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("bash_pwd_1", "allow_for_session");
+        await firstPrompt;
+        const eventsAfterFirstPrompt = received.length;
+        await facade.prompt("run bash twice");
+        (0, vitest_1.expect)(received.slice(eventsAfterFirstPrompt).map((event) => event.type)).toEqual([
+            "tool_started",
+            "tool_completed",
+        ]);
+    });
+    (0, vitest_1.it)("reuses allow_for_session approval for write on the same file within the session", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["write"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["write"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        const recordedApprovals = [];
+        const originalRecordSessionApproval = governor.recordSessionApproval.bind(governor);
+        governor.recordSessionApproval = (entry) => {
+            recordedApprovals.push(entry);
+            originalRecordSessionApproval(entry);
+        };
+        governor.catalog.register({
+            identity: { name: "write", category: "file-mutation" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "per_target",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "write",
+        });
+        adapter.enqueueEventsForPrompt("write once", [
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "write",
+                    toolCallId: "write_1",
+                    parameters: { file_path: "/tmp/.tmp-tests/one.txt", content: "hello" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "write", toolCallId: "write_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        adapter.enqueueEventsForPrompt("write twice", [
+            {
+                type: "tool_execution_start",
+                timestamp: 3000,
+                payload: {
+                    toolName: "write",
+                    toolCallId: "write_2",
+                    parameters: { file_path: "/tmp/.tmp-tests/one.txt", content: "world" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 4000,
+                payload: { toolName: "write", toolCallId: "write_2", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const firstPrompt = facade.prompt("write once");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("write_1", "allow_for_session");
+        await firstPrompt;
+        (0, vitest_1.expect)(recordedApprovals[0]).toMatchObject({
+            toolName: "write",
+            riskLevel: "L3",
+            targetPattern: "/tmp/**",
+        });
+        const writeDecision = governor.beforeExecution({
+            sessionId: stubId.value,
+            toolName: "write",
+            toolCallId: "write_probe",
+            workingDirectory: "/tmp",
+            sessionMode: "print",
+            isSubAgent: false,
+            targetPath: "/tmp/.tmp-tests/one.txt",
+            parameters: { file_path: "/tmp/.tmp-tests/one.txt", content: "world" },
+        });
+        (0, vitest_1.expect)(writeDecision).toMatchObject({ type: "allow" });
+        const eventsAfterFirstPrompt = received.length;
+        await facade.prompt("write twice");
+        (0, vitest_1.expect)(received.slice(eventsAfterFirstPrompt).map((event) => event.type)).toEqual([
+            "tool_started",
+            "tool_completed",
+        ]);
+    });
+    (0, vitest_1.it)("reuses allow_for_session approval for edit on the same file within the session", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["edit"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["edit"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "edit", category: "file-mutation" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "per_target",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "edit",
+        });
+        adapter.enqueueEventsForPrompt("edit once", [
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "edit",
+                    toolCallId: "edit_1",
+                    parameters: {
+                        file_path: "/tmp/.tmp-tests/two.txt",
+                        old_string: "before",
+                        new_string: "after",
+                    },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "edit", toolCallId: "edit_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        adapter.enqueueEventsForPrompt("edit twice", [
+            {
+                type: "tool_execution_start",
+                timestamp: 3000,
+                payload: {
+                    toolName: "edit",
+                    toolCallId: "edit_2",
+                    parameters: {
+                        file_path: "/tmp/.tmp-tests/two.txt",
+                        old_string: "after",
+                        new_string: "final",
+                    },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 4000,
+                payload: { toolName: "edit", toolCallId: "edit_2", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const firstPrompt = facade.prompt("edit once");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("edit_1", "allow_for_session");
+        await firstPrompt;
+        (0, vitest_1.expect)(governor.beforeExecution({
+            sessionId: stubId.value,
+            toolName: "edit",
+            toolCallId: "edit_probe",
+            workingDirectory: "/tmp",
+            sessionMode: "print",
+            isSubAgent: false,
+            targetPath: "/tmp/.tmp-tests/two.txt",
+            parameters: {
+                file_path: "/tmp/.tmp-tests/two.txt",
+                old_string: "after",
+                new_string: "final",
+            },
+        }).type).toBe("allow");
+        const eventsAfterFirstPrompt = received.length;
+        await facade.prompt("edit twice");
+        (0, vitest_1.expect)(received.slice(eventsAfterFirstPrompt).map((event) => event.type)).toEqual([
+            "tool_started",
+            "tool_completed",
+        ]);
+    });
+    (0, vitest_1.it)("reuses allow_for_session approval for another file under the same working directory", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["write"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["write"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "write", category: "file-mutation" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "per_target",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "write",
+        });
+        adapter.enqueueEventsForPrompt("write first file", [
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "write",
+                    toolCallId: "write_a",
+                    parameters: { file_path: "/tmp/.tmp-tests/a.txt", content: "hello" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "write", toolCallId: "write_a", status: "success", durationMs: 20 },
+            },
+        ]);
+        adapter.enqueueEventsForPrompt("write second file", [
+            {
+                type: "tool_execution_start",
+                timestamp: 3000,
+                payload: {
+                    toolName: "write",
+                    toolCallId: "write_b",
+                    parameters: { file_path: "/tmp/.tmp-tests/b.txt", content: "world" },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 4000,
+                payload: { toolName: "write", toolCallId: "write_b", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const firstPrompt = facade.prompt("write first file");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("write_a", "allow_for_session");
+        await firstPrompt;
+        (0, vitest_1.expect)(governor.beforeExecution({
+            sessionId: stubId.value,
+            toolName: "write",
+            toolCallId: "write_probe_b",
+            workingDirectory: "/tmp",
+            sessionMode: "print",
+            isSubAgent: false,
+            targetPath: "/tmp/.tmp-tests/b.txt",
+            parameters: { file_path: "/tmp/.tmp-tests/b.txt", content: "world" },
+        }).type).toBe("allow");
+        const eventsAfterFirstPrompt = received.length;
+        await facade.prompt("write second file");
+        (0, vitest_1.expect)(received.slice(eventsAfterFirstPrompt).map((event) => event.type)).toEqual([
+            "tool_started",
+            "tool_completed",
+        ]);
+    });
+    (0, vitest_1.it)("asks again when the same tool targets a different directory outside the session scope", async () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["edit"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp/project",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["edit"]),
+        });
+        const governor = (0, tool_governor_js_1.createToolGovernor)();
+        governor.catalog.register({
+            identity: { name: "edit", category: "file-mutation" },
+            contract: {
+                parameterSchema: { type: "object", properties: {} },
+                output: { type: "text" },
+                errorTypes: [],
+            },
+            policy: {
+                riskLevel: "L3",
+                readOnly: false,
+                concurrency: "per_target",
+                confirmation: "always",
+                subAgentAllowed: true,
+                timeoutMs: 60_000,
+            },
+            executorTag: "edit",
+        });
+        adapter.enqueueEventsForPrompt("edit external one", [
+            {
+                type: "tool_execution_start",
+                timestamp: 1000,
+                payload: {
+                    toolName: "edit",
+                    toolCallId: "edit_external_1",
+                    parameters: {
+                        file_path: "/opt/tmp-tests/a.txt",
+                        old_string: "before",
+                        new_string: "after",
+                    },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 2000,
+                payload: { toolName: "edit", toolCallId: "edit_external_1", status: "success", durationMs: 20 },
+            },
+        ]);
+        adapter.enqueueEventsForPrompt("edit external two", [
+            {
+                type: "tool_execution_start",
+                timestamp: 3000,
+                payload: {
+                    toolName: "edit",
+                    toolCallId: "edit_external_2",
+                    parameters: {
+                        file_path: "/var/tmp-tests/b.txt",
+                        old_string: "before",
+                        new_string: "after",
+                    },
+                },
+            },
+            {
+                type: "tool_execution_end",
+                timestamp: 4000,
+                payload: { toolName: "edit", toolCallId: "edit_external_2", status: "success", durationMs: 20 },
+            },
+        ]);
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, governor);
+        const received = [];
+        globalBus.onCategory("permission", (event) => received.push(event));
+        globalBus.onCategory("tool", (event) => received.push(event));
+        const firstPrompt = facade.prompt("edit external one");
+        await new Promise((r) => setTimeout(r, 0));
+        await facade.resolvePermission("edit_external_1", "allow_for_session");
+        await firstPrompt;
+        const eventsAfterFirstPrompt = received.length;
+        const secondPrompt = facade.prompt("edit external two");
+        await new Promise((r) => setTimeout(r, 0));
+        (0, vitest_1.expect)(received.slice(eventsAfterFirstPrompt).map((event) => event.type)).toEqual(["permission_requested"]);
+        await facade.resolvePermission("edit_external_2", "deny");
+        await secondPrompt;
+    });
+});
+// ---------------------------------------------------------------------------
+// Plan integration tests
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("SessionFacade — plan integration", () => {
+    function createFacadeWithPlan() {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        const planEngine = (0, plan_engine_js_1.createPlanEngine)();
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus, undefined, planEngine);
+        return { facade, adapter, globalBus, planEngine };
+    }
+    (0, vitest_1.it)("exposes plan orchestrator when planEngine is provided", () => {
+        const { facade } = createFacadeWithPlan();
+        (0, vitest_1.expect)(facade.plan).not.toBeNull();
+        (0, vitest_1.expect)(facade.plan.engine).toBeDefined();
+    });
+    (0, vitest_1.it)("plan is null when no planEngine is provided", () => {
+        const adapter = new stub_kernel_session_adapter_js_1.StubKernelSessionAdapter();
+        const globalBus = (0, event_bus_js_1.createEventBus)();
+        const state = (0, session_state_js_1.createInitialSessionState)(stubId, stubModel, new Set(["read"]));
+        const context = (0, runtime_context_js_1.createRuntimeContext)({
+            sessionId: stubId,
+            workingDirectory: "/tmp",
+            mode: "print",
+            model: stubModel,
+            toolSet: new Set(["read"]),
+        });
+        const facade = new session_facade_js_1.SessionFacadeImpl(adapter, state, context, globalBus);
+        (0, vitest_1.expect)(facade.plan).toBeNull();
+    });
+    (0, vitest_1.it)("plan events update sessionState.planSummary", () => {
+        const { facade } = createFacadeWithPlan();
+        (0, vitest_1.expect)(facade.state.planSummary).toBeNull();
+        facade.plan.createAndActivate("p1", "Test goal", ["Step A"]);
+        // After plan creation, planSummary should be updated via event listener
+        (0, vitest_1.expect)(facade.state.planSummary).not.toBeNull();
+        (0, vitest_1.expect)(facade.state.planSummary.planId).toBe("p1");
+        (0, vitest_1.expect)(facade.state.planSummary.stepCount).toBe(1);
+    });
+    (0, vitest_1.it)("plan state changes trigger onStateChange", () => {
+        const { facade } = createFacadeWithPlan();
+        const states = [];
+        facade.onStateChange((s) => states.push(s));
+        facade.plan.createAndActivate("p1", "Goal", ["Step A"]);
+        (0, vitest_1.expect)(states.length).toBeGreaterThan(0);
+        const last = states[states.length - 1];
+        (0, vitest_1.expect)(last.planSummary).not.toBeNull();
+    });
+    (0, vitest_1.it)("plan boundary violation prevents step completion", () => {
+        const { facade } = createFacadeWithPlan();
+        facade.plan.createAndActivate("p1", "Goal", ["Step A"]);
+        facade.plan.assignTask(0, {
+            taskId: "task-1",
+            goal: "Do something",
+            scope: { allowedPaths: ["packages/app-runtime/**"], forbiddenPaths: [] },
+            inputs: { docs: [], files: [], assumptions: [] },
+            deliverables: ["code"],
+            verification: [{ name: "build", type: "command", command: "npm run build", description: "Build" }],
+            stopConditions: [{ type: "max_file_count", value: 100, description: "Safety limit" }],
+        });
+        const result = {
+            taskId: "task-1",
+            status: "completed",
+            modifiedPaths: ["packages/OUTSIDE/src/hack.ts"],
+            verifications: [],
+            risks: [],
+            handoffNotes: [],
+            completedAt: Date.now(),
+        };
+        const plan = facade.plan.submitResult(0, result);
+        // Step should be failed, not completed
+        (0, vitest_1.expect)(plan.steps[0].status).toBe("failed");
+    });
+});
+//# sourceMappingURL=session-facade.test.js.map