gestalt-mobile 0.41.3 → 0.42.1

package/README.md

@@ -343,6 +343,19 @@ durable history, deletes only the exact smoke-created Codex threads through the
 app-server afterwards, and always removes its temporary state. It reports
 `SKIP` when the isolated profile is unavailable.
 
+## Control-plane traces
+
+Export the durable Org Plan, Autopilot, and agent-projection timeline for one relay session without starting the server:
+
+```sh
+gestalt-mobile trace <session-id>
+gestalt-mobile trace <session-id> --json
+```
+
+Use `--cwd <workspace>` to select another workspace state database, or `--data-dir <directory>` when the server uses an explicit data directory. The export excludes chat messages, prompts, model output, and environment values. New checkpoint handoffs share a stable `traceId` across checkpoint persistence, continuation scheduling, control dispatch, turn outcome, and agent projection events. The human format includes bounded diagnoses for missing transitions; JSON is suitable for issue attachments and automated analysis.
+
+Browser receipt is intentionally not inferred from server persistence. A trace that contains `agent.activity.updated` proves the backend projection was journaled, while its diagnostic notes that the browser event cursor is still needed to prove delivery.
+
 ## Run from source
 
 ```sh

package/dist/server/server/cli.js

@@ -15,8 +15,11 @@ import { CliUsageError, parseConfig } from './config.js';
 import { LauncherProfileCatalog } from './platform/catalog/launcher-profile-catalog.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
 import { loadPwaIcon } from './platform/pwa/load-pwa-icon.js';
+import { exportControlPlaneTrace, formatControlPlaneTrace, } from './features/control-plane-trace/export-trace.js';
+import { relayStatePath } from './platform/persistence/state-path.js';
 const runFile = promisify(execFile);
 export const usage = `Usage: gestalt-mobile [options]
+       gestalt-mobile trace <session-id> [--json] [--cwd <path>] [--data-dir <path>]
 
 Options:
   --cwd <path>       Workspace root (default: current directory)
