@cydm/happy-elves 0.1.0-beta.504 → 0.1.0-beta.506

package/README.md

@@ -6,8 +6,8 @@ Public beta CLI for Happy Elves.
 
 Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
 
-    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.504
-    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.504 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.506
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.506 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
 
 The same updater entrypoint works on macOS after selecting a permanent user prefix.
 

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.504",
+  "version": "0.1.0-beta.506",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/direct/server.js

@@ -395,6 +395,8 @@ class DirectState {
             return this.machineScoped(message, "machine:dispatch", connection);
         if (message.type === "controller:queue")
             return this.machineScoped(message, "machine:queue", connection);
+        if (message.type === "controller:followup")
+            return this.machineScoped(message, "machine:followup", connection);
         if (message.type === "controller:crewQueueEnqueue")
             return this.machineScoped(message, "machine:crewQueueEnqueue", connection);
         if (message.type === "controller:crewQueueUpdate")

package/apps/daemon/dist/orchestration/crew-queue.js

@@ -298,7 +298,9 @@ async function completeMaterializedCrewQueueHead(config, queue) {
         .find((record) => record.crewSessionId === queue.crewSessionId && (record.crewMachineId ?? queue.crewMachineId) === queue.crewMachineId);
     if (!head)
         return "none";
-    const turnId = head.turnId ?? stableId("turn", head.taskId, head.requestId, "brief");
+    // Follow-ups carry the caller's stable queued turn identity before delivery;
+    // recovery must use it to find a runtime turn created just before a crash.
+    const turnId = head.turnId ?? (head.kind === "followup" ? head.queuedTurnId : undefined) ?? stableId("turn", head.taskId, head.requestId, "brief");
     const runtimeTurnId = head.runtimeTurnId ?? head.providerTurnId ?? await runtimeTurnIdForCrewTurn(queue.crewSessionId, turnId);
     if (!runtimeTurnId)
         return "none";

package/apps/daemon/dist/orchestration/handler.d.ts

@@ -7,6 +7,9 @@ type DispatchCommand = Extract<MachineCommand, {
 type QueueCommand = Extract<MachineCommand, {
     type: "machine:queue";
 }>;
+type FollowUpCommand = Extract<MachineCommand, {
+    type: "machine:followup";
+}>;
 export type DispatchListCommand = Extract<DispatchCommand, {
     action: "list";
 }>;
@@ -17,6 +20,7 @@ export type DispatchListResult = {
 };
 export declare function handleDispatchCommand(ws: WebSocket, config: DaemonConfig, command: DispatchCommand): Promise<void>;
 export declare function handleQueueCommand(ws: WebSocket, config: DaemonConfig, command: QueueCommand): Promise<void>;
+export declare function handleFollowUpCommand(ws: WebSocket, config: DaemonConfig, command: FollowUpCommand): Promise<void>;
 export declare function dispatchListResultForCommand(config: DaemonConfig, command: DispatchListCommand): Promise<DispatchListResult>;
 export declare function remoteLoadedSessionInventory(config: DaemonConfig, machineId: string, filters?: {
     cwd?: string;

package/apps/daemon/dist/orchestration/handler.js

@@ -8,7 +8,7 @@ import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
 import { runtimeRead, runtimeSessionCheckpoint, runtimeTurnSummaryForTask } from "../session/runtime-truth.js";
 import { loadSessionProjections } from "../session/store.js";
 import { listArtifacts } from "../artifact/store.js";
-import { ackAttention, completeClaimedQueueAdmission, crewQueueHasBacklog, deadAttention, failClaimedQueueAdmission, findAdmissionByTask, findAdmissionByTaskAndRequest, latestAttentionForTask, listAdmissions, listAttentions, recordAdmission, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, retryAttention, retryClaimedQueueAdmission, runtimeTurnIdForCrewTurn, updateAdmission, updatePendingConsumerQueueEnqueue, upsertSubscription, } from "./store.js";
+import { ackAttention, completeClaimedQueueAdmission, crewQueueHasBacklog, deadAttention, failClaimedQueueAdmission, findAdmissionByTask, findAdmissionByTaskAndRequest, latestAttentionForTask, listAdmissions, listAttentions, recordAdmission, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, retryAttention, retryClaimedQueueAdmission, runtimeTurnIdForCrewTurn, updateAdmission, updatePendingConsumerQueueEnqueue, cancelQueuedFollowUp, findFollowUpById, listFollowUpsForSession, upsertSubscription, } from "./store.js";
 import { catchUpSubscriptionEvents } from "./watcher.js";
 export async function handleDispatchCommand(ws, config, command) {
     // Status/list are read projections, not mutation retries. A caller may use
@@ -466,6 +466,161 @@ export async function handleQueueCommand(ws, config, command) {
         });
     }
 }
+export async function handleFollowUpCommand(ws, config, command) {
+    // Follow-up request IDs are scoped to this command contract. Never let the
+    // generic 24h response cache bypass target/session/payload validation (or
+    // replay a response from another command using the same correlation id).
+    completedCommandResponses.delete(command.requestId);
+    if (command.machineId !== config.machineId) {
+        await sendCommandResponse(ws, { type: "machine:error", requestId: command.requestId, code: "WRONG_MACHINE", message: `Follow-up command targeted ${command.machineId}, not ${config.machineId}` });
+        return;
+    }
+    const reply = async (result) => {
+        await sendCommandResponse(ws, { type: "machine:followupResult", requestId: command.requestId, machineId: config.machineId, result });
+    };
+    if (command.action === "list" || command.action === "cancel") {
+        const session = await ensureSessionLoaded(command.sessionId);
+        if (!session) {
+            await sendCommandResponse(ws, {
+                type: "machine:error",
+                requestId: command.requestId,
+                code: "SESSION_NOT_FOUND",
+                capability: `followup.${command.action}`,
+                message: `Session ${command.sessionId} is not loaded on this daemon`,
+            });
+            return;
+        }
+    }
+    if (command.action === "list" || command.action === "cancel") {
+        if (!claimCommandRequest(ws, command.requestId))
+            return;
+    }
+    if (command.action === "list") {
+        const records = await listFollowUpsForSession(command.sessionId);
+        await reply({ action: "list", requestId: command.requestId, sessionId: command.sessionId, records: await Promise.all(records.map((record) => followUpQueueRecord(config, record))) });
+        return;
+    }
+    if (command.action === "cancel") {
+        const outcome = await cancelQueuedFollowUp(command.sessionId, command.followUpId);
+        if (outcome.status === "missing") {
+            await reply({ action: "cancel", requestId: command.requestId, sessionId: command.sessionId, followUpId: command.followUpId, cancelled: false, conflict: "Follow-up was not found" });
+            return;
+        }
+        if (outcome.status === "conflict") {
+            await reply({ action: "cancel", requestId: command.requestId, sessionId: command.sessionId, followUpId: command.followUpId, cancelled: false, conflict: "Follow-up is already being delivered", ...(outcome.record ? { followUp: await followUpQueueRecord(config, outcome.record) } : {}) });
+            return;
+        }
+        await reply({ action: "cancel", requestId: command.requestId, sessionId: command.sessionId, followUpId: command.followUpId, cancelled: true, ...(outcome.record ? { followUp: await followUpQueueRecord(config, outcome.record) } : {}) });
+        return;
+    }
+    const session = await ensureSessionLoaded(command.sessionId);
+    if (!session) {
+        await sendCommandResponse(ws, { type: "machine:error", requestId: command.requestId, code: "SESSION_NOT_FOUND", capability: "followup.enqueue", message: `Session ${command.sessionId} is not loaded on this daemon` });
+        return;
+    }
+    const existing = await findFollowUpById(command.sessionId, command.followUpId);
+    if (existing) {
+        const samePayload = existing.encryptedBrief
+            ? await sameFollowUpPayload(config, existing.encryptedBrief, command.encryptedPrompt)
+            : false;
+        const existingTurnId = existing.queuedTurnId ?? existing.turnId;
+        // Optional follow-up fields have protocol defaults. A caller replaying a
+        // request may omit them after the first attempt; compare the normalized
+        // execution instead of treating an omitted default as a conflict. A
+        // supplied turn id remains an explicit identity check, while an omitted
+        // turn id is intentionally compatible with the owner-assigned id.
+        const sameExecution = existing.requestId === command.requestId &&
+            samePayload &&
+            (command.turnId === undefined || existingTurnId === command.turnId) &&
+            (existing.permissionMode ?? "approve-reads") === crewTurnPermissionMode(command.permissionMode) &&
+            (existing.model ?? undefined) === (command.model ?? undefined) &&
+            (existing.thinkingLevel ?? undefined) === (command.thinkingLevel ?? undefined);
+        if (!sameExecution) {
+            await sendCommandResponse(ws, { type: "machine:error", requestId: command.requestId, code: "FOLLOWUP_IDEMPOTENCY_CONFLICT", capability: "followup.enqueue", message: `Follow-up ${command.followUpId} already exists with different content or request id` });
+            return;
+        }
+        if (!claimCommandRequest(ws, command.requestId))
+            return;
+        const { signalCrewQueue } = await import("./crew-queue.js");
+        void signalCrewQueue(config, { crewMachineId: config.machineId, crewSessionId: command.sessionId, reason: "admission" }).catch(() => undefined);
+        await reply({ action: "enqueue", requestId: command.requestId, followUp: await followUpQueueRecord(config, existing), replayed: true });
+        return;
+    }
+    if (!claimCommandRequest(ws, command.requestId))
+        return;
+    const now = new Date().toISOString();
+    const record = await recordAdmission({
+        kind: "followup",
+        followUpId: command.followUpId,
+        followUpStatus: "queued",
+        ...(command.turnId ? { queuedTurnId: command.turnId } : {}),
+        taskId: stableId("followup", command.sessionId, command.followUpId),
+        requestId: command.requestId,
+        consumerMachineId: config.machineId,
+        crewMachineId: config.machineId,
+        consumerSessionId: command.sessionId,
+        crewSessionId: command.sessionId,
+        agent: session.agent,
+        cwd: session.cwd,
+        briefVersion: 1,
+        admission: "accepted",
+        dispatch: "queued",
+        routeDecision: { kind: "reuse", crewSessionId: command.sessionId, ifBusy: "queue" },
+        queuedAt: now,
+        queueAuthority: "owner",
+        encryptedBrief: command.encryptedPrompt,
+        permissionMode: crewTurnPermissionMode(command.permissionMode),
+        model: command.model,
+        thinkingLevel: command.thinkingLevel,
+        subscribe: false,
+        queueAttempts: 0,
+        createdAt: now,
+        updatedAt: now,
+    });
+    if (record.requestId !== command.requestId) {
+        await sendCommandResponse(ws, { type: "machine:error", requestId: command.requestId, code: "FOLLOWUP_IDEMPOTENCY_CONFLICT", capability: "followup.enqueue", message: `Follow-up ${command.followUpId} already exists with a different request id` });
+        return;
+    }
+    const { signalCrewQueue } = await import("./crew-queue.js");
+    void signalCrewQueue(config, { crewMachineId: config.machineId, crewSessionId: command.sessionId, reason: "admission" }).catch(() => undefined);
+    await reply({ action: "enqueue", requestId: command.requestId, followUp: await followUpQueueRecord(config, record) });
+}
+async function sameFollowUpPayload(config, left, right) {
+    try {
+        const [leftPayload, rightPayload] = await Promise.all([
+            decryptJson(config.accountSecret, left),
+            decryptJson(config.accountSecret, right),
+        ]);
+        return JSON.stringify(leftPayload) === JSON.stringify(rightPayload);
+    }
+    catch {
+        return false;
+    }
+}
+async function followUpQueueRecord(config, record) {
+    let text;
+    if (record.encryptedBrief) {
+        try {
+            const payload = await decryptJson(config.accountSecret, record.encryptedBrief);
+            if (payload.type === "user_prompt")
+                text = payload.text;
+        }
+        catch { /* encrypted content is optional in projection */ }
+    }
+    return {
+        id: record.followUpId ?? record.taskId,
+        requestId: record.requestId,
+        sessionId: record.consumerSessionId,
+        machineId: record.crewMachineId ?? config.machineId,
+        status: record.followUpStatus ?? (record.dispatch === "delivered" ? "delivered" : record.dispatch === "failed" ? "failed" : "queued"),
+        ...(record.turnId ? { turnId: record.turnId } : {}),
+        ...(text !== undefined ? { text } : {}),
+        createdAt: record.createdAt,
+        ...(record.dispatch === "delivered" ? { deliveredAt: record.updatedAt } : {}),
+        ...(record.errorCode ? { errorCode: record.errorCode } : {}),
+        ...(record.error ? { error: record.error } : {}),
+    };
+}
 export async function dispatchListResultForCommand(config, command) {
     const admissions = await listAdmissions({ consumerSessionId: command.consumerSessionId });
     const records = await Promise.all(admissions.map((admission) => dispatchTaskProjection(config, admission)));
@@ -772,6 +927,8 @@ export async function deliverQueuedCrewAdmission(config, admission) {
     const claimId = admission.queuedClaim?.claimId;
     if (!claimId)
         return admission;
+    if (admission.kind === "followup")
+        return await deliverQueuedFollowUpAdmission(config, admission);
     if (!crewSessionId || !admission.encryptedBrief) {
         const errorCode = "QUEUED_DISPATCH_INVALID";
         const error = !crewSessionId ? "Queued admission is missing crewSessionId" : "Queued admission is missing encrypted brief";
@@ -863,6 +1020,43 @@ export async function deliverQueuedCrewAdmission(config, admission) {
     }
     return delivered;
 }
+async function deliverQueuedFollowUpAdmission(config, admission) {
+    const claimId = admission.queuedClaim?.claimId;
+    const sessionId = admission.crewSessionId;
+    if (!claimId || !sessionId || !admission.encryptedBrief)
+        return admission;
+    const state = await crewSessionRuntimeState(config, config.machineId, sessionId);
+    if (state.availability === "busy") {
+        return await retryClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, error: "target Crew is still busy", queueReason: "target-crew-busy", retryAfterMs: 30_000 }) ?? admission;
+    }
+    if (state.availability === "unavailable") {
+        if (state.retryable)
+            return await retryClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, error: state.error ?? "Crew unavailable", queueReason: "target-crew-unavailable", retryAfterMs: queueRetryDelayMs(admission.queueAttempts ?? 1) }) ?? admission;
+        return (await failClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, errorCode: state.errorCode ?? "CREW_SESSION_UNAVAILABLE", error: state.error ?? "Crew session unavailable" })).admission ?? admission;
+    }
+    const turnId = admission.turnId ?? admission.queuedTurnId ?? stableId("followup-turn", sessionId, admission.followUpId ?? admission.taskId);
+    const promptRequestId = stableId("followup-prompt", admission.requestId, sessionId);
+    try {
+        await admitMachinePrompt(config, {
+            requestId: promptRequestId,
+            sessionId,
+            turnId,
+            encryptedPrompt: admission.encryptedBrief,
+            permissionMode: admission.permissionMode ?? "approve-reads",
+            ...(admission.model ? { model: admission.model } : {}),
+            ...(admission.thinkingLevel ? { thinkingLevel: admission.thinkingLevel } : {}),
+        });
+        return await completeClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, turnId }) ?? admission;
+    }
+    catch (error) {
+        const code = dispatchErrorCode(error);
+        const message = error instanceof Error ? error.message : String(error);
+        if (queueDeliveryErrorDisposition(code) === "permanent") {
+            return (await failClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, errorCode: code, error: message })).admission ?? admission;
+        }
+        return await retryClaimedQueueAdmission({ taskId: admission.taskId, requestId: admission.requestId, claimId, error: message, queueReason: "delivery-retry", retryAfterMs: queueRetryDelayMs(admission.queueAttempts ?? 1) }) ?? admission;
+    }
+}
 async function deliverDispatch(config, command, admission, options = {}) {
     const crewSessionId = admission.crewSessionId ?? stableId("ses", admission.taskId, admission.requestId, "crew");
     const turnId = admission.turnId ?? stableId("turn", admission.taskId, admission.requestId, "brief");

package/apps/daemon/dist/orchestration/queue-state.js

@@ -125,6 +125,7 @@ export function retryClaimedQueueAdmissionRecord(record, input) {
     return {
         ...record,
         dispatch: "queued",
+        ...(record.kind === "followup" ? { followUpStatus: "queued" } : {}),
         turnId: undefined,
         subscriptionCursor: undefined,
         runtimeTurnId: undefined,
@@ -144,6 +145,7 @@ export function failClaimedQueueAdmissionRecord(record, input) {
     return {
         ...record,
         dispatch: "failed",
+        ...(record.kind === "followup" ? { followUpStatus: "failed" } : {}),
         queuedClaim: undefined,
         nextAttemptAt: undefined,
         lastQueueError: input.error,
@@ -156,6 +158,7 @@ function completeQueuedAdmissionRecord(record, input) {
     return {
         ...record,
         dispatch: "delivered",
+        ...(record.kind === "followup" ? { followUpStatus: "delivered" } : {}),
         turnId: input.turnId,
         subscriptionCursor: input.subscriptionCursor,
         runtimeTurnId: input.runtimeTurnId,

package/apps/daemon/dist/orchestration/store.d.ts

@@ -1,5 +1,9 @@
 import type { DispatchAdmissionRecord, EncryptedEnvelope, PermissionMode, TaskAttentionEventType, TaskAttentionPayloadRef, TaskAttentionRecord, TaskAttentionStatus } from "../../../../packages/shared/dist/index.js";
 export type StoredDispatchAdmissionRecord = DispatchAdmissionRecord & {
+    kind?: "dispatch" | "followup";
+    followUpId?: string;
+    followUpStatus?: "queued" | "delivered" | "failed" | "cancelled";
+    queuedTurnId?: string;
     dispatchRequestId?: string;
     queueAuthority?: "owner" | "consumer";
     encryptedBrief?: EncryptedEnvelope;
@@ -131,6 +135,12 @@ export declare function readOrchestrationStore(): Promise<OrchestrationStore>;
 export declare function updateOrchestrationStore(update: (store: OrchestrationStore) => OrchestrationStore | Promise<OrchestrationStore>): Promise<OrchestrationStore>;
 export declare function findAdmissionByTaskAndRequest(taskId: string, requestId: string): Promise<StoredDispatchAdmissionRecord | undefined>;
 export declare function findAdmissionByTask(taskId: string): Promise<StoredDispatchAdmissionRecord | undefined>;
+export declare function findFollowUpById(sessionId: string, followUpId: string): Promise<StoredDispatchAdmissionRecord | undefined>;
+export declare function listFollowUpsForSession(sessionId: string): Promise<StoredDispatchAdmissionRecord[]>;
+export declare function cancelQueuedFollowUp(sessionId: string, followUpId: string): Promise<{
+    status: "cancelled" | "missing" | "conflict";
+    record?: StoredDispatchAdmissionRecord;
+}>;
 export declare function findAdmissionByCrewTurn(crewSessionId: string, turnId: string): Promise<StoredDispatchAdmissionRecord | undefined>;
 export declare function runtimeTurnIdForCrewTurn(crewSessionId: string, turnId: string | undefined): Promise<string | undefined>;
 export declare function listAdmissions(input?: {

package/apps/daemon/dist/orchestration/store.js

@@ -29,6 +29,41 @@ export async function findAdmissionByTask(taskId) {
     const store = await readOrchestrationStore();
     return latestAdmission(store.admissions.filter((record) => record.taskId === taskId));
 }
+export async function findFollowUpById(sessionId, followUpId) {
+    const store = await readOrchestrationStore();
+    return store.admissions.find((record) => record.kind === "followup" && record.consumerSessionId === sessionId && record.followUpId === followUpId);
+}
+export async function listFollowUpsForSession(sessionId) {
+    const store = await readOrchestrationStore();
+    return store.admissions
+        // Keep delivered records queryable until transcript history has caught up.
+        // The Web projection removes them after the exact user_prompt echo, but a
+        // closed/reloaded page must still be able to reconcile the durable result.
+        .filter((record) => record.kind === "followup" && record.consumerSessionId === sessionId && (record.dispatch === "queued" ||
+        record.dispatch === "delivered" ||
+        record.followUpStatus === "failed" ||
+        record.followUpStatus === "cancelled"))
+        .sort((left, right) => (left.queueOrdinal ?? Number.MAX_SAFE_INTEGER) - (right.queueOrdinal ?? Number.MAX_SAFE_INTEGER) || left.createdAt.localeCompare(right.createdAt));
+}
+export async function cancelQueuedFollowUp(sessionId, followUpId) {
+    let result = { status: "missing" };
+    await updateOrchestrationStore((current) => {
+        const index = current.admissions.findIndex((record) => record.kind === "followup" && record.consumerSessionId === sessionId && record.followUpId === followUpId);
+        if (index < 0)
+            return current;
+        const previous = current.admissions[index];
+        if (previous.dispatch !== "queued" || previous.queuedClaim) {
+            result = { status: "conflict", record: previous };
+            return current;
+        }
+        const now = new Date().toISOString();
+        const next = { ...previous, dispatch: "failed", followUpStatus: "cancelled", errorCode: "FOLLOWUP_CANCELLED", error: "Follow-up cancelled before delivery", updatedAt: now };
+        current.admissions[index] = next;
+        result = { status: "cancelled", record: next };
+        return current;
+    });
+    return result;
+}
 export async function findAdmissionByCrewTurn(crewSessionId, turnId) {
     const store = await readOrchestrationStore();
     return latestAdmission(store.admissions.filter((record) => record.crewSessionId === crewSessionId && record.turnId === turnId));
@@ -424,13 +459,17 @@ export async function ownerCrewQueuePromptGate(input) {
         .find((record) => admissionMatchesCrew(record, input));
     if (!head)
         return { allowed: true };
-    const expectedPromptRequestId = stableId("req", head.taskId, head.requestId, "prompt");
+    const expectedPromptRequestId = head.kind === "followup"
+        ? stableId("followup-prompt", head.requestId, input.crewSessionId)
+        : stableId("req", head.taskId, head.requestId, "prompt");
     const leaseUntil = head.queuedClaim?.leaseUntil ? Date.parse(head.queuedClaim.leaseUntil) : NaN;
     const validClaim = Boolean(head.queuedClaim?.claimId) && Number.isFinite(leaseUntil) && leaseUntil > now.getTime();
     if (validClaim && input.promptRequestId === expectedPromptRequestId)
         return { allowed: true };
     if (input.promptRequestId === expectedPromptRequestId) {
-        const expectedTurnId = stableId("turn", head.taskId, head.requestId, "brief");
+        const expectedTurnId = head.kind === "followup"
+            ? stableId("followup-turn", input.crewSessionId, head.followUpId ?? head.taskId)
+            : stableId("turn", head.taskId, head.requestId, "brief");
         if (await runtimeTurnIdForCrewTurn(input.crewSessionId, expectedTurnId))
             return { allowed: true };
     }
@@ -569,6 +608,7 @@ export async function failQueuedCrewBacklog(input) {
             const admission = withOwnerQueueRevision(current, {
                 ...previous,
                 dispatch: "failed",
+                ...(previous.kind === "followup" ? { followUpStatus: "failed" } : {}),
                 queuedClaim: undefined,
                 nextAttemptAt: undefined,
                 lastQueueError: input.error,
@@ -612,8 +652,16 @@ async function updateClaimedQueueAdmission(input, transition) {
     return result;
 }
 export async function recordAdmission(record) {
+    let conflictRecord;
     const store = await updateOrchestrationStore((current) => {
-        const index = current.admissions.findIndex((item) => item.taskId === record.taskId && item.requestId === record.requestId);
+        let index = current.admissions.findIndex((item) => item.taskId === record.taskId && item.requestId === record.requestId);
+        if (index < 0 && record.kind === "followup" && record.followUpId) {
+            index = current.admissions.findIndex((item) => item.kind === "followup" && item.followUpId === record.followUpId && item.consumerSessionId === record.consumerSessionId);
+            if (index >= 0) {
+                conflictRecord = current.admissions[index];
+                return current;
+            }
+        }
         if (index >= 0) {
             const next = normalizeQueuedStoreFields(current, { ...current.admissions[index], ...record, updatedAt: record.updatedAt }, false);
             current.admissions[index] = next;
@@ -626,7 +674,7 @@ export async function recordAdmission(record) {
         }
         return current;
     });
-    return store.admissions.find((item) => item.taskId === record.taskId && item.requestId === record.requestId) ?? record;
+    return conflictRecord ?? store.admissions.find((item) => item.taskId === record.taskId && item.requestId === record.requestId) ?? record;
 }
 export async function updateAdmission(taskId, requestId, patch) {
     const updatedAt = new Date().toISOString();

package/apps/daemon/dist/relay/connection.js

@@ -4,7 +4,7 @@ import { drainPendingArtifactFeedbackAttentions, handleArtifactCommand } from ".
 import { handleGatewayCommand } from "../gateway/handler.js";
 import { tickLoops } from "../loop/runner.js";
 import { handleMemoryCommand } from "../memory/handler.js";
-import { handleDispatchCommand, handleQueueCommand } from "../orchestration/handler.js";
+import { handleDispatchCommand, handleFollowUpCommand, handleQueueCommand } from "../orchestration/handler.js";
 import { handleCrewQueueEnqueueCommand, handleCrewQueueUpdateCommand, recoverCrewQueues } from "../orchestration/crew-queue.js";
 import { tickOrchestration } from "../orchestration/runner.js";
 import { handleScheduleCommand } from "../schedule/handler.js";
@@ -160,6 +160,10 @@ export async function handleServerMessage(ws, config, message) {
         await handleQueueCommand(ws, config, message);
         return;
     }
+    if (message.type === "machine:followup") {
+        await handleFollowUpCommand(ws, config, message);
+        return;
+    }
     if (message.type === "machine:crewQueueEnqueue") {
         await handleCrewQueueEnqueueCommand(ws, config, message);
         return;
@@ -491,6 +495,8 @@ async function machineCommandFromController(ws, config, message, senderNodeId) {
         return { ...message, type: "machine:dispatch" };
     if (message.type === "controller:queue")
         return { ...message, type: "machine:queue" };
+    if (message.type === "controller:followup")
+        return { ...message, type: "machine:followup" };
     if (message.type === "controller:crewQueueEnqueue") {
         if (senderNodeId !== message.consumerMachineId) {
             await sendCommandResponse(ws, {

package/apps/daemon/dist/relay/send.js

@@ -23,6 +23,7 @@ const criticalMessageTypes = new Set([
     "machine:dispatchResult",
     "machine:crewQueueUpdateApplied",
     "machine:queueResult",
+    "machine:followupResult",
     "machine:artifactResult",
     "machine:turnReconciled",
     "machine:error",

package/apps/daemon/dist/runtime/headless-event-projector.js

@@ -900,18 +900,20 @@ export function historicalEventsFromThread(items, turns, limit, runtimeEvents =
         if (event)
             addEvent(event);
     }
-    for (const runtimeEvent of runtimeEvents) {
-        const event = userMessageHistoricalEventFromRuntimeEvent(runtimeEvent);
-        if (event)
-            addEvent(event);
-    }
+    // The canonical item projection is authoritative for text, including user
+    // prompts. Do not add user-message snapshots back from the append-only log:
+    // a native-history reconciliation can deliberately remove stale HE item
+    // identities, and replaying those raw events here would resurrect them in
+    // the rebuilt transcript. Forward/anchored reads still use
+    // historicalEventsFromRuntimeEvents, where the append-only log is the
+    // authority until a canonical rebuild is requested.
     // Server requests and provider/HE tool calls are not guaranteed to be
     // represented by canonical ThreadItems. Preserve only those non-text
     // runtime events which are absent from the canonical identity set. Text
     // snapshots remain canonical-only: merging them would resurrect the raw
     // assistant history that the rebuild deliberately replaces.
     for (const event of historicalEventsFromRuntimeEvents(runtimeEvents)) {
-        if (event.payload.type === "text_delta" || event.payload.type === "done")
+        if (event.payload.type === "user_prompt" || event.payload.type === "text_delta" || event.payload.type === "done")
             continue;
         if (event.payload.type === "tool_call" && runtimeEventMatchesCanonicalItem(event, canonicalToolItemIds, canonicalToolCallIds))
             continue;

package/apps/daemon/dist/session/he-official/common.d.ts

@@ -264,6 +264,12 @@ export declare function messageResult(message: MachineClientMessage | undefined,
             requestId: string;
             machineId: string;
             result: import("../../../../../packages/shared/dist/index.js").QueueCommandResult;
+        } | {
+            type: "machine:followupResult";
+            requestId: string;
+            machineId: string;
+            messageId?: string;
+            result: import("../../../../../packages/shared/dist/index.js").FollowUpQueueResult;
         } | {
             type: "machine:artifactResult";
             requestId: string;

package/apps/daemon/dist/session/prompt.d.ts

@@ -4,6 +4,14 @@ type PromptCommand = Extract<MachineCommand, {
     type: "machine:prompt";
 }>;
 type PromptExecutionPhase = "decrypt-prompt" | "prepare-attachments" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "prepare-first-agent-context" | "start-turn" | "attach-turn" | "persist-runtime-start" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "mark-terminal-pending" | "send-turn-done" | "mark-terminal-enqueued" | "terminal-hooks";
+type PromptExecutionBoundaries = {
+    daemonAcceptedAt: number;
+    providerStartAt?: number;
+    providerAcceptedAt?: number;
+    providerTurnId?: string;
+    providerTerminalAt?: number;
+    terminalEventAt?: number;
+};
 export declare function handlePrompt(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleSteerTurn(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleOptionResponse(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
@@ -14,13 +22,14 @@ export declare function promptFailureResponse(command: PromptCommand, phase: Pro
     code: string;
     message: string;
 };
-export declare function promptFailureAuditEvent(config: Pick<DaemonConfig, "machineId">, command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+export declare function promptFailureAuditEvent(config: Pick<DaemonConfig, "machineId">, command: PromptCommand, phase: PromptExecutionPhase, error: unknown, boundaries?: PromptExecutionBoundaries): {
     sessionId: string;
     machineId: string;
     actor: "system";
     action: string;
     summary: string;
     evidence: {
+        boundaries?: PromptExecutionBoundaries | undefined;
         requestId: string;
         turnId: string;
         code: string;

package/apps/daemon/dist/session/prompt.js

@@ -191,6 +191,7 @@ export async function handlePrompt(ws, config, command) {
     let turnReleased = false;
     let terminalNotification = false;
     let terminalNotified = false;
+    const boundaries = { daemonAcceptedAt: Date.now() };
     const releasePromptTurn = () => {
         if (turnReleased)
             return;
@@ -298,6 +299,7 @@ export async function handlePrompt(ws, config, command) {
         const runtimePrompt = await prepareRuntimePromptForSession(config, session, prompt, memoryContext.text);
         const runtimeText = runtimePrompt.text;
         phase = "start-turn";
+        boundaries.providerStartAt = Date.now();
         const turn = await startRuntimePromptTurn({
             session,
             command,
@@ -310,6 +312,7 @@ export async function handlePrompt(ws, config, command) {
                 ? { manualHandoffProof: fallback?.manualHandoffProof ?? session.manualHandoffProof }
                 : {}),
         });
+        boundaries.providerAcceptedAt = Date.now();
         phase = "attach-turn";
         if (!attachClaimedTurn(command.sessionId, command.requestId, command.turnId, turn)) {
             throw new Error(`Session turn claim was lost before start: ${command.sessionId}`);
@@ -317,6 +320,7 @@ export async function handlePrompt(ws, config, command) {
         phase = "persist-runtime-start";
         const runtimeThreadId = session.runtimeBinding.threadId;
         const runtimeTurnId = await turn.runtimeTurnId;
+        boundaries.providerTurnId = runtimeTurnId;
         if (!runtimeTurnId) {
             throw new Error(`Runtime did not return a turn id for ${command.turnId}`);
         }
@@ -357,6 +361,7 @@ export async function handlePrompt(ws, config, command) {
                 thinkingLevel,
                 memoryMode: memoryOptions?.mode,
                 usedMemories: memoryContext.used.map((item) => ({ path: item.path, citation: item.citation })),
+                boundaries,
             },
         });
         let outputPreview = "";
@@ -371,6 +376,7 @@ export async function handlePrompt(ws, config, command) {
         }
         phase = "await-turn-result";
         const result = await turn.result;
+        boundaries.providerTerminalAt = Date.now();
         session = withSessionHead(session, result.currentHead, result.lastTurnId);
         sessions.set(command.sessionId, session);
         await persistSessionProjection(session);
@@ -409,6 +415,7 @@ export async function handlePrompt(ws, config, command) {
             runtimeMetadataRefreshedAt: new Date().toISOString(),
         });
         phase = "emit-terminal";
+        boundaries.terminalEventAt = Date.now();
         clearPendingOptionRequestsForTurn(command.sessionId, command.turnId);
         const completedRuntimeTurnId = result.lastTurnId ?? result.currentHead ?? runtimeTurnId;
         await emitEvent(ws, config, command.sessionId, command.turnId, result.status === "failed"
@@ -525,6 +532,7 @@ export async function handlePrompt(ws, config, command) {
                 requestId: command.requestId,
                 turnId: command.turnId,
                 ...(result.status === "failed" ? { error: result.error.message } : { stopReason: result.stopReason }),
+                boundaries,
             },
         });
     }
@@ -540,7 +548,7 @@ export async function handlePrompt(ws, config, command) {
         await emitPromptFailureEvent(ws, config, command, phase, error).catch((eventError) => {
             console.error(`Prompt failure event failed for ${command.turnId}: ${eventError instanceof Error ? eventError.message : String(eventError)}`);
         });
-        await appendAudit(promptFailureAuditEvent(config, command, phase, error)).catch((auditError) => {
+        await appendAudit(promptFailureAuditEvent(config, command, phase, error, boundaries)).catch((auditError) => {
             console.error(`Prompt failure audit failed for ${command.turnId}: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
         });
         await sendCommandResponse(ws, response);
@@ -784,7 +792,7 @@ export function promptFailureResponse(command, phase, error) {
         message: promptFailureMessage(code, error),
     };
 }
-export function promptFailureAuditEvent(config, command, phase, error) {
+export function promptFailureAuditEvent(config, command, phase, error, boundaries) {
     const code = promptFailureCode(phase, error);
     return {
         sessionId: command.sessionId,
@@ -798,6 +806,7 @@ export function promptFailureAuditEvent(config, command, phase, error) {
             code,
             phase,
             message: safeErrorMessage(error),
+            ...(boundaries ? { boundaries } : {}),
         },
     };
 }

package/apps/daemon/dist/update-barrier.js

@@ -74,6 +74,7 @@ export function isUpdateAdmissionCommand(type) {
         type === "machine:prompt" ||
         type === "machine:dispatch" ||
         type === "machine:queue" ||
+        type === "machine:followup" ||
         type === "machine:optionResponse" ||
         type === "machine:resume" ||
         type === "machine:fork" ||