gestalt-mobile 0.17.2 → 0.18.0

package/dist/server/server/features/org-plan-attention/resolve/endpoint.js

@@ -0,0 +1,42 @@
+import { parseOrgPlanAttentionResponse, toOrgPlanAttentionToolResponse, } from '../../../../shared/contracts/org-plan-attention.js';
+export function registerResolveOrgPlanAttention(app, deps) {
+    app.post('/api/sessions/:id/attention/:requestId/resolve', async (request, reply) => {
+        const { id: sessionId, requestId } = request.params;
+        const body = request.body;
+        const validFields = body &&
+            Object.keys(body).every((key) => ['operationKey', 'action', 'guidance'].includes(key));
+        const response = validFields
+            ? parseOrgPlanAttentionResponse({
+                action: body.action,
+                ...(body.guidance === undefined ? {} : { guidance: body.guidance }),
+            })
+            : null;
+        const operationKey = typeof body?.operationKey === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(body.operationKey)
+            ? body.operationKey
+            : null;
+        if (!response || !operationKey)
+            return reply.code(400).send({ code: 'ATTENTION_RESPONSE_INVALID' });
+        const outcome = await deps.resolver.resolve({
+            sessionId,
+            requestId,
+            operationKey,
+            response: toOrgPlanAttentionToolResponse(response),
+        });
+        if (outcome.kind === 'accepted' || outcome.kind === 'replayed')
+            return reply.code(202).send({
+                accepted: true,
+                replayed: outcome.kind === 'replayed',
+                resolvedAt: outcome.resolvedAt,
+            });
+        const code = outcome.kind === 'noActive'
+            ? 'ORG_PLAN_ATTENTION_NOT_ACTIVE'
+            : outcome.kind === 'staleOperation'
+                ? 'ATTENTION_OPERATION_STALE'
+                : outcome.kind === 'legacyUnsupported'
+                    ? 'ATTENTION_LEGACY_UNSUPPORTED'
+                    : outcome.kind === 'writerCleared'
+                        ? 'ATTENTION_WRITER_CLEARED'
+                        : 'ATTENTION_WRITER_UNAVAILABLE';
+        return reply.code(outcome.kind === 'noActive' ? 404 : 409).send({ code });
+    });
+}

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

@@ -94,6 +94,9 @@ export function parseSupervisedPlan(input) {
         return unavailable('MISSING_REQUIRED_FIELD');
     const allSteps = headings;
     const allDone = allSteps.every((step) => step.state === 'DONE');
+    const executionComplete = built.every((step) => step.state === 'DONE' &&
+        step.reviewStatus === 'REVIEWED' &&
+        step.children.every((child) => child.state === 'DONE'));
     const currentStepId = findCurrentStepId(allSteps, allDone);
     if (!currentStepId)
         return unavailable('MALFORMED_ORG');
@@ -108,6 +111,7 @@ export function parseSupervisedPlan(input) {
             totalSteps: allSteps.length,
             doneSteps: allSteps.filter((step) => step.state === 'DONE').length,
             allDone,
+            executionComplete,
             currentStepId,
         }),
     };

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

@@ -38,12 +38,21 @@ export function registerGetHistory(app, deps) {
                 retryable: true,
             });
         }
-        const items = toChatItems(history.turns);
+        const controls = deps.autopilotControlTurns?.(session.id) ?? new Map();
+        const items = toChatItems(history.turns, controls);
+        const auditSource = deps.autopilotAudit?.(session.id, 100) ?? [];
+        const boundedAudit = isBoundedAudit(auditSource) ? auditSource : null;
+        const auditEvents = boundedAudit
+            ? boundedAudit.events
+            : auditSource;
+        const autopilotAudit = toAutopilotAudit(auditEvents);
         const snapshot = {
             items,
-            turns: toChatTurns(history.turns),
+            turns: toChatTurns(history.turns, controls),
             activeTurnId: history.activeTurnId,
             interactions: deps.interactions?.(session.id) ?? [],
+            ...(autopilotAudit.length ? { autopilotAudit } : {}),
+            ...(boundedAudit?.truncated ? { autopilotAuditTruncated: true } : {}),
             baseSequence,
             // Temporary compatibility for clients which have not adopted ChatSnapshot.
             currentSequence: baseSequence,
@@ -51,3 +60,54 @@ export function registerGetHistory(app, deps) {
         return reply.send(snapshot);
     });
 }