@@ -125,6 +128,33 @@ export function installShutdownHandlers(app, signalSource = process) {
     return shutdown;
 }
 function parseInvocation(args, cwd) {
+    if (args[0] === 'trace') {
+        const sessionId = args[1];
+        if (!sessionId || sessionId.startsWith('--'))
+            throw new CliUsageError('trace requires a session ID');
+        let json = false;
+        let root = cwd;
+        let dataDir;
+        for (let index = 2; index < args.length; index += 1) {
+            const option = args[index];
+            if (option === '--json') {
+                if (json)
+                    throw new CliUsageError('Duplicate option: --json');
+                json = true;
+                continue;
+            }
+            if (option !== '--cwd' && option !== '--data-dir')
+                throw new CliUsageError(`Unknown trace option: ${option}`);
+            const value = args[++index];
+            if (!value || value.startsWith('--'))
+                throw new CliUsageError(`Missing value for ${option}`);
+            if (option === '--cwd')
+                root = resolve(cwd, value);
+            else
+                dataDir = resolve(cwd, value);
+        }
+        return { command: 'trace', sessionId, json, root, ...(dataDir ? { dataDir } : {}) };
+    }
     if (args.includes('--help')) {
         if (args.length !== 1)
             throw new CliUsageError('--help cannot be combined with other arguments');
@@ -187,6 +217,23 @@ export async function runCli(dependencies = {}) {
         stdout.write(`${await packageVersion(moduleUrl)}\n`);
         return 0;
     }
+    if (invocation.command === 'trace') {
+        const stateHome = dependencies.environment?.XDG_STATE_HOME ??
+            process.env.XDG_STATE_HOME ??
+            resolve(dependencies.homeDirectory ?? homedir(), '.local/state');
+        const databasePath = invocation.dataDir
+            ? resolve(invocation.dataDir, 'relay.sqlite')
+            : relayStatePath(invocation.root, stateHome);
+        try {
+            const trace = (dependencies.exportTrace ?? exportControlPlaneTrace)(databasePath, invocation.sessionId);
+            stdout.write(invocation.json ? `${JSON.stringify(trace, null, 2)}\n` : formatControlPlaneTrace(trace));
+            return 0;
+        }
+        catch (error) {
+            stderr.write(`Unable to export control-plane trace: ${error instanceof Error ? error.message : 'unknown error'}\n`);
+            return 1;
+        }
+    }
     const skillProfiles = new FilesystemSkillProfileStore(dependencies.homeDirectory ?? homedir());
     if (invocation.command === 'list')
         return listSkillProfiles(skillProfiles, stdout, stderr);

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

@@ -1045,6 +1045,16 @@ describe('production composition', () => {
             await expect
                 .poll(async () => (await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json().activeTurnId)
                 .toBeNull();
+            await expect
+                .poll(() => {
+                const database = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
+                const scheduled = database
+                    .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'autopilot.continuation-scheduled'")
+                    .get(fixture.sessionId);
+                database.close();
+                return scheduled.count;
+            })
+                .toBeGreaterThan(0);
             const startedTurns = () => fixture.handles
                 .flatMap((candidate) => candidate.requests)
                 .filter((request) => request.method === 'turn/start').length;
@@ -1611,8 +1621,14 @@ describe('production composition', () => {
             handle.notify(completion);
             handle.notify(completion);
             await vi.waitFor(() => expect(timers.filter((timer) => !timer.cancelled && !timer.fired)).toHaveLength(1));
-            await runNextTimer();
-            await runNextTimer();
+            for (let attempts = 0; attempts < 3; attempts += 1) {
+                const pending = timers.find((timer) => !timer.cancelled && !timer.fired);
+                if (!pending)
+                    break;
+                pending.fired = true;
+                pending.callback();
+                await Promise.resolve();
+            }
             await vi.waitFor(() => expect(fixture.handles
                 .flatMap((candidate) => candidate.calls)
                 .filter((call) => call === 'turn/start')).toHaveLength(2), { timeout: 3_500 });

package/dist/server/server/composition.js

@@ -137,7 +137,14 @@ export async function composeRelayApp(options) {
     };
     options.onAttentionTransitions?.(attentionTransitions);
     const activity = new AgentActivityRegistry((snapshot, occurredAt) => {
-        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', toAgentActivityDto(snapshot), occurredAt));
+        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', {
+            ...toAgentActivityDto(snapshot),
+            ...(autopilotStore.find(snapshot.sessionId)?.checkpoints?.activeHandoffId
+                ? {
+                    traceId: autopilotStore.find(snapshot.sessionId).checkpoints.activeHandoffId,
+                }
+                : {}),
+        }, occurredAt));
         publishSessionStatus(snapshot.sessionId, occurredAt);
         notifyAutopilotActivity(snapshot.sessionId);
     }, {
@@ -496,7 +503,13 @@ export async function composeRelayApp(options) {
         if (!interactions.resolve(sessionId, requestId, occurredAt, 'failed'))
             return false;
         autopilot.checkpointHandoffFailed(sessionId, turnId);
-        events.publish(journal.append(sessionId, 'org-plan.checkpoint-handoff-failed', { requestId, reason: 'checkpointHandoffFailed' }, occurredAt));
+        events.publish(journal.append(sessionId, 'org-plan.checkpoint-handoff-failed', {
+            requestId,
+            reason: 'checkpointHandoffFailed',
+            ...(autopilotStore.find(sessionId)?.checkpoints?.activeHandoffId
+                ? { traceId: autopilotStore.find(sessionId).checkpoints.activeHandoffId }
+                : {}),
+        }, occurredAt));
         publishAttentionSettlement(sessionId, requestId, occurredAt, 'failed');
         // Neither this timeout nor a failed transport may schedule continuation.
         // If a successful response is already blocked in the writable stream, drop
@@ -696,9 +709,16 @@ export async function composeRelayApp(options) {
             const rootCommandId = resolvedOrigin.kind === 'root' ? completedCommandId(notification) : null;
             if (rootCommandId)
                 autopilot.rootProcessCompleted(sessionId, rootCommandId);
+            const refreshChildTopology = notification.method === 'item/completed' &&
+                activityFacts.some((fact) => fact.kind === 'collaboration' &&
+                    (fact.collaborationAction === 'spawn_agent' ||
+                        fact.collaborationAction === 'resume_agent' ||
+                        fact.collaborationAction === 'close_agent'));
             if (!normalized) {
                 for (const activityFact of activityFacts)
                     activity.observe(activityFact);
+                if (refreshChildTopology)
+                    void activity.refresh(sessionId);
                 return;
             }
             let completedSession;
@@ -717,6 +737,19 @@ export async function composeRelayApp(options) {
             // activeTurnId while the completion fact makes the root appear idle.
             for (const activityFact of activityFacts)
                 activity.observe(activityFact);
+            // Re-evaluate once both halves of the safe continuation boundary are
+            // observable. turnCompleted() releases the durable checkpoint before
+            // these facts project the idle root; its first evaluation can therefore
+            // still see the pre-completion activity snapshot. This second evaluation
+            // is idempotently fenced by the durable control row.
+            if (completedSession)
+                autopilot.evaluate(sessionId);
+            // Lifecycle notifications are fast transition evidence, while
+            // thread/list is the bounded topology authority. Reconcile after the
+            // mutation so canonical identity and every retained child reach both
+            // the GUI and Autopilot even when the notification is sparse.
+            if (refreshChildTopology)
+                void activity.refresh(sessionId);
             events.publish(journal.append(sessionId, normalized.type, normalized.payload, normalized.occurredAt));
             if (completedSession)
                 events.publish(journal.append(sessionId, 'session.updated', completedSession, occurredAt));

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

@@ -196,6 +196,14 @@ function childOutcome(status, action, previous) {
         return 'cancelled';
     if (status === 'completed' || status === 'idle')
         return 'partial';
+    // A follow-up reopens the same physical child. Do not keep presenting its
+    // previous boundary completion while its new turn is running.
+    if (action === 'resume_agent' ||
+        status === 'working' ||
+        status === 'active' ||
+        status === 'running' ||
+        status === 'pendingInit')
+        return undefined;
     return previous;
 }
 function childState(status, action, previous = 'working') {

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

@@ -102,6 +102,10 @@ export class AgentActivityRegistry {
                     kind: 'collaboration',
                     childId: child.id,
                     childStatus: 'notLoaded',
+                    // The bounded roster/process read is authoritative as a unit. If a
+                    // child disappeared, its previous runtime-local process projection
+                    // cannot remain eligible as live work after this reconciliation.
+                    childOwnedProcesses: [],
                 });
         // A malformed/unknown `thread/list` row is not proof that a child is
         // healthy. Preserve it as disconnected but keep the aggregate qualified

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

@@ -49,6 +49,47 @@ export function classifyAgentActivity(activity) {
     const subagentsSettled = activity.aggregateSubagents === 'idle' || activity.aggregateSubagents === 'blocked';
     return rootSettled && subagentsSettled ? 'settled' : 'observe';
 }
+/**
+ * Classifies actor state against the plan position that can legally run next.
+ * Completed canonical executors remain visible evidence, but their terminal
+ * topology cannot indefinitely turn a fresh read into a reconciliation loop.
+ */
+function classifySupervisedActivity(activity, plan) {
+    const selected = plan.steps.findIndex((step) => step.id === plan.currentStepId || step.state === 'WIP');
+    const index = selected >= 0 ? selected : plan.steps.findIndex((step) => step.state !== 'DONE');
+    if (index < 0)
+        return classifyAgentActivity(activity);
+    const position = index + 1;
+    const retained = activity.subagents.filter((child) => {
+        const match = /^L([1-9]\d*)$/.exec(child.canonicalPosition ?? '');
+        if (!match)
+            return true;
+        const historical = Number(match[1]) < position;
+        const supervisedProcess = child.ownedProcesses?.some((process) => process.ownership === 'supervisor' &&
+            (process.state === 'running' || process.state === 'detached-active'));
+        return !historical || supervisedProcess;
+    });
+    // An aggregate-only observation cannot prove which child is historical.
+    if (retained.length === activity.subagents.length)
+        return classifyAgentActivity(activity);
+    if (activity.root.state === 'awaitingHuman' ||
+        retained.some((child) => child.state === 'awaitingHuman'))
+        return 'attention';
+    if (activity.root.state === 'working' ||
+        retained.some((child) => child.state === 'working' ||
+            child.state === 'awaitingAgent' ||
+            child.ownedProcesses?.some((process) => (child.state !== 'disconnected' || process.ownership === 'supervisor') &&
+                (process.state === 'running' || process.state === 'detached-active'))))
+        return 'active';
+    if (activity.root.state === 'disconnected' ||
+        retained.some((child) => child.state === 'disconnected'))
+        return 'reconcile';
+    const rootSettled = activity.root.state === 'idle' ||
+        activity.root.state === 'blocked' ||
+        activity.root.state === 'awaitingAgent';
+    const childrenSettled = retained.every((child) => child.state === 'idle' || child.state === 'blocked');
+    return rootSettled && childrenSettled ? 'settled' : 'observe';
+}
 /** A deliberately pure, exhaustive safety gate. Adapters may only enact this result. */
 export function decideAutopilot(input) {
     const { state, plan, activity, hasPendingInteraction, now, policy } = input;
@@ -93,7 +134,7 @@ export function decideAutopilot(input) {
         return { kind: 'reconcile' };
     if (Date.parse(now) - Date.parse(activity.root.observedAt) > policy.staleAfterMs)
         return { kind: 'reconcile' };
-    const disposition = classifyAgentActivity(activity);
+    const disposition = classifySupervisedActivity(activity, plan);
     if (disposition === 'attention')
         return { kind: 'observe' };
     if (disposition === 'reconcile')

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

@@ -525,7 +525,12 @@ export class AutopilotCoordinator {
                     {
                         sessionId,
                         type: 'autopilot.continuation-scheduled',
-                        payload: { controlId: scheduledControlId },
+                        payload: {
+                            controlId: scheduledControlId,
+                            ...(prior.checkpoints?.activeHandoffId
+                                ? { traceId: prior.checkpoints.activeHandoffId }
+                                : {}),
+                        },
                         occurredAt: now,
                     },
                 ]);
@@ -639,7 +644,12 @@ export class AutopilotCoordinator {
                         : pendingKind === 'terminalReviewAccepted'
                             ? 'org-plan.terminal-review-reported'
                             : 'org-plan.milestone-reported',
-                    payload: { turnId: state.checkpoints.pendingTurnId },
+                    payload: {
+                        turnId: state.checkpoints.pendingTurnId,
+                        ...(state.checkpoints.activeHandoffId
+                            ? { traceId: state.checkpoints.activeHandoffId }
+                            : {}),
+                    },
                     occurredAt,
                 },
             ]);
@@ -700,6 +710,7 @@ export class AutopilotCoordinator {
             ...(previous?.completionEpochs ?? []).filter((entry) => entry.target !== target),
             { target, epoch, reopened: false, completed: true },
         ];
+        const handoffId = `handoff-${key.slice(0, 24)}`;
         const checkpoints = {
             protocolVersion: 1,
             planIdentity: retained.identity,
@@ -710,6 +721,7 @@ export class AutopilotCoordinator {
                 : reportedL1Ids,
             acceptedKeys: boundedUnique([...acceptedKeys, key], 768),
             pendingTurnId: turnId,
+            activeHandoffId: handoffId,
             pendingKind: checkpoint.kind,
             checkpointHandoffFailed: false,
             terminalReviewAccepted: checkpoint.kind === 'terminalReviewAccepted' || previous?.terminalReviewAccepted === true,
@@ -746,10 +758,16 @@ export class AutopilotCoordinator {
                         l2Id: checkpoint.l2Id,
                         position: checkpoint.position,
                         turnId,
+                        traceId: handoffId,
                     }
                     : checkpoint.kind === 'l1Accepted'
-                        ? { l1Id: checkpoint.l1Id, position: checkpoint.position, turnId }
-                        : { turnId },
+                        ? {
+                            l1Id: checkpoint.l1Id,
+                            position: checkpoint.position,
+                            turnId,
+                            traceId: handoffId,
+                        }
+                        : { turnId, traceId: handoffId },
                 occurredAt,
             },
         ]);
@@ -1030,7 +1048,17 @@ export class AutopilotCoordinator {
         const issuedControl = { ...priorControl, status: 'issued', updatedAt: now };
         const events = [
             ...this.snapshotEvents(next, issuedControl),
-            { sessionId, type: 'autopilot.control-issued', payload: { controlId }, occurredAt: now },
+            {
+                sessionId,
+                type: 'autopilot.control-issued',
+                payload: {
+                    controlId,
+                    ...(prior.checkpoints?.activeHandoffId
+                        ? { traceId: prior.checkpoints.activeHandoffId }
+                        : {}),
+                },
+                occurredAt: now,
+            },
         ];
         const control = this.deps.store.claimControlIssued
             ? this.deps.store.claimControlIssued(sessionId, controlId, now, next, events)
@@ -2140,8 +2168,19 @@ export class AutopilotCoordinator {
                         sessionId,
                         type: eventType,
                         payload: eventType === 'autopilot.turn-failed'
-                            ? { controlId, code: failureCode }
-                            : { controlId },
+                            ? {
+                                controlId,
+                                code: failureCode,
+                                ...(this.deps.store.find(sessionId)?.checkpoints?.activeHandoffId
+                                    ? { traceId: this.deps.store.find(sessionId).checkpoints.activeHandoffId }
+                                    : {}),
+                            }
+                            : {
+                                controlId,
+                                ...(this.deps.store.find(sessionId)?.checkpoints?.activeHandoffId
+                                    ? { traceId: this.deps.store.find(sessionId).checkpoints.activeHandoffId }
+                                    : {}),
+                            },
                         occurredAt,
                     },
                 ]

package/dist/server/server/features/autopilot/domain/supervised-lifecycle.js

@@ -390,6 +390,11 @@ function parseCheckpoints(value) {
     const pendingTurnId = value.pendingTurnId === null ? null : boundedText(value.pendingTurnId);
     if (pendingTurnId === undefined)
         return undefined;
+    const activeHandoffId = value.activeHandoffId === undefined || value.activeHandoffId === null
+        ? null
+        : boundedText(value.activeHandoffId);
+    if (activeHandoffId === undefined)
+        return undefined;
     if (value.checkpointHandoffFailed !== undefined &&
         typeof value.checkpointHandoffFailed !== 'boolean')
         return undefined;
@@ -437,6 +442,7 @@ function parseCheckpoints(value) {
         reportedL1Ids,
         acceptedKeys,
         pendingTurnId,
+        ...(activeHandoffId ? { activeHandoffId } : {}),
         pendingKind: pendingKind,
         ...(value.checkpointHandoffFailed === undefined
             ? {}

package/dist/server/server/features/control-plane-trace/export-trace.js

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { DatabaseSync } from 'node:sqlite';
+const relevant = /^(?:org-plan\.|autopilot\.|agent\.activity\.|session\.status\.)/;
+function objectPayload(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function correlation(payload) {
+    for (const key of ['traceId', 'handoffId', 'controlId', 'turnId', 'requestId'])
+        if (typeof payload[key] === 'string' && payload[key])
+            return String(payload[key]);
+    return null;
+}
+function diagnose(events) {
+    const diagnoses = [];
+    if (!events.length)
+        return ['no control-plane events found for this session'];
+    const checkpointIndex = events.findLastIndex((event) => event.type.endsWith('-checkpointed'));
+    const currentHandoff = checkpointIndex < 0 ? events : events.slice(checkpointIndex);
+    const types = new Set(currentHandoff.map((event) => event.type));
+    if ([...types].some((type) => type.endsWith('-checkpointed')) &&
+        !types.has('autopilot.continuation-scheduled'))
+        diagnoses.push('checkpoint persisted, but no continuation was scheduled');
+    if (types.has('autopilot.continuation-scheduled') &&
+        !types.has('autopilot.control-issued') &&
+        !types.has('autopilot.executor-resumed'))
+        diagnoses.push('continuation scheduled, but no control or executor dispatch was observed');
+    if (types.has('autopilot.control-issued') &&
+        !types.has('autopilot.turn-started') &&
+        !types.has('autopilot.turn-failed'))
+        diagnoses.push('control issued, but no turn acceptance or failure was observed');
+    if (types.has('org-plan.checkpoint-handoff-failed'))
+        diagnoses.push('checkpoint response handoff failed; inspect the matching trace ID');
+    if (currentHandoff.some((event) => event.type === 'agent.activity.updated'))
+        diagnoses.push('backend agent projection was recorded; browser delivery still requires the client event cursor');
+    return diagnoses;
+}
+export function exportControlPlaneTrace(databasePath, sessionId, generatedAt = new Date().toISOString()) {
+    const database = new DatabaseSync(databasePath, { readOnly: true });
+    try {
+        const rows = database
+            .prepare('SELECT sequence,occurred_at,type,payload_json FROM session_events WHERE session_id = ? ORDER BY sequence')
+            .all(sessionId);
+        const events = rows
+            .filter((row) => relevant.test(row.type))
+            .map((row) => {
+            const payload = objectPayload(row.payload_json);
+            return {
+                sequence: row.sequence,
+                occurredAt: row.occurred_at,
+                type: row.type,
+                payload,
+                traceId: correlation(payload),
+            };
+        });
+        return { schemaVersion: 1, sessionId, generatedAt, events, diagnoses: diagnose(events) };
+    }
+    finally {
+        database.close();
+    }
+}
+export function formatControlPlaneTrace(trace) {
+    const lines = [
+        `Control-plane trace for ${trace.sessionId}`,
+        `Generated: ${trace.generatedAt}`,
+        '',
+    ];
+    for (const event of trace.events) {
+        const correlationLabel = event.traceId ? ` trace=${event.traceId}` : '';
+        lines.push(`${String(event.sequence).padStart(6)}  ${event.occurredAt}  ${event.type}${correlationLabel}`);
+    }
+    lines.push('', 'Diagnosis:');
+    if (!trace.diagnoses.length)
+        lines.push('  No incomplete control-plane transition detected.');
+    else
+        for (const diagnosis of trace.diagnoses)
+            lines.push(`  - ${diagnosis}`);
+    return `${lines.join('\n')}\n`;
+}

package/dist/server/server/platform/codex/activity-facts.js

@@ -147,10 +147,12 @@ function collaborationAction(tool) {
         spawnAgent: 'spawn_agent',
         sendInput: 'send_input',
         resumeAgent: 'resume_agent',
+        followupTask: 'resume_agent',
         closeAgent: 'close_agent',
         spawn_agent: 'spawn_agent',
         send_input: 'send_input',
         resume_agent: 'resume_agent',
+        followup_task: 'resume_agent',
         close_agent: 'close_agent',
         wait: 'wait',
     }[tool];

package/dist/server/shared/contracts/org-plan-checkpoint.js

@@ -10,81 +10,14 @@ const record = (value) => typeof value === 'object' && value !== null && !Array.
 export const gestaltOrgPlanCheckpointDynamicTool = {
     type: 'function',
     name: GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME,
-    description: 'Record a validated supervised Org Plan report boundary. This is not review authority and must only be called by the active root after the Org Plan helper has recorded the matching state.',
+    description: 'Record a validated supervised Org Plan report boundary. Send only the boundary kind; Mobile derives and validates all details from authoritative control state.',
     inputSchema: {
         type: 'object',
         additionalProperties: false,
-        required: ['version', 'kind', 'planIdentity'],
+        required: ['kind'],
         properties: {
-            version: { const: 1 },
             kind: { type: 'string', enum: ['l2Completed', 'l1Accepted', 'terminalReviewAccepted'] },
-            planIdentity: { type: 'string', minLength: 1, maxLength: 128 },
-            l1Id: { type: 'string', minLength: 1, maxLength: 128 },
-            l2Id: { type: 'string', minLength: 1, maxLength: 128 },
-            position: { type: 'string', pattern: '^L[1-9][0-9]*(\\.[1-9][0-9]*)?$', maxLength: 32 },
-            status: { const: 'DONE' },
-            verdict: { const: 'ACCEPT' },
-            commit: {
-                oneOf: [
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['kind', 'subject', 'shortHash'],
-                        properties: {
-                            kind: { const: 'created' },
-                            subject: { type: 'string', minLength: 1, maxLength: 160 },
-                            shortHash: { type: 'string', pattern: '^[0-9a-f]{7,16}$' },
-                        },
-                    },
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['kind'],
-                        properties: { kind: { const: 'notRequired' } },
-                    },
-                ],
-            },
-            findings: { type: 'string', minLength: 1, maxLength: 600 },
-            changes: { type: 'string', minLength: 1, maxLength: 600 },
-            files: { type: 'string', minLength: 1, maxLength: 600 },
-            tests: { type: 'string', minLength: 1, maxLength: 600 },
         },
-        oneOf: [
-            {
-                properties: { kind: { const: 'l2Completed' } },
-                required: ['l1Id', 'l2Id', 'position', 'status', 'changes', 'files', 'tests'],
-                not: {
-                    anyOf: [{ required: ['verdict'] }, { required: ['commit'] }, { required: ['findings'] }],
-                },
-            },
-            {
-                properties: { kind: { const: 'l1Accepted' } },
-                required: ['l1Id', 'position', 'verdict', 'commit'],
-                not: {
-                    anyOf: [
-                        { required: ['l2Id'] },
-                        { required: ['status'] },
-                        { required: ['changes'] },
-                        { required: ['files'] },
-                    ],
-                },
-            },
-            {
-                properties: { kind: { const: 'terminalReviewAccepted' } },
-                required: ['verdict'],
-                not: {
-                    anyOf: [
-                        { required: ['l1Id'] },
-                        { required: ['l2Id'] },
-                        { required: ['position'] },
-                        { required: ['status'] },
-                        { required: ['commit'] },
-                        { required: ['changes'] },
-                        { required: ['files'] },
-                    ],
-                },
-            },
-        ],
     },
 };
 export function parseOrgPlanCheckpoint(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.41.3",
+  "version": "0.42.1",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",