gestalt-mobile 0.21.0 → 0.22.0

package/dist/client/index.html

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-ufTniVfO.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D9-XA9jj.css">
+    <script type="module" crossorigin src="/assets/index-NHzJXg1w.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Db9p-xm2.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/composition.contracts.js

@@ -565,6 +565,9 @@ describe('production composition', () => {
             });
             const database = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
             const timestamp = new Date().toISOString();
+            database
+                .prepare('DELETE FROM autopilot_sessions WHERE session_id = ?')
+                .run(fixture.sessionId);
             database
                 .prepare("INSERT INTO autopilot_sessions (session_id,state,requested_enabled,plan_identity,plan_fingerprint,generation,no_progress_count,next_evaluation_at,last_control_id,stop_reason,updated_at) VALUES (?, 'backoff', 1, 'fixture', 'fixture', 1, 0, ?, 'issued-without-turn', NULL, ?)")
                 .run(fixture.sessionId, timestamp, timestamp);
@@ -595,6 +598,9 @@ describe('production composition', () => {
                 },
             });
             const acceptedDatabase = new DatabaseSync(join(accepted.dataDir, 'relay.sqlite'));
+            acceptedDatabase
+                .prepare('DELETE FROM autopilot_sessions WHERE session_id = ?')
+                .run(accepted.sessionId);
             acceptedDatabase
                 .prepare("INSERT INTO autopilot_sessions (session_id,state,requested_enabled,plan_identity,plan_fingerprint,generation,no_progress_count,next_evaluation_at,last_control_id,stop_reason,updated_at) VALUES (?, 'backoff', 1, 'fixture', 'fixture', 1, 0, ?, 'issued-with-turn', NULL, ?)")
                 .run(accepted.sessionId, timestamp, timestamp);
@@ -715,20 +721,22 @@ describe('production composition', () => {
                     // absence is the durable proof that no queued control can be reopened.
                     expect(row).toBeUndefined();
                 }
+                else if (action === 'replace') {
+                    await vi.waitFor(() => expect(staleTimer.cancelled).toBe(true));
+                    await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
+                        autopilot: { enabled: true, state: expect.stringMatching(/monitoring|backoff/) },
+                    }));
+                }
                 else {
                     await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
                         autopilot: {
                             enabled: false,
                             state: 'disabled',
-                            reason: action === 'replace'
-                                ? 'planReplaced'
-                                : action === 'close'
-                                    ? 'planRemoved'
-                                    : 'sessionEnded',
+                            reason: action === 'close' ? 'planRemoved' : 'sessionEnded',
                         },
                     }));
                 }
-                expect(staleTimer.cancelled).toBe(true);
+                expect(staleTimer.cancelled, action).toBe(true);
                 staleTimer.callback();
                 await Promise.resolve();
                 expect(fixture.handles.flatMap((candidate) => candidate.calls)).not.toContain('turn/start');
@@ -804,6 +812,12 @@ describe('production composition', () => {
                     };
                 },
             });
+            expect((await fixture.app.inject({
+                method: 'PUT',
+                url: `/api/sessions/${fixture.sessionId}/autopilot`,
+                payload: { enabled: false },
+            })).statusCode).toBe(200);
+            timers.length = 0;
             const handle = fixture.handles.find((candidate) => candidate.notify);
             handle.notify({
                 method: 'thread/started',
@@ -868,6 +882,12 @@ describe('production composition', () => {
                     };
                 },
             });
