@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/scheduler/journal-index-state.d.ts

@@ -18,10 +18,10 @@ export declare function encodeJournalIndexState(state: JournalIndexState, genera
         id: string;
         requestId: string;
         sessionId: string;
+        environmentId: string;
         status: import("./contracts.js").SchedulerRunStatus;
         jobId: string;
         scheduledAt: string;
-        environmentId: string;
         jobRevision: number;
         offset: number;
         active?: SchedulerRun;

package/dist/src/runtime/scheduler/journal-store.d.ts

@@ -1,6 +1,7 @@
 import type { SchedulerRunListQuery, SchedulerSnapshot } from "./contracts.js";
 export declare class SchedulerJournalStore {
     private readonly directory;
+    private readonly onCommittedChange?;
     private index;
     private sequence;
     private generation?;
@@ -8,13 +9,14 @@ export declare class SchedulerJournalStore {
     private legacy?;
     private publicationFailure?;
     private ownedDirectoriesSynced;
-    constructor(directory: string);
+    constructor(directory: string, onCommittedChange?: (() => void) | undefined);
     load(): Promise<this>;
     prepareOwned(): Promise<void>;
     snapshot(view?: "active"): Promise<SchedulerSnapshot>;
     readRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<import("./contracts.js").SchedulerRun[]>;
     update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
     private replaceGeneration;
+    private notifyCommittedChange;
     private ensureOwnedDirectoriesSynced;
     private publishHead;
     private requireDurablePublication;

package/dist/src/runtime/scheduler/journal-store.js

@@ -10,6 +10,7 @@ import { cleanObsoleteJournalCheckpoints, loadCheckpointJournalIndex, writeJourn
 import { JournalPublicationSyncError, syncJournalDirectory, syncJournalDirectoryPath, } from "./journal-durability.js";
 export class SchedulerJournalStore {
     directory;
+    onCommittedChange;
     index = new SchedulerJournalIndex();
     sequence = 0;
     generation;
@@ -17,8 +18,9 @@ export class SchedulerJournalStore {
     legacy;
     publicationFailure;
     ownedDirectoriesSynced = false;
-    constructor(directory) {
+    constructor(directory, onCommittedChange) {
         this.directory = directory;
+        this.onCommittedChange = onCommittedChange;
     }
     async load() {
         const head = await readJournalHead(this.directory);
@@ -89,7 +91,7 @@ export class SchedulerJournalStore {
             const complete = view === "active"
                 ? applyWorkingChanges(await this.snapshot(), delta)
                 : after;
-            await this.replaceGeneration(complete);
+            await this.replaceGeneration(complete, true);
             return result;
         }
         const file = join(this.directory, this.generation, journalTransactionName(this.sequence + 1));
@@ -99,9 +101,10 @@ export class SchedulerJournalStore {
         this.index.apply(delta, file);
         this.sequence += 1;
         this.head = head;
+        this.notifyCommittedChange();
         return result;
     }
-    async replaceGeneration(snapshot) {
+    async replaceGeneration(snapshot, hasLogicalChange = false) {
         const generation = await createJournalGeneration(this.directory);
         const index = new SchedulerJournalIndex();
         let sequence = 0;
@@ -126,9 +129,19 @@ export class SchedulerJournalStore {
         this.generation = generation;
         this.head = head;
         this.legacy = undefined;
+        if (hasLogicalChange)
+            this.notifyCommittedChange();
         // Failed physical removal remains discoverable on the next explicit operation.
         await cleanObsoleteJournalGenerations(this.directory, generation);
     }
+    notifyCommittedChange() {
+        try {
+            this.onCommittedChange?.();
+        }
+        catch {
+            /* A view cannot change the outcome of a committed transaction. */
+        }
+    }
     async ensureOwnedDirectoriesSynced() {
         if (this.ownedDirectoriesSynced)
             return;

package/dist/src/runtime/scheduler/run-records.js

@@ -10,6 +10,7 @@ export function makeSchedulerRun(job, scheduledAt, trigger) {
         prompt: job.prompt,
         modelProfileId: job.modelProfileId,
         agentMode: job.agentMode,
+        toolPermissionMode: job.toolPermissionMode,
         timeZone: job.timeZone,
         jobRevision: job.revision,
         scheduledAt,

package/dist/src/runtime/scheduler/schedule-validation.js

@@ -1,3 +1,4 @@
+import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { SchedulerValidationError } from "./validation-error.js";
 import { parseSchedulerInstant, schedulerInstantFromMilliseconds, } from "./instant-validation.js";
 export { SchedulerValidationError } from "./validation-error.js";
@@ -27,6 +28,7 @@ export function validateSchedulerJobInput(input) {
     if (!allowedModes.includes(input.agentMode)) {
         throw new SchedulerValidationError("scheduler_invalid_job", "agentMode is invalid");
     }
+    requireSchedulerToolPermissionMode(input.toolPermissionMode);
     validateTimeZone(input.timeZone);
 }
 export function validateTimeZone(timeZone) {

package/dist/src/runtime/scheduler/scheduler-engine.js

@@ -63,7 +63,7 @@ async function dispatchPendingRun(context, pending) {
     }
     if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
         return;
-    const release = context.executor.tryReserve(pending.sessionId);
+    const release = await context.executor.tryReserve(pending.sessionId);
     if (!release)
         return;
     let delegated = false;
@@ -148,6 +148,7 @@ function startCapturedRun(context, job, run) {
             title: run.title,
             modelProfileId: run.modelProfileId,
             agentMode: run.agentMode,
+            toolPermissionMode: run.toolPermissionMode ?? "full_access",
             timeZone: run.timeZone,
             revision: run.jobRevision,
         }, run);

package/dist/src/runtime/scheduler/snapshot-validation.js

@@ -1,4 +1,5 @@
 import { normalizeStoredSchedulerSchedule, validateSchedulerJobInput, validateTimeZone, } from "./schedule-validation.js";
+import { isSchedulerToolPermissionMode, requireSchedulerToolPermissionMode, } from "./tool-permission-mode.js";
 function isRecord(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -20,7 +21,7 @@ export function parseStoredJob(value) {
     validateSchedulerJobInput(job);
     if (!job.id || !job.environmentId)
         failSnapshot();
-    if (job.toolPermissionMode !== "full_access")
+    if (!isSchedulerToolPermissionMode(job.toolPermissionMode))
         failSnapshot();
     if (!["active", "paused", "cancelled", "completed"].includes(job.state))
         failSnapshot();
@@ -61,6 +62,7 @@ export function parseStoredRun(value) {
         failSnapshot();
     if (Number(value.jobRevision) < 1)
         failSnapshot();
+    requireSchedulerToolPermissionMode(value.toolPermissionMode);
     validateTimeZone(String(value.timeZone));
     const states = [
         "pending",

package/dist/src/runtime/scheduler/tool-permission-mode.d.ts

@@ -0,0 +1,5 @@
+import type { ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+export type SchedulerToolPermissionMode = Extract<ToolPermissionMode, "full_access" | "full_plus">;
+export declare function isSchedulerToolPermissionMode(value: unknown): value is SchedulerToolPermissionMode;
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export declare function requireSchedulerToolPermissionMode(value: unknown): SchedulerToolPermissionMode;

package/dist/src/runtime/scheduler/tool-permission-mode.js

@@ -0,0 +1,14 @@
+import { SchedulerValidationError } from "./validation-error.js";
+export function isSchedulerToolPermissionMode(value) {
+    if (value === "full_access")
+        return true;
+    return value === "full_plus";
+}
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export function requireSchedulerToolPermissionMode(value) {
+    if (value === undefined)
+        return "full_access";
+    if (isSchedulerToolPermissionMode(value))
+        return value;
+    throw new SchedulerValidationError("scheduler_invalid_job", "toolPermissionMode must be full_access or full_plus");
+}

package/dist/src/runtime/session/cancelled-response.d.ts

@@ -0,0 +1,12 @@
+import type { SessionThinkingTraceEntry } from "../../sessions/types.js";
+import type { RequestSessionStore } from "../request/session-store.js";
+type CancelledResponseParams = {
+    sessionStore: Pick<RequestSessionStore, "getOrCreateSession" | "appendMessage">;
+    sessionId: string;
+    requestId: string;
+    partialAnswer: string;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+};
+/** Called only after opening the request session; the terminal remains cancelled. */
+export declare function persistCancelledResponse(params: CancelledResponseParams): Promise<Record<string, unknown>>;
+export {};

package/dist/src/runtime/session/cancelled-response.js

@@ -0,0 +1,39 @@
+import { traceDebug } from "../observability/debug-logger.js";
+/** Called only after opening the request session; the terminal remains cancelled. */
+export async function persistCancelledResponse(params) {
+    try {
+        const stoppedResponse = await appendCancelledResponse(params);
+        if (stoppedResponse === undefined)
+            return {};
+        return { stoppedResponse };
+    }
+    catch (error) {
+        traceDebug("runtime.request", "cancelled_response.persist_failed", {
+            requestId: params.requestId,
+            sessionId: params.sessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { stoppedResponsePersistenceFailed: true };
+    }
+}
+async function appendCancelledResponse(params) {
+    const session = await params.sessionStore.getOrCreateSession(params.sessionId);
+    const requestMessages = session.messages.filter((message) => message.requestId === params.requestId);
+    const hasPersistedUserMessage = requestMessages.some((message) => message.role === "user");
+    if (!hasPersistedUserMessage)
+        return undefined;
+    const existingResponse = requestMessages.find((message) => message.role === "assistant");
+    if (existingResponse)
+        return existingResponse.content;
+    const acknowledgement = "I stopped the task at your request.";
+    const output = params.partialAnswer.trim()
+        ? `${params.partialAnswer}\n\n${acknowledgement}`
+        : acknowledgement;
+    await params.sessionStore.appendMessage(params.sessionId, "assistant", output, {
+        requestId: params.requestId,
+        source: "request",
+        grounding: "conversation",
+        thinkingTrace: params.thinkingTrace,
+    });
+    return output;
+}

package/dist/src/runtime/session/request-activation.d.ts

@@ -0,0 +1,3 @@
+import type { SessionRequestLifecycleSnapshot, SessionRequestLifecycleStore, SessionStartActivationCommand } from "../../sessions/request-lifecycle/contracts.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export declare function startRequestActivation(store: SessionRequestLifecycleStore, sessionId: string, command: SessionStartActivationCommand): Promise<SessionRequestLifecycleSnapshot>;

package/dist/src/runtime/session/request-activation.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { SessionCommitOutcomeUnknownError } from "../../sessions/durable-session-commit.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export async function startRequestActivation(store, sessionId, command) {
+    try {
+        const started = await store.startActivation(sessionId, command);
+        if (!started.accepted)
+            throw new Error(`request_activation_rejected:${started.reason}`);
+        return started.current;
+    }
+    catch (error) {
+        if (!(error instanceof SessionCommitOutcomeUnknownError))
+            throw error;
+        const current = await store.get(sessionId, command.requestId);
+        if (!isUnconfirmedInitialActivation(current, command))
+            throw error;
+        // No runner has started. Close the exact visible activation before its
+        // owner releases the control; an uncertain commit never permits dispatch.
+        const interrupted = await store.interruptActivation(sessionId, {
+            expected: {
+                requestId: current.requestId,
+                generation: current.generation,
+                revision: current.revision,
+                activationId: command.activationId,
+                ownerEpoch: command.ownerEpoch,
+            },
+            commandId: randomUUID(),
+            message: {
+                content: "The task was interrupted because its startup could not be saved reliably.",
+            },
+        });
+        if (!interrupted.accepted)
+            throw new Error(`request_activation_interruption_rejected:${interrupted.reason}`, { cause: error });
+        throw error;
+    }
+}
+function isUnconfirmedInitialActivation(current, command) {
+    if (current?.status !== "streaming")
+        return false;
+    if (current.activation?.activationId !== command.activationId)
+        return false;
+    return current.activation.ownerEpoch === command.ownerEpoch;
+}

package/dist/src/runtime/session/request-history.js

@@ -1,10 +1,17 @@
+import { isAssistantInitiativeMessage } from "../../sessions/assistant-initiative.js";
 export function snapshotRequestHistory(session) {
-    return session.messages.map((message) => ({
+    return session.messages.filter(isRequestHistoryMessage).map((message) => ({
         id: message.id,
         role: message.role,
         content: message.content,
         createdAt: message.createdAt,
         ...(message.requestId ? { requestId: message.requestId } : {}),
         ...(message.grounding ? { grounding: message.grounding } : {}),
+        ...(isAssistantInitiativeMessage(message)
+            ? { assistantInitiativeId: message.initiative.proposalId }
+            : {}),
     }));
 }
+function isRequestHistoryMessage(message) {
+    return message.kind !== "tool_approval_request";
+}

package/dist/src/runtime/session/request-session.d.ts

@@ -1,5 +1,6 @@
 import type { ModelGatewayAttachment } from "../../model-gateway/types.js";
 import type { SessionRecord } from "../../sessions/types.js";
+import type { SessionActivation, SessionRequestLifecycleSnapshot } from "../../sessions/request-lifecycle/contracts.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { RuntimeAttachmentReference, RuntimeAttachmentStore } from "../attachments/store.js";
 import type { EventSink } from "../ports.js";
@@ -8,6 +9,7 @@ import type { RequestSessionStore } from "../request/session-store.js";
 type OpenedRequestSession = {
     session: SessionRecord;
     attachments: RuntimeAttachmentReference[];
+    activation?: SessionRequestLifecycleSnapshot;
 };
 export declare function openRequestSession(params: {
     sessionId: string;
@@ -15,6 +17,7 @@ export declare function openRequestSession(params: {
     rawAttachments: unknown;
     sessionStore: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
+    activation?: SessionActivation;
 }): Promise<OpenedRequestSession>;
 export declare function initializeRequestSession(params: {
     opened: OpenedRequestSession;

package/dist/src/runtime/session/request-session.js

@@ -1,5 +1,6 @@
 import { appendRequestAttachmentManifest } from "../orchestration/request/request-attachment-prompt.js";
 import { resolveModelGatewayAttachments, resolveRequestAttachments, resolveToolRequestAttachments, } from "../orchestration/request/request-attachments.js";
+import { startRequestActivation } from "./request-activation.js";
 export async function openRequestSession(params) {
     if (!params.sessionId) {
         throw new Error("sessionId required");
@@ -10,6 +11,17 @@ export async function openRequestSession(params) {
         sessionId: params.sessionId,
         attachmentStore: params.attachmentStore,
     });
+    if (params.activation) {
+        const store = params.sessionStore.requestLifecycle;
+        if (!store)
+            throw new Error("durable_approval_store_unavailable");
+        // The first persisted running record already has its recoverable activation.
+        const activation = await startRequestActivation(store, params.sessionId, {
+            requestId: params.requestId,
+            ...params.activation,
+        });
+        return { session, attachments, activation };
+    }
     await params.sessionStore.startRequestStream(params.sessionId, params.requestId);
     return { session, attachments };
 }
@@ -25,6 +37,9 @@ export async function initializeRequestSession(params) {
             ? { attachments: params.opened.attachments }
             : {}),
     });
+    params.events.event("session.messages.updated", {
+        sessionId: params.sessionId,
+    });
     if (params.schedule) {
         const message = persisted.messages.find((entry) => entry.requestId === params.requestId && entry.role === "user");
         params.events.event("schedule.triggered", {

package/dist/src/runtime/session/session-lifecycle-store.js

@@ -35,6 +35,25 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
         };
     }
     const store = {
+        ...(base.requestLifecycle
+            ? {
+                requestLifecycle: {
+                    ...base.requestLifecycle,
+                    startActivation: wrapSessionMutation(base.requestLifecycle.startActivation),
+                    commitWait: wrapSessionMutation(base.requestLifecycle.commitWait),
+                    commitDecision: wrapSessionMutation(base.requestLifecycle.commitDecision),
+                    cancelWait: wrapSessionMutation(base.requestLifecycle.cancelWait),
+                    interruptActivation: wrapSessionMutation(base.requestLifecycle.interruptActivation),
+                    commitTerminal: wrapSessionMutation(base.requestLifecycle.commitTerminal),
+                    appendActivationEvent: wrapSessionMutation(base.requestLifecycle.appendActivationEvent),
+                },
+            }
+            : {}),
+        ...(base.createAssistantConversation
+            ? {
+                createAssistantConversation: wrapSessionMutation(base.createAssistantConversation),
+            }
+            : {}),
         getAllSessions: base.getAllSessions.bind(base),
         listSessions: base.listSessions.bind(base),
         getSessionById: base.getSessionById.bind(base),

package/dist/src/runtime/session/session-title.js

@@ -1,3 +1,4 @@
+import { getRequestFinalState } from "../../sessions/record/projection.js";
 import { traceDebug } from "../observability/debug-logger.js";
 export function createRequestSessionTitleUpdater(params) {
     return async (title) => {
@@ -33,6 +34,22 @@ export function createRequestSessionTitleUpdater(params) {
     };
 }
 export function shouldGenerateSessionTitle(session) {
-    return (session.messages.length === 0 &&
-        (!session.title.trim() || session.title === session.id));
+    const hasPlaceholderTitle = !session.title.trim() || session.title === session.id;
+    if (!hasPlaceholderTitle)
+        return false;
+    if (session.messages.length === 0)
+        return true;
+    return hasOnlyCancelledRequestMessages(session);
+}
+function hasOnlyCancelledRequestMessages(session) {
+    const cancelledIds = new Set((session.requests ?? [])
+        .filter(isUserCancelledRequest)
+        .map(({ requestId }) => requestId));
+    return session.messages.every((message) => cancelledIds.has(message.requestId ?? ""));
+}
+function isUserCancelledRequest(request) {
+    if (request.status !== "failed")
+        return false;
+    const terminal = getRequestFinalState(request);
+    return (terminal?.status === "failed" && terminal.error === "request_cancelled");
 }

package/dist/src/runtime/steps/auditor-decision/input.js

@@ -102,6 +102,7 @@ export function buildAuditorDecisionInput(request, assignment, phase = "review")
                 callId: assignment.auditId,
             },
             onEvent: request.onEvent,
+            deferCompactionFailure: true,
         }),
         format,
         modelStep: AUDITOR_DECISION_MODEL_STEP,

package/dist/src/runtime/steps/auditor-decision/run.js

@@ -74,6 +74,7 @@ async function invokeAuditorPhase(request, input, parse) {
         modelStep: input.modelStep,
         format: input.format,
         messages: input.context.messages,
+        contextRetention: "exact",
         timeoutReason: "auditor_decision_timeout",
         invalidOutputReason: "invalid_auditor_decision",
         parse,

package/dist/src/runtime/steps/degraded-finalization/input.d.ts

@@ -4,6 +4,7 @@ import { createDegradedFinalizationFormat, type DegradedFinalizationInput } from
 export declare function buildDegradedFinalizationModelInput(params: {
     request: RequestExecutionSeed;
     input: DegradedFinalizationInput;
+    languageSampleText?: string;
 }): {
     messages: ChatMessage[];
     format: ReturnType<typeof createDegradedFinalizationFormat>;

package/dist/src/runtime/steps/degraded-finalization/input.js

@@ -10,7 +10,7 @@ export function buildDegradedFinalizationModelInput(params) {
             {
                 role: "user",
                 content: buildDegradedFinalizationUserPrompt({
-                    requestText: params.request.prompt,
+                    requestText: params.languageSampleText ?? params.request.prompt,
                     problemText: JSON.stringify(params.input.problem, null, 2),
                 }),
             },

package/dist/src/runtime/steps/degraded-finalization/model-authored.d.ts

@@ -0,0 +1,8 @@
+import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "../../request/contracts.js";
+import { type DegradedFinalizationInput } from "./contract.js";
+/** Requires model-authored framing; failure never substitutes runtime prose. */
+export declare function runModelAuthoredDegradedFinalization(params: {
+    request: RequestExecutionSeed & BoundRequestModelInvocationContext;
+    input: DegradedFinalizationInput;
+    maxResponseChars: number;
+}): Promise<string>;

package/dist/src/runtime/steps/degraded-finalization/model-authored.js

@@ -0,0 +1,81 @@
+import { invokeStructuredModelStep, } from "../../model/invoke-structured-step.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { DEGRADED_FINALIZATION_STEP_ID, } from "./contract.js";
+import { resolveRequestSteeringInbox } from "../../request/request-steering.js";
+import { buildDegradedFinalizationModelInput } from "./input.js";
+import { parseDegradedFinalizationPhrasing } from "./parser.js";
+import { renderDegradedFinalization } from "./render.js";
+/** Requires model-authored framing; failure never substitutes runtime prose. */
+export async function runModelAuthoredDegradedFinalization(params) {
+    params.request.abortSignal.throwIfAborted();
+    if (!isUsableDegradedResponseLimit(params.maxResponseChars)) {
+        throw new Error("degraded_finalization_response_limit_invalid");
+    }
+    const steering = resolveRequestSteeringInbox(params.request.requestSteering).snapshot();
+    const modelInput = buildDegradedFinalizationModelInput({
+        ...params,
+        languageSampleText: steering.updates.at(-1)?.text,
+    });
+    traceDebug("runtime.degraded_finalization", "started", {
+        requestId: params.request.requestId,
+        problemCode: params.input.problem.code,
+        source: "model_required",
+    });
+    try {
+        const response = await invokeStructuredModelStep({
+            request: params.request,
+            modelStep: DEGRADED_FINALIZATION_STEP_ID,
+            messages: modelInput.messages,
+            format: modelInput.format,
+            timeoutReason: "degraded_finalization_timeout",
+            invalidOutputReason: "invalid_degraded_finalization_output",
+            parse: (text) => parseBoundedDegradedResponse(text, params),
+        });
+        params.request.abortSignal.throwIfAborted();
+        traceDebug("runtime.degraded_finalization", "completed", {
+            requestId: params.request.requestId,
+            problemCode: params.input.problem.code,
+            source: "model",
+            outputLength: response.length,
+        });
+        return response;
+    }
+    catch (error) {
+        traceDebug("runtime.degraded_finalization", "failed", {
+            requestId: params.request.requestId,
+            problemCode: params.input.problem.code,
+            source: "model_required",
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+function parseBoundedDegradedResponse(text, params) {
+    const phrasing = parseDegradedFinalizationPhrasing(text);
+    if (!phrasing) {
+        return rejectedDegradedResponse("degraded_finalization_phrasing_invalid", "Return the required failureNotice and nextStep as non-empty strings.");
+    }
+    const response = renderDegradedFinalization({
+        input: params.input,
+        phrasing,
+    });
+    if (!fitsDegradedResponseLimit(response, params.maxResponseChars)) {
+        return rejectedDegradedResponse("degraded_finalization_response_too_long", `Shorten the framing so the complete response, including recorded progress, fits within ${params.maxResponseChars} characters.`);
+    }
+    return { ok: true, decision: response };
+}
+function rejectedDegradedResponse(code, message) {
+    return {
+        ok: false,
+        stage: "degraded_finalization",
+        issues: [{ code, path: "$", message }],
+    };
+}
+function isUsableDegradedResponseLimit(maxResponseChars) {
+    if (!Number.isSafeInteger(maxResponseChars))
+        return false;
+    return maxResponseChars > 0;
+}
+function fitsDegradedResponseLimit(response, maxResponseChars) {
+    return response.length <= maxResponseChars;
+}

package/dist/src/runtime/steps/degraded-finalization/render.js

@@ -11,8 +11,9 @@ function renderCanonicalProgress(input) {
     if (!input.progress) {
         return "";
     }
+    const planSummary = normalizeLine(input.progress.planSummary);
     return [
-        `### ${normalizeLine(input.progress.planSummary)}`,
+        ...(planSummary ? [`### ${planSummary}`] : []),
         ...input.progress.completed.map((item) => `- [x] ${normalizeLine(item.title)}`),
         ...input.progress.unresolved.map((item) => `- ${renderUnresolvedMarker(item.status)} ${normalizeLine(item.title)}`),
     ].join("\n");

package/dist/src/runtime/steps/execution-agent/input.js

@@ -1,5 +1,6 @@
 import { projectRequestContext } from "../../context/request-context.js";
 import { projectRootSessionMemory } from "../../context/session-memory/root-projection.js";
+import { buildConversationMemoryAvailabilityInstructions } from "../../long-term-memory/conversation-authoring/prompt.js";
 import { canOfferMemoryRecall } from "../../long-term-memory/recall-policy.js";
 import { projectMemoryRecallContinuations } from "../../long-term-memory/recall-continuation.js";
 import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
@@ -69,20 +70,23 @@ export function buildExecutionAgentInput(request, options) {
         includeWorkingDirectory: options.call.workingDirectory === undefined,
     });
     const format = createExecutionAgentDecisionFormat(contract);
-    const instructions = buildExecutionAgentInstructions({
-        allowWorkPlan: workPlan !== undefined,
-        allowMemoryRecall: contract.allowMemoryRecall,
-        hasMemoryRecallContext: memoryRecallMessage !== undefined,
-        hasCapabilities: capabilities.length > 0,
-        hasCapabilityCatalogGroups: capabilityCatalogGroups.length > 0,
-        capabilityScopeAction,
-        allowPlanner: options.allowPlanner,
-        availableAuditCriterionCount: availableAuditCriterionIds.length,
-        allowRespond: true,
-        includeAcknowledgement: options.includeAcknowledgement,
-        includeTitle: options.includeTitle,
-        includeWorkingDirectory: options.call.workingDirectory === undefined,
-    });
+    const instructions = [
+        buildExecutionAgentInstructions({
+            allowWorkPlan: workPlan !== undefined,
+            allowMemoryRecall: contract.allowMemoryRecall,
+            hasMemoryRecallContext: memoryRecallMessage !== undefined,
+            hasCapabilities: capabilities.length > 0,
+            hasCapabilityCatalogGroups: capabilityCatalogGroups.length > 0,
+            capabilityScopeAction,
+            allowPlanner: options.allowPlanner,
+            availableAuditCriterionCount: availableAuditCriterionIds.length,
+            allowRespond: true,
+            includeAcknowledgement: options.includeAcknowledgement,
+            includeTitle: options.includeTitle,
+            includeWorkingDirectory: options.call.workingDirectory === undefined,
+        }),
+        ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
+    ].join("\n");
     const scheduledExecution = projectScheduledExecutionContext(request, instructions, "decision");
     const budget = resolveModelContextBudget({
         runnerConfig: request.runnerConfig,

package/dist/src/runtime/steps/execution-agent/response-input.d.ts

@@ -11,6 +11,7 @@ export declare function buildExecutionAgentResponseInput(request: RequestExecuti
     steeringSnapshot: RequestSteeringSnapshot;
     memoryAuthoringMaxResponseChars?: number;
     longTermMemoryMessage?: ChatMessage;
+    memoryAuthoringMessage?: ChatMessage;
 }>): Readonly<{
     context: RequestContextProjection;
     messages: ChatMessage[];

package/dist/src/runtime/steps/execution-agent/response-input.js

@@ -48,6 +48,7 @@ export function buildExecutionAgentResponseInput(request, options) {
                 ? [operationSupervisionEvidenceMessage]
                 : []),
             ...(options.longTermMemoryMessage ? [options.longTermMemoryMessage] : []),
+            ...(options.memoryAuthoringMessage ? [options.memoryAuthoringMessage] : []),
         ],
         ...(continuationMessages.length > 0 ? { continuationMessages } : {}),
         deferCompactionFailure: true,