+function isBoundedAudit(source) {
+    return !Array.isArray(source) && 'events' in source;
+}
+const auditLabels = {
+    'autopilot.continuation-scheduled': 'Autopilot scheduled a continuation',
+    'autopilot.control-issued': 'Autopilot issued an automatic continuation.',
+    'autopilot.turn-started': 'Autopilot continuation started',
+    'autopilot.turn-failed': 'Autopilot continuation failed',
+    'autopilot.progress-reset': 'Autopilot reset retry progress after the plan changed',
+    'org-plan.attention-required': 'Autopilot needs attention',
+    'org-plan.attention-resolved': 'Attention resolved',
+};
+function snapshotAuditLabel(payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const { state, reason } = payload;
+    if (state === 'backoff')
+        return 'Autopilot is backing off';
+    if (state === 'attentionRequired')
+        return 'Autopilot needs attention';
+    if (state === 'completed')
+        return 'Autopilot completed the plan';
+    if (state === 'disabled' && reason === 'planRequired')
+        return 'Autopilot requires an incomplete supervised plan';
+    return null;
+}
+/** Maps journal vocabulary to a deliberately redacted, durable timeline projection. */
+function toAutopilotAudit(events) {
+    return events.flatMap((event) => {
+        const occurredAt = Date.parse(event.occurredAt);
+        if (!Number.isFinite(occurredAt))
+            return [];
+        const label = event.type === 'org-plan.attention-resolved' &&
+            event.payload &&
+            typeof event.payload === 'object' &&
+            event.payload.outcome === 'failed'
+            ? 'Attention resolution failed'
+            : (auditLabels[event.type] ??
+                (event.type === 'autopilot.updated' ? snapshotAuditLabel(event.payload) : null));
+        if (!label)
+            return [];
+        const controlId = event.payload &&
+            typeof event.payload === 'object' &&
+            typeof event.payload.controlId === 'string'
+            ? event.payload.controlId
+            : undefined;
+        return [
+            { id: `audit:${event.sequence}`, label, occurredAt, ...(controlId ? { controlId } : {}) },
+        ];
+    });
+}

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