+            expect((await fixture.app.inject({
+                method: 'PUT',
+                url: `/api/sessions/${fixture.sessionId}/autopilot`,
+                payload: { enabled: false },
+            })).statusCode).toBe(200);
+            timers.length = 0;
             const handle = fixture.handles.find((candidate) => candidate.notify);
             handle.notify({
                 method: 'thread/started',
@@ -1356,6 +1376,86 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        it('forgets a session while activity reconciliation is pending without publishing late activity', async () => {
+            const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
+            const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
+            ownTemporaryPaths(root, dataDir);
+            await mkdir(join(root, 'workspace'));
+            const writers = [];
+            const unhandled = [];
+            const onUnhandled = (reason) => unhandled.push(reason);
+            process.on('unhandledRejection', onUnhandled);
+            onTestFinished(() => {
+                process.off('unhandledRejection', onUnhandled);
+            });
+            const app = await composeAuthorizedApp({
+                root,
+                dataDir,
+                relyingParty,
+                installedCodexVersion: 'codex-cli 0.144.3',
+                startAppServers: true,
+                profiles: {
+                    list: async () => [{ name: 'default', state: 'ok', status: 'ready' }],
+                    require: async () => ({
+                        name: 'default',
+                        state: 'ok',
+                        status: 'ready',
+                    }),
+                },
+                launchAppServer: () => {
+                    const writer = {};
+                    return {
+                        rpc: {
+                            request: async (method, params) => {
+                                if (method === 'thread/start') {
+                                    writers.push(writer);
+                                    return { thread: { id: `thread-${writers.length}` } };
+                                }
+                                if (method === 'thread/read')
+                                    return await new Promise((resolve, reject) => {
+                                        writer.releaseRead = () => resolve({ thread: { turns: [] } });
+                                        writer.rejectRead = () => reject(new Error('LATE_READ_FAILURE'));
+                                    });
+                                if (method === 'thread/list')
+                                    return { data: [] };
+                                if (method === 'model/list')
+                                    return { data: [{ id: 'gpt-5.6-terra' }] };
+                                if (method === 'skills/list')
+                                    return {
+                                        data: [{ cwd: params.cwds[0], skills: [], errors: [] }],
+                                    };
+                                return {};
+                            },
+                            onNotification: (listener) => {
+                                writer.notify = listener;
+                                return () => { };
+                            },
+                            onServerRequest: () => () => { },
+                        },
+                        close: () => { },
+                        onExit: () => () => { },
+                    };
+                },
+            });
+            const forgottenId = await createComposedSession(app);
+            await vi.waitFor(() => expect(writers[0]?.releaseRead).toBeTypeOf('function'));
+            expect((await app.inject({ method: 'DELETE', url: `/api/sessions/${forgottenId}` })).statusCode).toBe(204);
+            writers[0].rejectRead();
+            await Promise.resolve();
+            await Promise.resolve();
+            expect(unhandled).toEqual([]);
+            expect((await app.inject('/api/bootstrap')).statusCode).toBe(200);
+            const liveId = await createComposedSession(app);
+            await vi.waitFor(() => expect(writers[1]?.notify).toBeTypeOf('function'));
+            writers[1].notify({
+                method: 'thread/started',
+                params: { thread: { id: 'thread-2', status: { type: 'active' } } },
+            });
+            await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${liveId}`)).json()).toMatchObject({
+                agentActivity: { root: { state: 'working' } },
+            }));
+            await app.close();
+        });
         it('uses the relay root for detached history reads and Open never resumes', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));

package/dist/server/server/composition.js

@@ -32,7 +32,7 @@ import { GitFetchCoordinator } from './platform/git/git-fetch-coordinator.js';
 import { GitSummaryCache } from './platform/git/git-summary-cache.js';
 import { SessionSupervisor } from './platform/runtime/session-supervisor.js';
 import { mapWithConcurrency } from './platform/runtime/concurrency.js';
-import { RelaySession } from './features/sessions/model/relay-session.js';
+import { RelaySession, } from './features/sessions/model/relay-session.js';
 import { AgentActivityRegistry } from './features/agent-activity/registry.js';
 import { decodeAgentActivityFacts } from './platform/codex/activity-facts.js';
 import { resolvedServerRequestId, toPendingInteraction } from './platform/codex/server-request.js';
@@ -130,6 +130,11 @@ export async function composeRelayApp(options) {
             if (!session || !runtime)
                 return;
             const history = await runtime.readHistory(session);
+            // Forget may commit while the detached history reader is still in
+            // flight. Revalidate ownership before handing its result to the
+            // registry, whose publisher intentionally keeps the journal strict.
+            if (!sessions.find(sessionId))
+                return;
             const occurredAt = new Date().toISOString();
             activity.observe({
                 sessionId,
@@ -138,7 +143,12 @@ export async function composeRelayApp(options) {
                 ...(session.threadId ? { threadId: session.threadId } : {}),
                 ...(history.activeTurnId ? { turnId: history.activeTurnId } : {}),
             });
-            activity.childrenReconciled(sessionId, occurredAt, await runtime.listDirectChildren(session));
+            const children = await runtime.listDirectChildren(session);
+            // The writer read is also asynchronous; it cannot publish after the
+            // durable owner has gone away either.
+            if (!sessions.find(sessionId))
+                return;
+            activity.childrenReconciled(sessionId, occurredAt, children);
         },
     });
     const autopilot = new AutopilotCoordinator({
@@ -244,6 +254,14 @@ export async function composeRelayApp(options) {
         profiles: options.profiles,
         launch: options.launchAppServer ?? launchCodexAppServer,
     });
+    const recoverExecutionPolicy = async (session) => {
+        if (session.executionPolicy || !session.threadId)
+            return session;
+        const executionPolicy = await recentThreads.executionPolicy(session.threadId);
+        return executionPolicy
+            ? { ...session, executionPolicy, updatedAt: new Date().toISOString() }
+            : session;
+    };
     const protocol = protocolCompatibility(options.installedCodexVersion, generatedProtocolVersion);
     const gitFetches = new GitFetchCoordinator(fetchUpstream);
     const gitSummaries = new GitSummaryCache(inspectGit);
@@ -297,6 +315,8 @@ export async function composeRelayApp(options) {
             }
             events.publish(journal.append(sessionId, 'plan.updated', { plan: update.plan, reason: update.reason }, occurredAt));
         }
+        if (update.kind === 'updated' && update.reason === 'supervision-start')
+            autopilot.supervisionStarted(sessionId);
         autopilot.planStatusChanged(sessionId);
     };
     runtime = options.startAppServers
@@ -486,7 +506,13 @@ export async function composeRelayApp(options) {
                 profiles: options.profiles,
                 models,
                 sessions: {
-                    list: () => sessions.list().map((session) => withPendingInteractions(session)),
+                    list: () => sessions.list().map((session) => {
+                        const plan = supervisedPlans.find(session.id);
+                        return {
+                            ...withPendingInteractions(session),
+                            ...(plan ? { plan } : {}),
+                        };
+                    }),
                 },
                 protocolCompatible: protocol.compatible,
             },
@@ -496,16 +522,17 @@ export async function composeRelayApp(options) {
                 save: saveSession,
                 find: (id) => withPendingInteractions(sessions.find(id)),
                 list: () => sessions.list().map((session) => withPendingInteractions(session)),
+                plan: (id) => supervisedPlans.find(id),
                 workspaces,
                 profiles: options.profiles,
                 skillProfiles,
                 skillCatalog,
                 defaultSkillProfile: options.explicitSkillProfile,
                 activate: runtime
-                    ? async (session, settings) => {
+                    ? async (session) => {
                         const now = new Date().toISOString();
                         dismissPendingInteractions(session.id, now);
-                        const started = await runtime.start(session, now, settings);
+                        const started = await runtime.start(session, now);
                         return started;
                     }
                     : undefined,
@@ -516,9 +543,9 @@ export async function composeRelayApp(options) {
                     }
                     : undefined,
                 ensureWriter: runtime
-                    ? (session) => {
+                    ? async (session) => {
                         dismissPendingInteractions(session.id, new Date().toISOString());
-                        return runtime.ensureWriter(session, new Date().toISOString());
+                        return runtime.ensureWriter(await recoverExecutionPolicy(session), new Date().toISOString());
                     }
                     : undefined,
                 releaseWriter: runtime
@@ -556,7 +583,7 @@ export async function composeRelayApp(options) {
                     : undefined,
                 restore: runtime
                     ? async (session) => {
-                        const restored = await runtime.restoreWithOutcome(session, new Date().toISOString());
+                        const restored = await runtime.restoreWithOutcome(await recoverExecutionPolicy(session), new Date().toISOString());
                         // An exit can be reported while resume is resolving. Do not let the
                         // route persist a stale ready snapshot over that recovered exit.
                         if (!runtime.ownsWriter(session.id))
@@ -576,6 +603,7 @@ export async function composeRelayApp(options) {
                         list: () => sessions.list(),
                         save: saveSession,
                         read: (session) => runtime.readHistory(session),
+                        executionPolicy: (candidate) => recentThreads.executionPolicy(candidate.id),
                     })
                     : undefined,
                 release: (session) => {

package/dist/server/server/features/agent-activity/model.js

@@ -94,6 +94,11 @@ export function projectAgentActivity(current, fact) {
                         ? { nickname: before.nickname }
                         : {}),
                 ...(fact.childRole ? { role: fact.childRole } : before?.role ? { role: before.role } : {}),
+                ...(fact.childModel
+                    ? { model: fact.childModel }
+                    : before?.model
+                        ? { model: before.model }
+                        : {}),
                 state: childState(fact.childStatus, fact.collaborationAction, before?.state),
                 reason: childReason(fact.childStatus, fact.collaborationAction),
                 observedAt: fact.occurredAt,

package/dist/server/server/features/agent-activity/registry.js

@@ -12,6 +12,7 @@ export class AgentActivityRegistry {
     #timers = new Map();
     #generation = new Map();
     #inFlight = new Map();
+    #disposed = new Set();
     constructor(publish, options = {}) {
         this.publish = publish;
         this.options = options;
@@ -20,6 +21,8 @@ export class AgentActivityRegistry {
         return this.#snapshots.get(sessionId) ?? createAgentActivitySnapshot(sessionId, now);
     }
     observe(fact) {
+        if (this.#disposed.has(fact.sessionId))
+            return this.snapshot(fact.sessionId, fact.occurredAt);
         const current = this.snapshot(fact.sessionId, fact.occurredAt);
         const next = withActivityConfidence(projectAgentActivity(current, fact), fact.kind === 'collaboration' && !fact.childId ? 'stale' : 'fresh');
         if (next !== current) {
@@ -34,6 +37,8 @@ export class AgentActivityRegistry {
         return this.#qualify(sessionId, occurredAt, 'reconciling');
     }
     disconnected(sessionId, occurredAt) {
+        if (this.#disposed.has(sessionId))
+            return this.snapshot(sessionId, occurredAt);
         this.suspend(sessionId);
         const current = this.snapshot(sessionId, occurredAt);
         const next = withActivityConfidence(clearAgentActivityChildren(projectAgentActivity(current, { sessionId, occurredAt, kind: 'processExited' })), 'stale');
@@ -55,7 +60,7 @@ export class AgentActivityRegistry {
         return this.#qualify(sessionId, occurredAt, 'fresh');
     }
     refresh(sessionId) {
-        if (!this.options.reconcile)
+        if (this.#disposed.has(sessionId) || !this.options.reconcile)
             return Promise.resolve();
         const existing = this.#inFlight.get(sessionId);
         if (existing)
@@ -71,6 +76,8 @@ export class AgentActivityRegistry {
     }
     /** Replaces the observed direct-child set; absent children are disconnected. */
     childrenReconciled(sessionId, occurredAt, children) {
+        if (this.#disposed.has(sessionId))
+            return this.snapshot(sessionId, occurredAt);
         let next = this.snapshot(sessionId, occurredAt);
         const seen = new Set(children.map((child) => child.id));
         for (const child of children)
@@ -83,6 +90,7 @@ export class AgentActivityRegistry {
                 ...(child.status ? { childStatus: child.status } : {}),
                 ...(child.nickname ? { childNickname: child.nickname } : {}),
                 ...(child.role ? { childRole: child.role } : {}),
+                ...(child.model ? { childModel: child.model } : {}),
             });
         for (const child of next.subagents)
             if (!seen.has(child.id))
@@ -105,6 +113,7 @@ export class AgentActivityRegistry {
         return next;
     }
     dispose(sessionId) {
+        this.#disposed.add(sessionId);
         this.#snapshots.delete(sessionId);
         this.#timers.get(sessionId)?.();
         this.#timers.delete(sessionId);
@@ -142,6 +151,8 @@ export class AgentActivityRegistry {
         }
     }
     #qualify(sessionId, occurredAt, confidence, fact) {
+        if (this.#disposed.has(sessionId))
+            return this.snapshot(sessionId, occurredAt);
         const current = this.snapshot(sessionId, occurredAt);
         const next = fact
             ? withActivityConfidence(projectAgentActivity(current, { sessionId, occurredAt, ...fact }), confidence)

package/dist/server/server/features/autopilot/application/service.js

@@ -110,13 +110,22 @@ export class AutopilotCoordinator {
     disable(sessionId) {
         const now = this.deps.now();
         const prior = this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, now);
+        // Retain the current plan identity even when Autopilot has not previously
+        // been enabled.  That makes an explicit Off a durable, plan-scoped choice
+        // instead of a generic disabled default that a later supervision signal
+        // could not distinguish from never having been configured.
+        const currentPlan = this.deps.plan(sessionId);
         const cancelled = this.cancelScheduledControl(prior, now);
-        if (!prior.requestedEnabled && prior.state === 'disabled' && !cancelled)
+        if (!prior.requestedEnabled &&
+            prior.state === 'disabled' &&
+            !cancelled &&
+            (!currentPlan || prior.planIdentity === currentPlan.identity))
             return this.snapshot(sessionId);
         const next = {
             ...prior,
             state: 'disabled',
             requestedEnabled: false,
+            ...(currentPlan ? { planIdentity: currentPlan.identity } : {}),
             generation: prior.generation + 1,
             nextEvaluationAt: null,
             ...(cancelled ? { lastControlId: null } : {}),
@@ -275,6 +284,49 @@ export class AutopilotCoordinator {
         if (executionComplete(plan.plan))
             this.evaluate(sessionId);
     }
+    /**
+     * Records a validated, session-private supervision request.  It intentionally
+     * does not discover plans: composition must first bind the update to this
+     * relay session.  A manual Off is authoritative for the retained identity,
+     * while a new identity can receive its own explicit supervision request.
+     */
+    supervisionStarted(sessionId) {
+        const currentPlan = this.deps.plan(sessionId);
+        if (!currentPlan)
+            return { code: 'AUTOPILOT_PLAN_REQUIRED' };
+        if (executionComplete(currentPlan.plan))
+            return { code: 'AUTOPILOT_PLAN_COMPLETE' };
+        const now = this.deps.now();
+        const prior = this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, now);
+        if (prior.planIdentity === currentPlan.identity &&
+            !prior.requestedEnabled &&
+            prior.stopReason === 'manualDisabled')
+            return this.snapshot(sessionId);
+        if (prior.requestedEnabled && prior.planIdentity === currentPlan.identity)
+            return this.snapshot(sessionId);
+        const replacing = Boolean(prior.planIdentity && prior.planIdentity !== currentPlan.identity);
+        const cancelled = replacing ? this.cancelScheduledControl(prior, now) : undefined;
+        if (replacing)
+            this.cancelTimer(sessionId);
+        const next = {
+            ...prior,
+            state: 'monitoring',
+            requestedEnabled: true,
+            planIdentity: currentPlan.identity,
+            planFingerprint: fingerprint(currentPlan.plan),
+            generation: prior.generation + 1,
+            consecutiveNoProgress: 0,
+            nextEvaluationAt: null,
+            ...(cancelled ? { lastControlId: null } : {}),
+            stopReason: null,
+            updatedAt: now,
+        };
+        this.persist(next, cancelled);
+        const session = this.deps.session(sessionId);
+        if (session?.threadId && ['ready', 'turnActive'].includes(session.state))
+            this.evaluate(sessionId);
+        return this.snapshot(sessionId);
+    }
     /** Reacts only to fresh actor status; plan mutations are not scheduling signals. */
     activityChanged(sessionId) {
         const prior = this.deps.store.find(sessionId);

package/dist/server/server/features/sessions/list-sessions/endpoint.js

@@ -5,10 +5,14 @@
  */
 import { buildResumeCommand } from '../application/resume-command.js';
 export function registerListSessions(app, deps) {
-    app.get('/api/sessions', async () => deps.list().map((session) => ({
-        ...session,
-        ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
-        ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
-        resumeCommand: session.threadId ? buildResumeCommand(session) : null,
-    })));
+    app.get('/api/sessions', async () => deps.list().map((session) => {
+        const plan = deps.plan?.(session.id) ?? null;
+        return {
+            ...session,
+            ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
+            ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
+            ...(plan ? { plan } : {}),
+            resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+        };
+    }));
 }

package/dist/server/server/features/sessions/model/relay-session.js

@@ -14,6 +14,21 @@ export function isSessionReadable(session) {
 export function relayOwnsWriter(session) {
     return session.state === 'ready' || session.state === 'turnActive';
 }
+const sandboxes = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+const approvalPolicies = new Set(['untrusted', 'on-request', 'never']);
+export function createSessionExecutionPolicy(input) {
+    if (input.sandbox !== undefined &&
+        (typeof input.sandbox !== 'string' || !sandboxes.has(input.sandbox)))
+        throw new DomainError('SESSION_EXECUTION_POLICY_INVALID');
+    const approvalPolicy = input.approvalPolicy ?? 'on-request';
+    if (typeof approvalPolicy !== 'string' ||
+        !approvalPolicies.has(approvalPolicy))
+        throw new DomainError('SESSION_EXECUTION_POLICY_INVALID');
+    return {
+        ...(input.sandbox === undefined ? {} : { sandbox: input.sandbox }),
+        approvalPolicy: approvalPolicy,
+    };
+}
 export function createEffectiveSkillSelection(input) {
     return {
         ...(input.selectedProfileName === undefined
@@ -38,6 +53,7 @@ export class RelaySession {
             ...(input.model === undefined ? {} : { model: input.model }),
             ...(input.branch === undefined ? {} : { branch: input.branch }),
             effectiveSkillSelection: createEffectiveSkillSelection(input.effectiveSkillSelection),
+            executionPolicy: createSessionExecutionPolicy(input),
             threadId: null,
             state: 'starting',
             desiredState: 'active',
@@ -55,6 +71,9 @@ export class RelaySession {
             workspaceId: workspaceId(input.workspaceId),
             workspacePath: workspacePath(input.workspacePath),
             profile: profileName(input.profile),
+            ...(input.executionPolicy === undefined
+                ? {}
+                : { executionPolicy: createSessionExecutionPolicy(input.executionPolicy) }),
             threadId: threadId(input.threadId),
             state: 'stopped',
             desiredState: 'stopped',

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js

@@ -3,7 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { RelaySession } from '../model/relay-session.js';
+import { RelaySession, } from '../model/relay-session.js';
 export class RecentThreadHistoryUnavailable extends Error {
     constructor() {
         super('RECENT_THREAD_HISTORY_UNAVAILABLE');
@@ -28,15 +28,24 @@ export async function promoteRecentThread(thread, deps) {
 async function promote(thread, deps) {
     const existing = deps.list().find((session) => session.threadId === thread.id);
     if (existing) {
+        const executionPolicy = existing.executionPolicy
+            ? undefined
+            : await deps.executionPolicy?.(thread);
+        const recovered = executionPolicy
+            ? { ...existing, executionPolicy, updatedAt: deps.now() }
+            : existing;
         try {
-            await deps.read(existing);
+            await deps.read(recovered);
         }
         catch {
             throw new RecentThreadHistoryUnavailable();
         }
-        return existing;
+        if (recovered !== existing)
+            deps.save(recovered);
+        return recovered;
     }
     const now = deps.now();
+    const executionPolicy = await deps.executionPolicy?.(thread);
     const imported = existing ??
         RelaySession.fromExistingThread({
             id: deps.createId(),
@@ -44,6 +53,7 @@ async function promote(thread, deps) {
             workspacePath: thread.cwd,
             profile: thread.profile,
             threadId: thread.id,
+            ...(executionPolicy === undefined ? {} : { executionPolicy }),
             now,
         }).snapshot;
     // Validate first: an unavailable thread must never leave an imported stub.

package/dist/server/server/features/sessions/register-routes.js

@@ -59,6 +59,7 @@ export function registerSessionRoutes(app, deps) {
                 list: sessions.list,
                 activity: sessions.agentActivity,
                 autopilot: sessions.autopilotSnapshot,
+                plan: sessions.plan,
             });
         if (sessions.readHistory)
             registerGetHistory(app, {

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -44,17 +44,15 @@ export async function startSession(input, deps) {
         profile: input.profile,
         model,
         ...(branch ? { branch } : {}),
+        sandbox: input.sandbox,
+        approvalPolicy: input.approvalPolicy,
         effectiveSkillSelection,
         now: deps.now(),
     }).snapshot;
     deps.save(session);
     if (!deps.activate)
         return session;
-    const active = await deps.activate(session, {
-        model,
-        sandbox: input.sandbox,
-        approvalPolicy: input.approvalPolicy,
-    });
+    const active = await deps.activate(session, {});
     deps.save(active);
     return active;
 }