gestalt-mobile 0.20.1 → 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-CnXbn39K.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DYERmevO.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/app.js

@@ -17,6 +17,7 @@ import { registerAuthorizationBoundary } from './platform/http/authorization-bou
 import { registerSkillRoutes } from './features/skills/register-routes.js';
 import { registerOrgPlanAttentionRoutes } from './features/org-plan-attention/register-routes.js';
 import { registerAutopilotRoutes } from './features/autopilot/register-routes.js';
+import { registerFileRoutes } from './features/files/register-routes.js';
 export async function buildApp(deps) {
     // Keep the default boundary finite even when an endpoint forgot a narrower schema.
     const app = fastify({ logger: false, bodyLimit: 1024 * 1024 });
@@ -48,6 +49,7 @@ export async function buildApp(deps) {
     if (deps.orgPlanAttention)
         registerOrgPlanAttentionRoutes(app, deps.orgPlanAttention);
     registerPlanRoutes(app, deps);
+    registerFileRoutes(app, deps);
     registerGitRoutes(app, deps);
     registerSkillRoutes(app, deps);
     registerProblemHandler(app, Boolean(deps.staticDir));

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-'));
@@ -1512,6 +1612,42 @@ describe('production composition', () => {
                 ['GET', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['HEAD', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['DELETE', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
+                [
+                    'GET',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
+                [
+                    'HEAD',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/files/copy',
+                    '/api/workspaces/workspace-1/files/copy',
+                    'protected',
+                ],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/files/move',
+                    '/api/workspaces/workspace-1/files/move',
+                    'protected',
+                ],
+                [
+                    'PUT',
+                    '/api/workspaces/:workspaceId/files/upload',
+                    '/api/workspaces/workspace-1/files/upload',
+                    'protected',
+                ],
+                [
+                    'DELETE',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
                 [
                     'GET',
                     '/api/workspaces/:workspaceId/plans',

package/dist/server/server/composition.js

@@ -9,6 +9,7 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { buildApp } from './app.js';
 import { FilesystemWorkspaceCatalog } from './platform/catalog/filesystem-workspace-catalog.js';
+import { FilesystemWorkspaceFiles } from './platform/filesystem/filesystem-workspace-files.js';
 import { protocolCompatibility } from './platform/codex/protocol-compatibility.js';
 import { launchCodexAppServer } from './platform/codex/codex-process-launcher.js';
 import { CodexModelCatalog } from './platform/codex/codex-model-catalog.js';
@@ -31,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';
@@ -129,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,
@@ -137,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({
@@ -216,6 +227,7 @@ export async function composeRelayApp(options) {
     notifyAutopilotActivity = (sessionId) => autopilot.activityChanged(sessionId);
     options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
+    const workspaceFiles = new FilesystemWorkspaceFiles();
     const models = new CodexModelCatalog(root, options.launchAppServer ?? launchCodexAppServer);
     const skillProfiles = new FilesystemSkillProfileStore(options.homeDirectory ?? homedir());
     const skillCatalog = (profile) => new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer);
@@ -242,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);
@@ -295,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
@@ -484,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,
             },
@@ -494,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,
@@ -514,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
@@ -554,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))
@@ -574,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) => {
@@ -654,6 +684,7 @@ export async function composeRelayApp(options) {
                 },
             },
             workspacePlanRoutes: { workspaces, plans: workspacePlanCatalog },
+            workspaceFileRoutes: { workspaces, files: workspaceFiles },
             autopilot,
             ...(runtime
                 ? {

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/files/application/ports.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

package/dist/server/server/features/files/copy-entry/endpoint.js

@@ -0,0 +1,48 @@
+export function registerCopyEntry(app, deps) {
+    app.post('/api/workspaces/:workspaceId/files/copy', async (request, reply) => mutation(request, reply, deps, 'copy'));
+}
+export async function mutation(request, reply, deps, operation) {
+    const body = request.body;
+    if (!body ||
+        typeof body.source !== 'string' ||
+        typeof body.destinationDirectory !== 'string' ||
+        !['reject', 'replace', 'keep-both'].includes(body.conflict ?? ''))
+        return reply.code(400).send({ code: 'INVALID_FILE_MUTATION' });
+    const method = deps.files[operation];
+    if (!method)
+        return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+    try {
+        const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+        const result = await method.call(deps.files, workspace.realPath, body);
+        return map(reply, result);
+    }
+    catch (error) {
+        return reply
+            .code(error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND' ? 404 : 503)
+            .send({
+            code: error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND'
+                ? 'WORKSPACE_NOT_FOUND'
+                : 'WORKSPACE_FILES_UNAVAILABLE',
+        });
+    }
+}
+export function map(reply, result) {
+    if (result.kind === 'available')
+        return reply.send(result);
+    const mapped = {
+        missing: [404, 'FILE_NOT_FOUND'],
+        protected: [403, 'FILE_PROTECTED'],
+        symlink: [409, 'SYMLINK_UNSUPPORTED'],
+        'invalid-destination': [400, 'INVALID_FILE_DESTINATION'],
+        'source-inside-destination': [409, 'SOURCE_INSIDE_DESTINATION'],
+        'same-parent': [409, 'SAME_PARENT_MOVE'],
+        conflict: [409, 'FILE_CONFLICT'],
+        'replace-unsupported': [409, 'FILE_REPLACE_UNSUPPORTED'],
+        unreadable: [503, 'WORKSPACE_FILES_UNAVAILABLE'],
+    };
+    const [status, code] = mapped[result.kind] ?? [503, 'WORKSPACE_FILES_UNAVAILABLE'];
+    return reply.code(status).send({
+        code,
+        ...(result.kind === 'conflict' ? { replaceAllowed: result.replaceAllowed } : {}),
+    });
+}

package/dist/server/server/features/files/delete-entry/endpoint.js

@@ -0,0 +1,23 @@
+import { map } from '../copy-entry/endpoint.js';
+export function registerDeleteEntry(app, deps) {
+    app.delete('/api/workspaces/:workspaceId/files', async (request, reply) => {
+        const body = request.body;
+        if (typeof body?.path !== 'string' || body.recursive !== true)
+            return reply.code(400).send({ code: 'INVALID_DELETE_REQUEST' });
+        if (!deps.files.delete)
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        try {
+            const w = await deps.workspaces.resolve(request.params.workspaceId);
+            return map(reply, await deps.files.delete(w.realPath, { path: body.path, recursive: true }));
+        }
+        catch (error) {
+            return reply
+                .code(error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND' ? 404 : 503)
+                .send({
+                code: error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND'
+                    ? 'WORKSPACE_NOT_FOUND'
+                    : 'WORKSPACE_FILES_UNAVAILABLE',
+            });
+        }
+    });
+}

package/dist/server/server/features/files/domain/relative-directory.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function parseRelativeDirectory(value) {
+    if (value === '')
+        return value;
+    if (value.includes('\\') || value.includes('\0') || value.startsWith('/') || value.endsWith('/'))
+        return null;
+    const parts = value.split('/');
+    if (parts.some((part) => part === '' || part === '.' || part === '..' || part === '.git'))
+        return null;
+    return value;
+}

package/dist/server/server/features/files/domain/workspace-directory.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};