gestalt-mobile 0.1.0

package/dist/server/server/features/git/get-summary/endpoint.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerGetGitSummary(app, deps) {
+    app.get('/api/sessions/:id/git', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        return session
+            ? reply.send(await deps.inspect(session.workspacePath))
+            : reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+    });
+}

package/dist/server/server/features/git/pull-rebase/endpoint.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerPullRebase(app, deps) {
+    app.post('/api/sessions/:id/git/pull', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        try {
+            await deps.pull(session.workspacePath);
+            return reply.code(202).send({ accepted: true });
+        }
+        catch (error) {
+            return reply.code(409).send({
+                code: 'GIT_PULL_FAILED',
+                detail: error instanceof Error ? error.message : 'Git pull --rebase failed.',
+            });
+        }
+    });
+}

package/dist/server/server/features/git/push-policy.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function mayPush(input) {
+    if (!input.upstream)
+        return { allowed: false, reason: 'NO_UPSTREAM' };
+    if (input.ahead < 1)
+        return { allowed: false, reason: 'NOT_AHEAD' };
+    if (input.behind > 0)
+        return { allowed: false, reason: 'BEHIND_UPSTREAM' };
+    return { allowed: true };
+}

package/dist/server/server/features/git/push-upstream/endpoint.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+import { mayPush } from '../push-policy.js';
+export function registerPushUpstream(app, deps) {
+    app.post('/api/sessions/:id/git/push', async (request, reply) => {
+        const id = request.params.id;
+        const key = idempotencyKey(request.headers);
+        const scope = `push-git:${id}`;
+        const prior = key ? deps.idempotency?.get(scope, key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const summary = await deps.inspect(session.workspacePath);
+        const allowed = mayPush(summary);
+        if (!allowed.allowed || !summary.upstream)
+            return reply.code(409).send({ code: allowed.reason ?? 'GIT_PUSH_UNAVAILABLE' });
+        await deps.push(session.workspacePath, summary.upstream);
+        const body = { accepted: true };
+        if (key)
+            deps.idempotency?.put(scope, key, 202, JSON.stringify(body));
+        return reply.code(202).send(body);
+    });
+}

package/dist/server/server/features/git/refresh/endpoint.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+export function registerRefreshGit(app, deps) {
+    app.post('/api/sessions/:id/git/refresh', async (request, reply) => {
+        const id = request.params.id;
+        const key = idempotencyKey(request.headers);
+        const scope = `refresh-git:${id}`;
+        const prior = key ? deps.idempotency?.get(scope, key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        await deps.refresh(session.workspacePath);
+        const body = { accepted: true };
+        if (key)
+            deps.idempotency?.put(scope, key, 202, JSON.stringify(body));
+        return reply.code(202).send(body);
+    });
+}

package/dist/server/server/features/git/refresh-policy.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function mayFetch(lastFetchedAt, now, throttleMs = 60_000) {
+    return lastFetchedAt === null || now - lastFetchedAt >= throttleMs;
+}

package/dist/server/server/features/health/get-health/endpoint.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerGetHealth(app, health) {
+    app.get('/health', async () => health.read());
+}

package/dist/server/server/features/health/get-health/request.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/health/get-health/response.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/sessions/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/sessions/application/resume-command.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const quote = (value) => `'${value.replaceAll("'", "'\"'\"'")}'`;
+export function buildResumeCommand(session) {
+    if (!session.threadId)
+        throw new Error('THREAD_REQUIRED');
+    return [
+        'codex-profile',
+        'cli',
+        session.profile,
+        'resume',
+        session.threadId,
+        '-C',
+        session.workspacePath,
+        '--include-non-interactive',
+    ]
+        .map(quote)
+        .join(' ');
+}

package/dist/server/server/features/sessions/application/start-settings.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/sessions/forget-session/endpoint.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 registerForgetSession(app, deps) {
+    app.delete('/api/sessions/:id', async (request, reply) => {
+        const id = request.params.id;
+        if (!deps.find(id))
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        deps.close(id);
+        deps.remove(id);
+        return reply.code(204).send();
+    });
+}

package/dist/server/server/features/sessions/get-history/endpoint.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { toChatItems } from './history-mapper.js';
+export function registerGetHistory(app, deps) {
+    app.get('/api/sessions/:id/history', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const history = await deps.read(session);
+        const items = toChatItems(history.turns);
+        return reply.send({
+            items,
+            activeTurnId: history.activeTurnId,
+            currentSequence: deps.currentSequence(session.id),
+        });
+    });
+}

package/dist/server/server/features/sessions/get-history/history-mapper.js

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function toChatItems(turns) {
+    return turns.flatMap((turn) => turn.items.flatMap((item) => toChatItem(item, occurredAt(item, turn))));
+}
+function toChatItem(item, timestamp) {
+    return [item].flatMap((item) => {
+        const id = typeof item.id === 'string' ? item.id : null;
+        if (!id)
+            return [];
+        switch (item.type) {
+            case 'userMessage': {
+                const text = Array.isArray(item.content)
+                    ? item.content
+                        .filter(isRecord)
+                        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+                        .map((part) => part.text)
+                        .join('\n')
+                    : '';
+                return text
+                    ? [{ id, kind: 'user', text, ...(timestamp ? { occurredAt: timestamp } : {}) }]
+                    : [];
+            }
+            case 'agentMessage':
+                return typeof item.text === 'string'
+                    ? [
+                        {
+                            id,
+                            kind: 'agent',
+                            text: item.text,
+                            ...(item.phase === 'commentary' || item.phase === 'final_answer'
+                                ? { phase: item.phase }
+                                : {}),
+                            ...(timestamp ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
+                    : [];
+            case 'reasoning':
+                if (!Array.isArray(item.summary))
+                    return [];
+                const summary = reasoningSummary(item.summary);
+                return summary.length ? [{ id, kind: 'reasoning', summary }] : [];
+            case 'plan':
+                return typeof item.text === 'string' ? [{ id, kind: 'plan', text: item.text }] : [];
+            case 'commandExecution':
+                return typeof item.command === 'string' && typeof item.status === 'string'
+                    ? [
+                        {
+                            id,
+                            kind: 'command',
+                            command: item.command,
+                            status: item.status,
+                            ...(typeof item.exitCode === 'number' ? { exitCode: item.exitCode } : {}),
+                        },
+                    ]
+                    : [];
+            default:
+                return [];
+        }
+    });
+}
+function occurredAt(item, turn) {
+    const seconds = item.type === 'agentMessage' && item.phase === 'final_answer'
+        ? (turn.completedAt ?? turn.startedAt)
+        : turn.startedAt;
+    return typeof seconds === 'number' ? seconds * 1_000 : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function reasoningSummary(parts) {
+    return parts.flatMap((part) => {
+        if (typeof part === 'string')
+            return part ? [part] : [];
+        if (isRecord(part) && part.type === 'summary_text' && typeof part.text === 'string')
+            return part.text ? [part.text] : [];
+        return [];
+    });
+}

package/dist/server/server/features/sessions/get-session/endpoint.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { buildResumeCommand } from '../application/resume-command.js';
+export function registerGetSession(app, find) {
+    app.get('/api/sessions/:id', async (request, reply) => {
+        const session = find(request.params.id);
+        return session
+            ? reply.send({
+                ...session,
+                resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+            })
+            : reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+    });
+}

package/dist/server/server/features/sessions/history/use-case.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function canonicalHistory(events) {
+    return [...events].sort((a, b) => a.sequence - b.sequence);
+}

package/dist/server/server/features/sessions/interaction/kind.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function isInteractionKind(value) {
+    return ['commandApproval', 'fileChangeApproval', 'permissionsApproval', 'userInput'].includes(value);
+}

package/dist/server/server/features/sessions/interaction/response-guard.js

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

package/dist/server/server/features/sessions/interaction/response-validator.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Validates the relay-safe subset of Codex's generated server-request responses. */
+export function isValidInteractionResponse(kind, value) {
+    if (!isRecord(value))
+        return false;
+    if (kind === 'userInput')
+        return isValidUserInputResponse(value);
+    if (kind === 'permissionsApproval')
+        return isRecord(value.permissions) && (value.scope === 'turn' || value.scope === 'session');
+    return isValidApprovalDecision(kind, value.decision);
+}
+function isValidUserInputResponse(value) {
+    if (!isRecord(value.answers))
+        return false;
+    return Object.values(value.answers).every((answer) => isRecord(answer) &&
+        Array.isArray(answer.answers) &&
+        answer.answers.every((item) => typeof item === 'string'));
+}
+function isValidApprovalDecision(kind, value) {
+    if (['accept', 'acceptForSession', 'decline', 'cancel'].includes(value))
+        return true;
+    if (kind !== 'commandApproval' || !isRecord(value))
+        return false;
+    return ((isRecord(value.acceptWithExecpolicyAmendment) &&
+        isRecord(value.acceptWithExecpolicyAmendment.execpolicy_amendment)) ||
+        (isRecord(value.applyNetworkPolicyAmendment) &&
+            isRecord(value.applyNetworkPolicyAmendment.network_policy_amendment)));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/server/server/features/sessions/interrupt-turn/endpoint.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { interruptTurn } from './use-case.js';
+export function registerInterruptTurn(app, deps) {
+    app.post('/api/sessions/:id/turns/:turnId/interrupt', async (request, reply) => {
+        const { id, turnId } = request.params;
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const result = interruptTurn(session, turnId);
+        if (!result.accepted)
+            return reply.code(409).send({ code: result.code });
+        await deps.interrupt(session, turnId);
+        return reply.send({ accepted: true });
+    });
+}

package/dist/server/server/features/sessions/interrupt-turn/use-case.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function interruptTurn(session, turnId) {
+    return session.activeTurnId === turnId
+        ? { accepted: true }
+        : { accepted: false, code: 'TURN_NOT_ACTIVE' };
+}

package/dist/server/server/features/sessions/lifecycle/use-case.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
+ */
+import { RelaySession } from '../model/relay-session.js';
+export function stopSession(session, now) {
+    return RelaySession.rehydrate(session).stop(now).snapshot;
+}
+export function releaseSession(session, now) {
+    return RelaySession.rehydrate(session).release(now).snapshot;
+}
+export function restoreSession(session, now) {
+    return RelaySession.rehydrate(session).beginRecovery(now).restore(now).snapshot;
+}

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerListRecentThreads(app, deps) {
+    app.get('/api/sessions/recent-threads', async () => {
+        const threads = await deps.list();
+        return threads.map(({ id, cwd, recencyAt }) => ({ id, cwd, recencyAt }));
+    });
+}

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { buildResumeCommand } from '../application/resume-command.js';
+export function registerListSessions(app, deps) {
+    app.get('/api/sessions', async () => deps.list().map((session) => ({
+        ...session,
+        resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+    })));
+}

package/dist/server/server/features/sessions/list-sessions/use-case.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function listSessions(sessions) {
+    return [...sessions].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/server/server/features/sessions/model/errors.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class DomainError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'DomainError';
+    }
+}

package/dist/server/server/features/sessions/model/events.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/sessions/model/relay-session.js

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { DomainError } from './errors.js';
+import { interactionId, profileName, sessionId, threadId, turnId, workspaceId, workspacePath, } from './value-objects.js';
+export class RelaySession {
+    value;
+    events;
+    constructor(value, events = []) {
+        this.value = value;
+        this.events = events;
+    }
+    static create(input) {
+        return new RelaySession({
+            id: sessionId(input.id),
+            workspaceId: workspaceId(input.workspaceId),
+            workspacePath: workspacePath(input.workspacePath),
+            profile: profileName(input.profile),
+            threadId: null,
+            state: 'starting',
+            desiredState: 'active',
+            activeTurnId: null,
+            protocolVersion: null,
+            failureCount: 0,
+            pendingInteractions: [],
+            createdAt: input.now,
+            updatedAt: input.now,
+        });
+    }
+    static fromExistingThread(input) {
+        return new RelaySession({
+            id: sessionId(input.id),
+            workspaceId: workspaceId(input.workspaceId),
+            workspacePath: workspacePath(input.workspacePath),
+            profile: profileName(input.profile),
+            threadId: threadId(input.threadId),
+            state: 'stopped',
+            desiredState: 'stopped',
+            activeTurnId: null,
+            protocolVersion: null,
+            failureCount: 0,
+            pendingInteractions: [],
+            createdAt: input.now,
+            updatedAt: input.now,
+        });
+    }
+    static rehydrate(snapshot) {
+        return new RelaySession(copy(snapshot));
+    }
+    get snapshot() {
+        return copy(this.value);
+    }
+    bindThread(value, now) {
+        return this.transition({ threadId: threadId(value), state: 'ready' }, 'ThreadBound', now);
+    }
+    startTurn(value, now) {
+        if (this.value.state === 'turnActive')
+            throw new DomainError('SESSION_TURN_ACTIVE');
+        if (this.value.state !== 'ready')
+            throw new DomainError('SESSION_NOT_READY');
+        return this.transition({ state: 'turnActive', activeTurnId: turnId(value) }, 'TurnStarted', now);
+    }
+    completeTurn(value, now) {
+        if (this.value.activeTurnId !== value)
+            throw new DomainError('TURN_NOT_ACTIVE');
+        return this.transition({ state: 'ready', activeTurnId: null }, 'TurnCompleted', now);
+    }
+    requestInteraction(input, now) {
+        if (this.value.pendingInteractions.some((item) => item.requestId === input.requestId))
+            throw new DomainError('INTERACTION_ALREADY_PENDING');
+        return this.transition({
+            pendingInteractions: [
+                ...this.value.pendingInteractions,
+                { ...input, requestId: interactionId(input.requestId) },
+            ],
+        }, 'InteractionRequested', now);
+    }
+    resolveInteraction(requestId, now) {
+        if (!this.value.pendingInteractions.some((item) => item.requestId === requestId))
+            throw new DomainError('INTERACTION_NOT_PENDING');
+        return this.transition({
+            pendingInteractions: this.value.pendingInteractions.filter((item) => item.requestId !== requestId),
+        }, 'InteractionResolved', now);
+    }
+    beginRecovery(now) {
+        return this.transition({
+            state: 'recovering',
+            desiredState: 'active',
+            activeTurnId: null,
+            failureCount: this.value.failureCount + 1,
+        }, 'RecoveryBegan', now);
+    }
+    restore(now) {
+        return this.transition({ state: 'ready', desiredState: 'active', activeTurnId: null, failureCount: 0 }, 'SessionRestored', now);
+    }
+    requireAttention(now) {
+        return this.transition({ state: 'attentionRequired', activeTurnId: null }, 'AttentionRequired', now);
+    }
+    stop(now) {
+        return this.transition({ state: 'stopped', desiredState: 'stopped', activeTurnId: null }, 'SessionStopped', now);
+    }
+    release(now) {
+        return this.transition({ state: 'released', desiredState: 'stopped', activeTurnId: null }, 'SessionReleased', now);
+    }
+    transition(change, type, now) {
+        const next = {
+            ...this.value,
+            ...change,
+            pendingInteractions: change.pendingInteractions ?? this.value.pendingInteractions,
+            updatedAt: now,
+        };
+        return new RelaySession(next, [{ type, occurredAt: now, sessionId: this.value.id }]);
+    }
+}
+function copy(snapshot) {
+    return {
+        ...snapshot,
+        pendingInteractions: snapshot.pendingInteractions.map((item) => ({ ...item })),
+    };
+}

package/dist/server/server/features/sessions/model/value-objects.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { DomainError } from './errors.js';
+function required(value) {
+    if (!value.trim())
+        throw new DomainError('INVALID_SESSION_VALUE');
+    return value;
+}
+export const sessionId = (value) => required(value);
+export const workspaceId = (value) => required(value);
+export const workspacePath = (value) => {
+    if (!value.startsWith('/'))
+        throw new DomainError('INVALID_SESSION_VALUE');
+    return required(value);
+};
+export const profileName = (value) => required(value);
+export const threadId = (value) => required(value);
+export const turnId = (value) => required(value);
+export const interactionId = (value) => required(value);