gestalt-mobile 0.41.0 → 0.41.2

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

@@ -13,6 +13,19 @@ export const blockingResumeConditions = {
     externalState: 'externalStateChanged',
     materialAmbiguity: 'userGuidance',
 };
+export function executorAssignment(executor, state = 'resumable') {
+    const taskName = executor.taskPath.split('/').filter(Boolean).at(-1);
+    const identity = executorIdentity(executor.canonicalTaskName, executor.continuationGeneration);
+    return {
+        canonicalPosition: executor.canonicalPosition,
+        canonicalTaskName: executor.canonicalTaskName,
+        taskName: taskName || identity.taskName,
+        taskPath: executor.taskPath,
+        threadId: executor.threadId,
+        generation: identity.generation,
+        state,
+    };
+}
 export function checkpointTarget(kind, l1Id, l2Id) {
     return kind === 'l2'
         ? JSON.stringify([kind, l1Id, l2Id])
@@ -153,6 +166,8 @@ export function parsePersistedSupervisedLifecycle(value) {
     const resumeFailures = executorValue.resumeFailures === undefined
         ? 0
         : nonNegativeInteger(executorValue.resumeFailures);
+    const assignmentValue = executorValue.assignment === undefined ? undefined : record(executorValue.assignment);
+    const assignment = assignmentValue ? parseExecutorAssignment(assignmentValue) : undefined;
     const replacementValue = executorValue.replacement === undefined ? undefined : record(executorValue.replacement);
     const replacementGeneration = replacementValue && nonNegativeInteger(replacementValue.generation);
     const replacementTaskName = replacementValue && boundedText(replacementValue.taskName);
@@ -160,6 +175,12 @@ export function parsePersistedSupervisedLifecycle(value) {
     const replacementCanonicalPosition = replacementValue && boundedText(replacementValue.canonicalPosition);
     const replacementPlanIdentity = replacementValue && boundedText(replacementValue.planIdentity);
     const replacementPlanFingerprint = replacementValue && boundedText(replacementValue.planFingerprint);
+    const replacementPreviousValue = replacementValue && record(replacementValue.previous);
+    const replacementPrevious = replacementPreviousValue
+        ? parseExecutorAssignment(replacementPreviousValue)
+        : undefined;
+    const replacementReason = replacementValue && stringValue(replacementValue.reason, ['explicitExecutorRejection']);
+    const replacementEvidence = replacementValue && boundedText(replacementValue.evidence);
     if (!canonicalPosition ||
         !canonicalTaskName ||
         !taskPath ||
@@ -170,14 +191,32 @@ export function parsePersistedSupervisedLifecycle(value) {
         continuationGeneration === null ||
         continuationCount === null ||
         resumeFailures === null ||
+        (executorValue.assignment !== undefined && !assignment) ||
         (replacementValue &&
             (!replacementGeneration ||
                 !replacementTaskName ||
                 !replacementCanonicalTaskName ||
                 !replacementCanonicalPosition ||
                 !replacementPlanIdentity ||
-                !replacementPlanFingerprint)))
+                !replacementPlanFingerprint ||
+                (replacementValue.previous !== undefined && !replacementPrevious) ||
+                (replacementReason !== undefined && replacementReason !== 'explicitExecutorRejection') ||
+                (replacementValue.evidence !== undefined && !replacementEvidence))))
         return undefined;
+    if (replacementValue) {
+        try {
+            const identity = executorIdentity(replacementCanonicalTaskName, replacementGeneration);
+            if (identity.taskName !== replacementTaskName ||
+                identity.canonicalPosition !== replacementCanonicalPosition ||
+                (replacementPrevious &&
+                    (replacementPrevious.canonicalTaskName !== canonicalTaskName ||
+                        replacementPrevious.canonicalPosition !== canonicalPosition)))
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     const commandsValue = executorValue.commands;
     if (commandsValue !== undefined && (!Array.isArray(commandsValue) || commandsValue.length > 32))
         return undefined;
@@ -268,6 +307,7 @@ export function parsePersistedSupervisedLifecycle(value) {
             continuationGeneration,
             continuationCount,
             ...(resumeFailures ? { resumeFailures } : {}),
+            ...(assignment ? { assignment } : {}),
             ...(replacementValue
                 ? {
                     replacement: {
@@ -277,6 +317,9 @@ export function parsePersistedSupervisedLifecycle(value) {
                         canonicalPosition: replacementCanonicalPosition,
                         planIdentity: replacementPlanIdentity,
                         planFingerprint: replacementPlanFingerprint,
+                        ...(replacementPrevious ? { previous: replacementPrevious } : {}),
+                        ...(replacementReason ? { reason: replacementReason } : {}),
+                        ...(replacementEvidence ? { evidence: replacementEvidence } : {}),
                     },
                 }
                 : {}),
@@ -396,19 +439,50 @@ function parseCheckpoints(value) {
         terminalReviewAccepted: value.terminalReviewAccepted,
     };
 }
+function parseExecutorAssignment(value) {
+    const canonicalPosition = boundedText(value.canonicalPosition);
+    const canonicalTaskName = boundedText(value.canonicalTaskName);
+    const taskName = boundedText(value.taskName);
+    const taskPath = boundedText(value.taskPath);
+    const threadId = boundedText(value.threadId);
+    const generation = nonNegativeInteger(value.generation);
+    const state = stringValue(value.state, ['resumable', 'closed', 'unavailable']);
+    if (!canonicalPosition ||
+        !canonicalTaskName ||
+        !taskName ||
+        !taskPath ||
+        !threadId ||
+        generation === null ||
+        generation < 1 ||
+        !state)
+        return undefined;
+    try {
+        const identity = executorIdentity(canonicalTaskName, generation);
+        return identity.canonicalPosition === canonicalPosition && identity.taskName === taskName
+            ? { canonicalPosition, canonicalTaskName, taskName, taskPath, threadId, generation, state }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function classifyExecutorOutcome(input) {
     if (input.objectiveComplete)
-        return { outcome: 'objective_complete' };
-    if (input.reportedOutcome === 'cancelled' || input.reportedOutcome === 'failed')
-        return { outcome: input.reportedOutcome };
+        return { classification: 'done', outcome: 'objective_complete' };
     const blocking = input.blockingReason && input.resumeCondition
         ? { reason: input.blockingReason, resumeCondition: input.resumeCondition }
         : undefined;
     if (input.reportedOutcome === 'blocked' && validStructuredBlock(blocking))
-        return { outcome: 'blocked', blocking };
+        return { classification: 'blocker', outcome: 'blocked', blocking };
+    if (input.active)
+        // Fresh activity outranks the previous turn's terminal transport status.
+        return { classification: 'ongoing', outcome: 'partial' };
+    if (input.reportedOutcome === 'cancelled' || input.reportedOutcome === 'failed')
+        return { classification: 'recoverableFailure', outcome: input.reportedOutcome };
     // A turn ending, a checkpoint, or free-form language about time/context is
-    // not objective state. Incomplete Org state remains mechanically partial.
-    return { outcome: 'partial' };
+    // not objective state. Incomplete, settled Org state is mechanically
+    // recoverable and must return to the same canonical executor.
+    return { classification: 'recoverableFailure', outcome: 'partial' };
 }
 export function decideSupervisedLifecycle(input) {
     if (input.explicitlyPausedOrCancelled || executionComplete(input.plan))

package/dist/server/server/features/org-plan-checkpoint/application/validate.js

@@ -3,8 +3,13 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+/** Terminal roster entries remain visible and are not active implementation writers. */
+export function hasActiveL1Writer(snapshot, position) {
+    return snapshot.subagents.some((child) => child.canonicalPosition === position &&
+        ['working', 'awaitingAgent', 'awaitingHuman'].includes(child.state));
+}
 /** Expands a host-owned compact boundary signal from authoritative plan state. */
-export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
+export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity, publicationReason = null) {
     if (kind === 'terminalReviewAccepted')
         return {
             version: 1,
@@ -12,8 +17,16 @@ export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
             planIdentity,
             verdict: 'ACCEPT',
         };
-    const selected = plan.steps.find((step) => step.id === plan.currentStepId) ??
-        [...plan.steps].reverse().find((step) => step.state === 'DONE' || step.state === 'WIP');
+    const reviewedId = publicationReason?.match(/^review:([^:]{1,128}):REVIEWED$/)?.[1];
+    const selected = kind === 'l1Accepted'
+        ? ((reviewedId
+            ? plan.steps.find((step) => step.id === reviewedId && step.state === 'DONE' && step.reviewStatus === 'REVIEWED')
+            : undefined) ??
+            [...plan.steps]
+                .reverse()
+                .find((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED'))
+        : (plan.steps.find((step) => step.id === plan.currentStepId) ??
+            [...plan.steps].reverse().find((step) => step.state === 'DONE' || step.state === 'WIP'));
     if (!selected)
         return null;
     const l1Position = `L${plan.steps.indexOf(selected) + 1}`;
@@ -44,25 +57,80 @@ export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
     };
 }
 export function validOrgPlanCheckpoint(input) {
+    return validateOrgPlanCheckpoint(input).valid;
+}
+export function validateOrgPlanCheckpoint(input) {
     const { checkpoint, plan, planIdentity, rootOwned } = input;
-    if (!rootOwned || checkpoint.planIdentity !== planIdentity)
-        return false;
+    if (!rootOwned)
+        return { valid: false, reasonCode: 'rootNotOwner' };
+    if (checkpoint.planIdentity !== planIdentity)
+        return { valid: false, reasonCode: 'planIdentityMismatch' };
     if (checkpoint.kind === 'terminalReviewAccepted')
-        return plan.steps.every((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED');
+        return plan.steps.every((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED')
+            ? { valid: true }
+            : { valid: false, reasonCode: 'terminalReviewIncomplete' };
     const l1 = plan.steps.find((step) => step.id === checkpoint.l1Id);
     if (!l1)
-        return false;
+        return { valid: false, reasonCode: 'l1NotFound' };
     const position = `L${plan.steps.indexOf(l1) + 1}`;
     if (checkpoint.kind === 'l2Completed') {
         const l2 = l1.children.find((step) => step.id === checkpoint.l2Id);
         if (!l2)
-            return false;
-        return (checkpoint.position === `${position}.${l1.children.indexOf(l2) + 1}` &&
-            l2.state === 'DONE' &&
-            l1.reviewStatus === 'UNREVIEWED');
+            return { valid: false, reasonCode: 'l2NotFound' };
+        const expectedPosition = `${position}.${l1.children.indexOf(l2) + 1}`;
+        if (checkpoint.position !== expectedPosition)
+            return {
+                valid: false,
+                reasonCode: 'checkpointPositionMismatch',
+                expected: { position: expectedPosition },
+                observed: { position: checkpoint.position },
+            };
+        if (l2.state !== 'DONE')
+            return {
+                valid: false,
+                reasonCode: 'l2NotDone',
+                expected: { l2State: 'DONE' },
+                observed: { l2State: l2.state },
+            };
+        return l1.reviewStatus === 'UNREVIEWED'
+            ? { valid: true }
+            : { valid: false, reasonCode: 'l1AlreadyReviewed' };
     }
-    return (checkpoint.position === position &&
-        l1.state === 'DONE' &&
-        l1.reviewStatus === 'REVIEWED' &&
-        !input.hasActiveL1Writer(position));
+    if (checkpoint.position !== position)
+        return {
+            valid: false,
+            reasonCode: 'checkpointPositionMismatch',
+            expected: { position },
+            observed: { position: checkpoint.position },
+        };
+    if (l1.state !== 'DONE')
+        return {
+            valid: false,
+            reasonCode: 'l1NotDone',
+            expected: { l1State: 'DONE' },
+            observed: { l1State: l1.state },
+        };
+    if (l1.reviewStatus !== 'REVIEWED')
+        return {
+            valid: false,
+            reasonCode: 'l1NotReviewed',
+            expected: { reviewStatus: 'REVIEWED' },
+            observed: { reviewStatus: l1.reviewStatus ?? null },
+        };
+    const incompleteChild = l1.children.find((child) => child.state !== 'DONE');
+    if (incompleteChild)
+        return {
+            valid: false,
+            reasonCode: 'l1ChildrenIncomplete',
+            expected: { childrenDone: true },
+            observed: { childrenDone: false, childState: incompleteChild.state },
+        };
+    if (input.hasActiveL1Writer(position))
+        return {
+            valid: false,
+            reasonCode: 'executorStillActive',
+            expected: { executorTerminal: true },
+            observed: { executorTerminal: false },
+        };
+    return { valid: true };
 }

package/dist/server/server/features/plans/application/supervised-plan-registry.js

@@ -8,7 +8,11 @@ export class SupervisedPlanRegistry {
     plans = new Map();
     accept(sessionId, update) {
         if (update.kind === 'updated')
-            this.plans.set(sessionId, { plan: update.plan, identity: update.identity });
+            this.plans.set(sessionId, {
+                plan: update.plan,
+                identity: update.identity,
+                publicationReason: update.reason,
+            });
     }
     find(sessionId) {
         return this.plans.get(sessionId)?.plan ?? null;
@@ -16,6 +20,9 @@ export class SupervisedPlanRegistry {
     identity(sessionId) {
         return this.plans.get(sessionId)?.identity ?? null;
     }
+    publicationReason(sessionId) {
+        return this.plans.get(sessionId)?.publicationReason ?? null;
+    }
     clear(sessionId) {
         this.plans.delete(sessionId);
     }

package/dist/server/server/platform/persistence/sqlite-pending-interaction-store.js

@@ -17,16 +17,22 @@ export class SqlitePendingInteractionStore {
     constructor(db) {
         this.db = db;
     }
-    add(sessionId, interaction) {
+    add(sessionId, interaction, initialResolutionState = 'active') {
         this.db
-            .prepare(`INSERT INTO pending_interactions (session_id,request_id,kind,payload_json,turn_id,requested_at)
-         VALUES (?,?,?,?,?,?)
+            .prepare(`INSERT INTO pending_interactions (session_id,request_id,kind,payload_json,turn_id,requested_at,resolution_state)
+         VALUES (?,?,?,?,?,?,?)
          ON CONFLICT(session_id,request_id) DO UPDATE SET
            kind = excluded.kind, payload_json = excluded.payload_json, turn_id = excluded.turn_id,
            requested_at = excluded.requested_at, resolved_at = NULL, outcome = NULL, operation_key = NULL,
-           resolution_state = 'active'
+           resolution_state = excluded.resolution_state
          WHERE pending_interactions.kind != 'orgPlanAttention'`)
-            .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload), interaction.turnId ?? null, interaction.requestedAt ?? null);
+            .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload), interaction.turnId ?? null, interaction.requestedAt ?? null, initialResolutionState);
+    }
+    resolutionState(sessionId, requestId) {
+        const row = this.db
+            .prepare('SELECT resolution_state FROM pending_interactions WHERE session_id = ? AND request_id = ? AND resolved_at IS NULL')
+            .get(sessionId, requestId);
+        return row?.resolution_state ?? null;
     }
     resolve(sessionId, requestId, resolvedAt, outcome = 'answered') {
         return (this.db
@@ -56,7 +62,7 @@ export class SqlitePendingInteractionStore {
     /** Persist the in-flight delivery boundary before the app-server is notified. */
     beginDelivery(sessionId, requestId, operationKey) {
         return (this.db
-            .prepare("UPDATE pending_interactions SET resolution_state = 'delivering' WHERE session_id = ? AND request_id = ? AND operation_key = ? AND resolved_at IS NULL AND resolution_state IN ('active','delivering')")
+            .prepare("UPDATE pending_interactions SET resolution_state = 'delivering' WHERE session_id = ? AND request_id = ? AND operation_key = ? AND resolved_at IS NULL AND resolution_state IN ('active','acknowledged','delivering')")
             .run(sessionId, requestId, operationKey).changes === 1);
     }
     /** A local writer outage is retryable only by the already-claimed key. */

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

@@ -93,13 +93,20 @@ export function parseOrgPlanAttentionResponse(value) {
         ...(typeof value.guidance === 'string' ? { guidance: value.guidance } : {}),
     };
 }
-/** The only result accepted by the held app-server dynamic-tool request. */
+/** Legacy human resolution payload used only for pre-acknowledgement held requests. */
 export function toOrgPlanAttentionToolResponse(response) {
     return {
         success: true,
         contentItems: [{ type: 'inputText', text: JSON.stringify(response) }],
     };
 }
+/** Immediate persist-first acknowledgement returned to the dynamic-tool caller. */
+export function toOrgPlanAttentionAcknowledgement(acknowledgement = { accepted: true }) {
+    return {
+        success: acknowledgement.accepted,
+        contentItems: [{ type: 'inputText', text: JSON.stringify(acknowledgement) }],
+    };
+}
 export function isOrgPlanAttentionToolResponse(value) {
     if (!isRecord(value) || value.success !== true || !Array.isArray(value.contentItems))
         return false;

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

@@ -176,13 +176,37 @@ export function parseOrgPlanCheckpoint(value) {
     };
 }
 /** Acknowledgement deliberately contains no plan path, findings, or model text. */
-export function toOrgPlanCheckpointToolResponse() {
+export function toOrgPlanCheckpointToolResponse(status, failure) {
+    const result = status === 'recorded'
+        ? {
+            status,
+            durable: true,
+            next: 'emitBoundaryFinalAndEndTurn',
+            allowFurtherTools: false,
+        }
+        : status === 'alreadyRecorded'
+            ? {
+                status,
+                durable: true,
+                next: 'continueFromDurableCheckpoint',
+                allowBoundaryFinal: false,
+            }
+            : {
+                status,
+                reasonCode: failure?.reasonCode ?? 'checkpointPersistenceFailed',
+                durable: false,
+                ...(failure?.expected ? { expected: failure.expected } : {}),
+                ...(failure?.observed ? { observed: failure.observed } : {}),
+                ...(failure?.correlationId ? { correlationId: failure.correlationId } : {}),
+                next: 'reconcileCheckpointState',
+                allowBoundaryFinal: false,
+            };
     return {
-        success: true,
+        success: status !== 'failed',
         contentItems: [
             {
                 type: 'inputText',
-                text: '{"accepted":true,"next":"emitBoundaryFinalAndEndTurn","allowFurtherTools":false}',
+                text: JSON.stringify(result),
             },
         ],
     };

package/dist/server/shared/contracts/plan-signal.js

@@ -13,5 +13,7 @@ export const planSignalReasons = [
     'resync',
 ];
 export function isPlanSignalReason(value) {
-    return typeof value === 'string' && planSignalReasons.includes(value);
+    return (typeof value === 'string' &&
+        (planSignalReasons.includes(value) ||
+            /^review:[A-Za-z0-9._-]{1,128}:REVIEWED$/.test(value)));
 }

package/package.json

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