@@ -4,21 +4,21 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 /** Canonical grouping preserves the upstream Codex turn identity across reloads. */
-export function toChatTurns(turns) {
+export function toChatTurns(turns, autopilotControlTurns = new Map()) {
     return turns.map((turn, index) => {
         const turnId = turn.id ?? `history-turn-${index}`;
         return {
             id: turnId,
-            items: turn.items.flatMap((item) => toChatItem(item, occurredAt(item, turn), turnId)),
+            items: turn.items.flatMap((item) => toChatItem(item, occurredAt(item, turn), turnId, autopilotControlTurns)),
             startedAt: turn.startedAt,
             completedAt: turn.completedAt,
         };
     });
 }
-export function toChatItems(turns) {
-    return turns.flatMap((turn, index) => turn.items.flatMap((item) => toChatItem(item, occurredAt(item, turn), turn.id ?? `history-turn-${index}`)));
+export function toChatItems(turns, autopilotControlTurns = new Map()) {
+    return turns.flatMap((turn, index) => turn.items.flatMap((item) => toChatItem(item, occurredAt(item, turn), turn.id ?? `history-turn-${index}`, autopilotControlTurns)));
 }
-function toChatItem(item, timestamp, turnId) {
+function toChatItem(item, timestamp, turnId, autopilotControlTurns) {
     const owner = turnId ? { turnId } : {};
     return [item].flatMap((item) => {
         const id = typeof item.id === 'string' ? item.id : null;
@@ -26,6 +26,18 @@ function toChatItem(item, timestamp, turnId) {
             return [];
         switch (item.type) {
             case 'userMessage': {
+                if (typeof item.clientId === 'string' &&
+                    turnId !== undefined &&
+                    autopilotControlTurns.get(turnId) === item.clientId)
+                    return [
+                        {
+                            id,
+                            kind: 'autopilot',
+                            controlId: item.clientId,
+                            ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ];
                 const text = Array.isArray(item.content)
                     ? item.content
                         .filter(isRecord)

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

@@ -4,12 +4,14 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { buildResumeCommand } from '../application/resume-command.js';
-export function registerGetSession(app, find) {
+export function registerGetSession(app, find, activity, autopilot) {
     app.get('/api/sessions/:id', async (request, reply) => {
         const session = find(request.params.id);
         return session
             ? reply.send({
                 ...session,
+                ...(activity ? { agentActivity: activity(session.id) } : {}),
+                ...(autopilot ? { autopilot: autopilot(session.id) } : {}),
                 resumeCommand: session.threadId ? buildResumeCommand(session) : null,
             })
             : reply.code(404).send({ code: 'SESSION_NOT_FOUND' });

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

@@ -10,5 +10,6 @@ export function isInteractionKind(value) {
         'permissionsApproval',
         'userInput',
         'quiz',
+        'orgPlanAttention',
     ].includes(value);
 }

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

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { isQuizToolResponseForQuiz, parseQuiz } from '../../../../shared/contracts/quiz.js';
+import { isOrgPlanAttentionToolResponse, parseOrgPlanAttention, } from '../../../../shared/contracts/org-plan-attention.js';
 /** 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 === 'quiz')
+    if (kind === 'quiz' || kind === 'orgPlanAttention')
         return false;
     if (kind === 'permissionsApproval')
         return isRecord(value.permissions) && (value.scope === 'turn' || value.scope === 'session');
@@ -21,6 +22,9 @@ export function isValidQuizInteractionResponse(payload, value) {
     const quiz = parseQuiz(payload);
     return quiz !== null && isQuizToolResponseForQuiz(quiz, value);
 }
+export function isValidOrgPlanAttentionInteractionResponse(payload, value) {
+    return parseOrgPlanAttention(payload) !== null && isOrgPlanAttentionToolResponse(value);
+}
 function isValidUserInputResponse(value) {
     if (!isRecord(value.answers))
         return false;

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

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

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

@@ -75,6 +75,9 @@ export class RelaySession {
     bindThread(value, now) {
         return this.transition({ threadId: threadId(value), state: 'ready' }, 'ThreadBound', now);
     }
+    supportsAttentionTool(now) {
+        return this.transition({ attentionToolCapability: 'supported' }, 'AttentionToolRegistered', now);
+    }
     selectModel(value, now) {
         if (this.value.state !== 'ready')
             throw new DomainError('SESSION_NOT_READY');

package/dist/server/server/features/sessions/refresh-activity/endpoint.js

@@ -0,0 +1,14 @@
+/**
+ * The client session controller owns foreground and sequence-gap detection.
+ * On either signal it calls this idempotent boundary; replaying journal events
+ * alone is deliberately not treated as an authoritative activity reconciliation.
+ */
+export function registerRefreshActivity(app, deps) {
+    app.post('/api/sessions/:id/activity/refresh', async (request, reply) => {
+        const id = request.params.id;
+        if (!deps.exists(id))
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        await deps.refresh(id);
+        return reply.code(202).send({ accepted: true });
+    });
+}

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

@@ -20,6 +20,7 @@ import { registerSessionEvents } from './session-events/endpoint.js';
 import { registerStartSession } from './start-session/endpoint.js';
 import { registerStartTurn } from './start-turn/endpoint.js';
 import { registerStopSession } from './stop-session/endpoint.js';
+import { registerRefreshActivity } from './refresh-activity/endpoint.js';
 export function registerSessionRoutes(app, deps) {
     const sessions = deps.sessionRoutes;
     if (deps.recentThreads) {
@@ -46,15 +47,26 @@ export function registerSessionRoutes(app, deps) {
             ...sessions,
             reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
         });
-        registerGetSession(app, sessions.find);
+        registerGetSession(app, sessions.find, sessions.agentActivity, sessions.autopilotSnapshot);
+        if (sessions.refreshActivity)
+            registerRefreshActivity(app, {
+                exists: (id) => sessions.find(id) !== null,
+                refresh: sessions.refreshActivity,
+            });
         if (sessions.list)
-            registerListSessions(app, { list: sessions.list });
+            registerListSessions(app, {
+                list: sessions.list,
+                activity: sessions.agentActivity,
+                autopilot: sessions.autopilotSnapshot,
+            });
         if (sessions.readHistory)
             registerGetHistory(app, {
                 find: sessions.find,
                 read: sessions.readHistory,
                 currentSequence: sessions.currentSequence ?? (() => 0),
                 interactions: deps.interactions?.snapshot,
+                autopilotControlTurns: sessions.autopilotControlTurns,
+                autopilotAudit: sessions.autopilotAudit,
             });
         if (sessions.startTurn)
             registerStartTurn(app, {
@@ -80,6 +92,7 @@ export function registerSessionRoutes(app, deps) {
                 find: sessions.find,
                 restore: sessions.restore,
                 save: sessions.save,
+                ownsWriter: sessions.ownsWriter,
                 idempotency: sessions.idempotency,
             });
         if (deps.recentThreads && sessions.promoteRecent)

package/dist/server/server/features/sessions/respond-interaction/endpoint.js

@@ -18,8 +18,21 @@ export function registerRespondInteraction(app, deps) {
             return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
         if (deps.validate && !deps.validate(id, requestId, value))
             return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
-        if (!deps.reply(id, requestId, value))
-            return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        const delivery = deps.reply(id, requestId, value);
+        if (delivery === false || delivery === 'unavailable')
+            return reply.code(409).send({ code: 'INTERACTION_DELIVERY_UNAVAILABLE' });
+        if (delivery === 'cleared') {
+            const resolvedAt = deps.now();
+            const outcome = 'dismissed';
+            if (deps.resolve(id, requestId, resolvedAt, outcome)) {
+                deps.resolved?.(id, requestId, resolvedAt, outcome);
+                return reply.code(202).send({ accepted: true, resolvedAt, outcome });
+            }
+            const raced = deps.alreadyResolved?.(id, requestId);
+            return raced
+                ? reply.code(202).send({ accepted: true, ...raced })
+                : reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        }
         const resolvedAt = deps.now();
         const outcome = safeOutcome(value);
         if (!deps.resolve(id, requestId, resolvedAt, outcome))

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { idempotencyKey } from '../../../platform/http/idempotency.js';
-import { RelaySession } from '../model/relay-session.js';
+import { RelaySession, relayOwnsWriter } from '../model/relay-session.js';
 import { canRestore } from './use-case.js';
 export function registerRestoreSession(app, deps) {
     app.post('/api/sessions/:id/restore', async (request, reply) => {
@@ -17,8 +17,15 @@ export function registerRestoreSession(app, deps) {
         const session = deps.find(id);
         if (!session)
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
-        if (!canRestore(session))
+        // Opening an already live session is a safe no-op. It must not tear down or
+        // replace this relay's writer merely because a client retried Open while the
+        // session was becoming ready.
+        const staleWriter = relayOwnsWriter(session) && deps.ownsWriter?.(id) === false;
+        if (!canRestore(session) && !staleWriter) {
+            if (relayOwnsWriter(session))
+                return reply.send(session);
             return reply.code(409).send({ code: 'SESSION_CANNOT_RESTORE' });
+        }
         const recovering = RelaySession.rehydrate(session).beginRecovery(new Date().toISOString()).snapshot;
         deps.save(recovering);
         let restored;
@@ -28,7 +35,9 @@ export function registerRestoreSession(app, deps) {
         catch {
             // The pre-I/O recovery marker must never strand a saved session: keep
             // its original thread and inactive state available for a later Open.
-            deps.save(session);
+            deps.save(staleWriter
+                ? RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot
+                : session);
             return reply.code(502).send({ code: 'RESTORE_FAILED' });
         }
         const response = 'session' in restored
@@ -40,8 +49,15 @@ export function registerRestoreSession(app, deps) {
             }
             : restored;
         deps.save(response);
+        const settled = (response.state === 'ready' || response.state === 'turnActive') &&
+            deps.ownsWriter &&
+            !deps.ownsWriter(id)
+            ? RelaySession.rehydrate(response).stop(new Date().toISOString()).snapshot
+            : response;
+        if (settled !== response)
+            deps.save(settled);
         if (key)
-            deps.idempotency?.put(scope, key, 200, JSON.stringify(response));
-        return reply.send(response);
+            deps.idempotency?.put(scope, key, 200, JSON.stringify(settled));
+        return reply.send(settled);
     });
 }

package/dist/server/server/features/skills/list-available/endpoint.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { z } from 'zod';
-import { applySkillSelectionSnapshot } from '../model/skill-profile.js';
+import { applySkillSelectionSnapshot, isAlwaysAdvertisedSkill } from '../model/skill-profile.js';
 import { SkillProfileError } from '../model/errors.js';
 import { problem } from '../../../platform/http/problem.js';
 const querySchema = z
@@ -34,9 +34,7 @@ export function registerListAvailableSkills(app, deps) {
                     : deps.catalog.list(profile.name, workspace.realPath),
                 deps.selections.readWorkspaceDefault(workspace.realPath),
             ]);
-            const skills = project
-                ? applySkillSelectionSnapshot(discovered.skills, project.skills)
-                : discovered.skills;
+            const skills = applySkillSelectionSnapshot(discovered.skills, project?.skills);
             return {
                 source: project ? 'project' : 'native',
                 errors: discovered.errors.map(({ message }) => ({ message })),
@@ -57,6 +55,7 @@ export function registerListAvailableSkills(app, deps) {
                     scope: skill.scope,
                     nativeEnabled: discovered.skills.find((native) => native.path === skill.path)?.enabled ?? false,
                     effectiveEnabled: skill.enabled,
+                    alwaysAdvertised: isAlwaysAdvertisedSkill(skill),
                 })),
             };
         }

package/dist/server/server/features/skills/model/skill-profile.js

@@ -54,6 +54,10 @@ export const availableSkillSchema = z
     scope: z.string().optional(),
 })
     .strict();
+/** Gestalt workflow skills are session infrastructure, not optional profile entries. */
+export function isAlwaysAdvertisedSkill(skill) {
+    return skill.name.startsWith('gestalt:');
+}
 const profileDocumentSchema = z
     .object({
     version: z.literal(1),
@@ -135,7 +139,9 @@ export function createSkillSelection(entries) {
 /**
  * Apply an optional complete selection snapshot to a fresh catalog. Selection
  * entry names are never used for matching: canonical paths are the identity.
- * Without a snapshot, the catalog retains Codex-native enabled states.
+ * Gestalt-provider skills are always enabled so update-added infrastructure
+ * cannot disappear from a session catalog. Other skills retain native state
+ * when no snapshot exists.
  */
 export function applySkillSelectionSnapshot(discovered, selection) {
     const catalog = discovered.map((skill) => {
@@ -145,11 +151,13 @@ export function applySkillSelectionSnapshot(discovered, selection) {
         }
         return { ...parsed.data, path: canonicalSkillPath(parsed.data.path) };
     });
-    if (selection === undefined) {
-        return catalog;
-    }
+    if (selection === undefined)
+        return catalog.map((skill) => isAlwaysAdvertisedSkill(skill) ? { ...skill, enabled: true } : skill);
     const enabledByPath = new Map(createSkillSelection(selection).map((entry) => [entry.path, entry.enabled]));
-    return catalog.map((skill) => ({ ...skill, enabled: enabledByPath.get(skill.path) ?? false }));
+    return catalog.map((skill) => ({
+        ...skill,
+        enabled: isAlwaysAdvertisedSkill(skill) ? true : (enabledByPath.get(skill.path) ?? false),
+    }));
 }
 /** Explicit session selection takes precedence over a workspace default. */
 export function selectEffectiveSkillSelection(input) {

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const id = (value) => typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : undefined;
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : undefined;
+/** Decodes only bounded app-server evidence; unsupported shapes deliberately become no fact. */
+export function decodeAgentActivityFact(sessionId, occurredAt, input) {
+    const params = record(input.params);
+    if (!params)
+        return null;
+    if (input.method === 'thread/started') {
+        const thread = record(params.thread);
+        const status = record(thread?.status);
+        return id(thread?.id)
+            ? {
+                sessionId,
+                occurredAt,
+                kind: 'threadStarted',
+                threadId: id(thread?.id),
+                ...(typeof status?.type === 'string' ? { status: status.type } : {}),
+            }
+            : null;
+    }
+    if (input.method === 'thread/status/changed') {
+        const status = record(params.status);
+        return id(params.threadId) && typeof status?.type === 'string' && status.type.length <= 64
+            ? {
+                sessionId,
+                occurredAt,
+                kind: 'threadStatus',
+                threadId: id(params.threadId),
+                status: status.type,
+            }
+            : null;
+    }
+    if (input.method === 'turn/started')
+        return id(params.threadId)
+            ? {
+                sessionId,
+                occurredAt,
+                kind: 'turnStarted',
+                threadId: id(params.threadId),
+                turnId: id(record(params.turn)?.id),
+            }
+            : null;
+    if (input.method === 'turn/completed')
+        return id(record(params.turn)?.id)
+            ? {
+                sessionId,
+                occurredAt,
+                kind: 'turnCompleted',
+                threadId: id(params.threadId),
+                turnId: id(record(params.turn)?.id),
+                status: typeof record(params.turn)?.status === 'string'
+                    ? record(params.turn)?.status
+                    : undefined,
+            }
+            : null;
+    if (input.method === 'item/started' || input.method === 'item/completed') {
+        const item = record(params.item);
+        if (item?.type !== 'collabToolCall')
+            return null;
+        const action = typeof item.tool === 'string' &&
+            ['spawn_agent', 'send_input', 'resume_agent', 'wait', 'close_agent'].includes(item.tool)
+            ? item.tool
+            : undefined;
+        const child = id(item.receiverThreadId) ?? id(item.newThreadId);
+        const itemStatus = typeof item.status === 'string' && item.status.length <= 64 ? item.status : undefined;
+        return {
+            sessionId,
+            occurredAt,
+            kind: 'collaboration',
+            ...(child ? { childId: child, childThreadId: child } : {}),
+            ...(id(item.senderThreadId) ? { threadId: id(item.senderThreadId) } : {}),
+            ...(typeof item.agentStatus === 'string' && item.agentStatus.length <= 64
+                ? { childStatus: item.agentStatus }
+                : itemStatus
+                    ? { childStatus: itemStatus }
+                    : {}),
+            ...(action ? { collaborationAction: action } : {}),
+        };
+    }
+    return null;
+}

package/dist/server/server/platform/codex/server-request.js

@@ -4,14 +4,22 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { GESTALT_QUIZ_TOOL_NAME, parseQuiz } from '../../../shared/contracts/quiz.js';
+import { GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME, parseOrgPlanAttention, } from '../../../shared/contracts/org-plan-attention.js';
 export function toPendingInteraction(input) {
     if (!Number.isSafeInteger(input.id) || !isRecord(input.params))
         return null;
     if (input.method === 'item/tool/call') {
-        if (!isRecord(input.params) || input.params.tool !== GESTALT_QUIZ_TOOL_NAME)
-            return null;
-        const quiz = parseQuiz(input.params.arguments);
-        return quiz ? { requestId: String(input.id), kind: 'quiz', payload: quiz } : null;
+        if (input.params.tool === GESTALT_QUIZ_TOOL_NAME) {
+            const quiz = parseQuiz(input.params.arguments);
+            return quiz ? { requestId: String(input.id), kind: 'quiz', payload: quiz } : null;
+        }
+        if (input.params.tool === GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME) {
+            const attention = parseOrgPlanAttention(input.params.arguments);
+            return attention
+                ? { requestId: String(input.id), kind: 'orgPlanAttention', payload: attention }
+                : null;
+        }
+        return null;
     }
     const kind = {
         'item/commandExecution/requestApproval': 'commandApproval',
@@ -21,6 +29,15 @@ export function toPendingInteraction(input) {
     }[input.method];
     return kind ? { requestId: String(input.id), kind, payload: input.params } : null;
 }
+export function resolvedServerRequestId(input) {
+    if (input.method !== 'serverRequest/resolved' || !isRecord(input.params))
+        return null;
+    const requestId = input.params.requestId;
+    if (!((typeof requestId === 'string' && requestId.length > 0 && requestId.length <= 256) ||
+        (typeof requestId === 'number' && Number.isSafeInteger(requestId))))
+        return null;
+    return String(requestId);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }