@ponythewhite/base-context 1.0.14 → 1.0.16

package/dist/core/agent-session.js

@@ -27,6 +27,7 @@ import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { createGoalContextMessage, emptyGoalState, GOAL_CONTEXT_CUSTOM_TYPE, GOAL_CONTEXT_PREVIEW_LABEL, GOAL_SKILL_NAME, GOAL_STATE_CUSTOM_TYPE, goalHostResponse, goalTokenDeltaForUsage, isPersistedGoalState, normalizeGoalState, validateGoalBudget, validateGoalObjective, } from "./goals.js";
 import { captureNativeBranchRequests, captureNativeCompactionRequests, captureNativePlannerRequests, captureNativeReviewerRequests, InferenceCoordinator, takeNativeInferenceAuthSource, } from "./inference-coordinator.js";
+import { JOB_WATCH_STATE, JobWatchController } from "./job-watch.js";
 import { snapshotPathIn } from "./kernel/state-snapshot.js";
 import { convertToLlm, createCompactionOutcomeMessage, createHeartbeatPromptMessage, createRefinementOutcomeMessage, createRlmChildFailureMessage, createRlmChildTerminalNoticeMessage, createSessionSlashCommandMessage, createSessionSlashCommandResultMessage, HARNESS_SNAPSHOT_CUSTOM_TYPE, HEARTBEAT_PROMPT_CUSTOM_TYPE, HEARTBEAT_PROMPT_PREVIEW_LABEL, IPYTHON_STATE_RESTORED_CUSTOM_TYPE, isSessionSlashCommandMessage, RLM_CHILD_FAILURE_CUSTOM_TYPE, RLM_CHILD_TERMINAL_NOTICE_CUSTOM_TYPE, } from "./messages.js";
 import { throwIfPromptAdmissionCancelled } from "./prompt-admission.js";
@@ -35,6 +36,7 @@ import { appendGlobalRefinement, applyRefinementProposal, formatHarnessStateForP
 import { getRecoveryCompactionAuthorization, PublicContextBudgetError } from "./request-view-selection.js";
 import { resolveConfigValue } from "./resolve-config-value.js";
 import { assertResourceCurrent } from "./resource-view.js";
+import { retainToolOutput } from "./retained-tool-output.js";
 import { createDefaultRlmSubagentSessionName, createRlmDeleteSubagentHostHandler, createRlmFindModelsHostHandler, createRlmListSubagentsHostHandler, createRlmRunHostHandler, findRlmModelMatches, normalizeRequestedRlmSubagentModel, normalizeRequestedRlmSubagentSessionName, normalizeRequestedRlmSubagentThinkingLevel, } from "./rlm-runtime.js";
 import { captureSelectedSkill, captureSkillDescriptor, readSkillSelection, sameSelectedSkills, selectedSkillBlock, selectedSkillIdentity, } from "./selected-skills.js";
 import { createNativeRecoveryRefusal, DEFAULT_NATIVE_RECOVERY_LIMITS, NativeRecoveryBudgetRefusal, NativeRecoveryCursorStore, parseNativeRecoveryInput, recoverCapturedHistory, } from "./selective-recovery.js";
@@ -328,6 +330,7 @@ export class AgentSession {
     _goalStateRevision = 0;
     _goalAccountingStartedAt = undefined;
     _goalContinuationAwaitsRlmWork = false;
+    _jobWatchController;
     _goalAccountedAssistantMessages = new WeakSet();
     _goalAbortInProgress = false;
     _autonomousState;
@@ -1110,6 +1113,10 @@ export class AgentSession {
                 activeToolNames: this._initialActiveToolNames,
                 includeAllExtensionTools: true,
             });
+            if (bootstrap.jobWatchState)
+                await this._getJobWatchController().restore(bootstrap.jobWatchState);
+            if (bootstrap.jobWatchUnavailable)
+                this._surfaceSessionInputError(new Error(bootstrap.jobWatchUnavailable));
             if (this._goalState.status === "active" &&
                 this._includeGoals &&
                 !this.getActiveToolNames().includes("ipython")) {
@@ -1625,8 +1632,28 @@ export class AgentSession {
                     !isPersistedRlmMaxDepthState(hydrated.entry.data))
                     throw new Error("Bootstrap RLM depth source is unavailable or ineligible");
                 rlmMaxDepth = hydrated.entry.data;
+                remaining -= bootstrap.rlmMaxDepth.locator.length;
+            }
+            let jobWatchState;
+            let jobWatchUnavailable = bootstrap.jobWatchUnavailable
+                ? `Monitoring unavailable: optional job-watch bootstrap candidate budget exceeded. Inspect ${this.sessionManager.getSessionFile()}; no watches were resumed.`
+                : undefined;
+            if (bootstrap.jobWatchState) {
+                if (bootstrap.jobWatchState.locator.length >
+                    Math.min(remaining, 64 * 1024 + 1024, Math.floor(maxSourceBytes / 2) + 1024)) {
+                    jobWatchUnavailable = `Monitoring unavailable: optional job-watch state exceeds the existing source budget. Inspect ${this.sessionManager.getSessionFile()} entry ${bootstrap.jobWatchState.id}; no watches were resumed.`;
+                }
+                else {
+                    const hydrated = await view.hydrateEntry(bootstrap.jobWatchState.id, remaining);
+                    if (hydrated?.entry.type === "custom" &&
+                        hydrated.entry.customType === JOB_WATCH_STATE &&
+                        hydrated.source.retention !== "retained-import")
+                        jobWatchState = hydrated.entry.data;
+                }
             }
             return {
+                jobWatchState,
+                jobWatchUnavailable,
                 goalState,
                 goalSeedable: bootstrap.goalSeedable,
                 rlmMaxDepth,
@@ -1675,6 +1702,8 @@ export class AgentSession {
         return true;
     }
     async _reloadBranchRuntimeState() {
+        this._jobWatchController?.dispose();
+        this._jobWatchController = undefined;
         this._contextMode = await this._readContextMode();
         const bootstrap = this.sessionManager.isPersisted()
             ? await this._readRuntimeBootstrap()
@@ -2123,7 +2152,10 @@ export class AgentSession {
     async _resumeGoalContinuationAfterRlmWork() {
         if (!this._goalContinuationAwaitsRlmWork)
             return;
-        if (this._disposed || this._disposing || this._hasUnsettledRlmQuiescenceWork())
+        if (this._disposed ||
+            this._disposing ||
+            this._hasUnsettledRlmQuiescenceWork() ||
+            this._jobWatchController?.isParked())
             return;
         if (this._goalState.status !== "active" || !this._goalState.objective) {
             this._goalContinuationAwaitsRlmWork = false;
@@ -3002,7 +3034,9 @@ export class AgentSession {
             : undefined;
     }
     async _queueAutonomousContinuationForThresholdCompaction(message, owner = this._captureCompactionOwner(this.agent.signal), capture = this._captureThresholdAutonomousOwner()) {
-        if (!this._isCompactionOwnerCurrent(owner) || !this._contextOptimizationAllowed())
+        if (!this._isCompactionOwnerCurrent(owner) ||
+            !this._contextOptimizationAllowed() ||
+            this._jobWatchController?.isParked())
             return undefined;
         const queued = this._queuedAutonomousThresholdContinuations.get(message);
         if (queued && this._checkpointActionPending(queued))
@@ -3059,7 +3093,7 @@ export class AgentSession {
             return undefined;
         if (message.stopReason === "error" || message.stopReason === "aborted")
             return undefined;
-        if (owner.goal.status !== "active" || !owner.goal.objective)
+        if (owner.goal.status !== "active" || !owner.goal.objective || this._jobWatchController?.isParked())
             return undefined;
         const queued = this._queuedGoalThresholdContinuation;
         if (queued && this._checkpointActionPending(queued))
@@ -3217,14 +3251,14 @@ export class AgentSession {
                 this._assertCompactionOwner(owner);
                 const compaction = owner.manager.bindCompactionSink();
                 const captured = owner.requests.capture(compaction);
-                let branch;
                 let preparation;
+                let leafKind;
                 try {
-                    branch = await compaction.readBranch();
-                    this._assertCompactionOwner(owner);
-                    preparation = this.isStreaming
-                        ? (await this._prepareCapturedCompaction(branch, settings, captured, compaction, owner)).preparation
-                        : undefined;
+                    if (this.isStreaming) {
+                        const prepared = await this._prepareCapturedCompaction(settings, captured, compaction, owner);
+                        preparation = prepared.preparation;
+                        leafKind = prepared.leafKind;
+                    }
                 }
                 catch (error) {
                     try {
@@ -3245,10 +3279,9 @@ export class AgentSession {
                         reason: "no active turn; compaction can only be requested while a turn is running",
                     };
                 if (!preparation) {
-                    const lastEntry = branch.at(-1);
                     return {
                         scheduled: false,
-                        reason: lastEntry?.type === "compaction" ? "already compacted" : "session is too short to compact",
+                        reason: leafKind === "compaction" ? "already compacted" : "session is too short to compact",
                     };
                 }
                 this._assertContextOptimizationAllowed();
@@ -3549,6 +3582,8 @@ export class AgentSession {
         if (this._goalState.status !== "active" || !this._goalState.objective) {
             return { kind: "finish" };
         }
+        if (this._jobWatchController?.isParked())
+            return { kind: "wait_for_owned_work" };
         // Delegating and ending the turn is correct behavior; retain the existing wakeup owner.
         if (this._hasUnsettledRlmQuiescenceWork()) {
             this._goalContinuationAwaitsRlmWork = true;
@@ -3591,6 +3626,8 @@ export class AgentSession {
             return this._stoppedContinuationOutcome(signal);
         if (this.queuedActionCount > 0)
             return { kind: "finish" };
+        if (this._jobWatchController?.isParked())
+            return { kind: "wait_for_owned_work" };
         const owner = this._captureGoalContinuationOwner(signal);
         const arrivalEpoch = this._sessionInputArrivalEpoch;
         const goalSnapshot = owner.goal;
@@ -4413,6 +4450,13 @@ export class AgentSession {
             await drain(() => this._agentEventQueue);
             await drain(() => this._goalResumeOperation);
             await drain(() => this._waitForChildUsageWrites());
+            if (this._jobWatchController) {
+                const undelivered = new Set(this._actionStore
+                    .unfinishedActions()
+                    .filter((action) => action.queueKey && action.payload.kind === "turn" && !primaryDeliveryRecord(action).durable)
+                    .map((action) => action.queueKey));
+                await drain(() => this._jobWatchController?.settleShutdown(undelivered));
+            }
             await drain(() => this.dispose());
         }
         catch (error) {
@@ -4461,6 +4505,7 @@ export class AgentSession {
         }
         this.requests.stopAdmission();
         this._disposed = true;
+        this._jobWatchController?.dispose();
         for (const run of this._unsettledRlmChildRuns)
             run.suppressTerminalNotice = true;
         for (const controller of this._rlmQuiescenceWaitAborts)
@@ -4813,10 +4858,10 @@ export class AgentSession {
     /** Persist mutable advice before the request owner captures its source and epoch ACK boundary. */
     async _appendHarnessSnapshotIfChanged() {
         const manager = this.sessionManager;
-        let leafId = manager.getLeafId();
-        const sourceIsCurrent = manager.captureCompactionSourceOwner();
+        const sourceIsCurrent = manager.captureCompactionContentOwner();
+        let ownAppends = 0;
         const assertCurrent = () => {
-            if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent() || manager.getLeafId() !== leafId)
+            if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent(ownAppends))
                 throw new Error("Harness snapshot source changed before request ownership");
         };
         let previous;
@@ -4845,8 +4890,9 @@ export class AgentSession {
         });
         if (previous === content)
             return assertCurrent;
-        const entryId = await manager.appendCustomMessageEntryWithRollback(HARNESS_SNAPSHOT_CUSTOM_TYPE, content, false);
-        if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent() || manager.getLeafId() !== entryId)
+        await manager.appendCustomMessageEntryWithRollback(HARNESS_SNAPSHOT_CUSTOM_TYPE, content, false);
+        ownAppends++;
+        if (this._disposed || this.sessionManager !== manager || !sourceIsCurrent(ownAppends))
             throw new Error("Harness snapshot source changed during append");
         if (!manager.isPersisted())
             this.agent.state.messages.push({
@@ -4856,7 +4902,6 @@ export class AgentSession {
                 display: false,
                 timestamp: Date.now(),
             });
-        leafId = entryId;
         return assertCurrent;
     }
     _refreshExtensionSystemPrompt(extensionPrompt, baseSnapshot) {
@@ -6492,10 +6537,13 @@ export class AgentSession {
                         actionId: action.id,
                         submittedText: input.submitted?.text,
                     };
+                    const clearedGoal = Boolean(this._goalState.objective) && this._parseGoalSlashCommand(input.text)?.kind === "clear";
                     await this._handleGoalSlashCommand(input.text, input.images, goalOrigin);
                     resultText = this._goalState.objective
                         ? `Goal ${this._goalState.status}: ${this._goalState.objective}`
-                        : "No active goal.";
+                        : clearedGoal
+                            ? "Goal cleared."
+                            : "No active goal.";
                     break;
                 }
                 case "autonomous":
@@ -7063,6 +7111,7 @@ export class AgentSession {
                 this._advanceCheckpointPauseEpoch();
                 this._notifySessionInputCheckpointChange();
                 this._flushDeferredRlmTerminalNotices();
+                void this._jobWatchController?.flushPending().catch((error) => this._surfaceSessionInputError(error));
                 this._scheduleGoalContinuationAfterRlmWork();
                 this._scheduleSessionInputPump();
             },
@@ -7179,6 +7228,7 @@ export class AgentSession {
         this._sessionInputPumpEpoch++;
         this._notifySessionInputCheckpointChange();
         this._flushDeferredRlmTerminalNotices();
+        void this._jobWatchController?.flushPending().catch((error) => this._surfaceSessionInputError(error));
     }
     /** Resume the scheduler after requestAbort/abortForUpdateRestart suspended it; owned pause leases are unaffected. */
     resumeQueuedWork() {
@@ -7786,14 +7836,12 @@ export class AgentSession {
             const semanticEdges = owner.semanticEdges;
             compaction = owner.manager.bindCompactionSink();
             requests = owner.requests.capture(compaction);
-            const pathEntries = await compaction.readBranch();
             this._assertCompactionOwner(owner);
             const { apiKey, headers } = await this._getRequiredRequestAuth(model);
             this._assertCompactionOwner(owner);
             committed = await this._performCompaction({
                 model,
                 thinkingLevel,
-                pathEntries,
                 settings,
                 requests,
                 compaction,
@@ -7887,33 +7935,47 @@ export class AgentSession {
         }
     }
     /** A private compiled context keeps extension summary edits separate from retained source recipes. */
-    async _prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
+    async _prepareCapturedCompaction(settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
         this._assertCompactionOwner(owner);
         const limits = this.settingsManager.getCanonicalContextLimits();
         const resource = this._captureKernelResource();
         const source = await compaction.source;
         this._assertCompactionOwner(owner);
-        if (!source.persistent)
+        if (!source.persistent) {
+            const pathEntries = await compaction.readBranch();
+            this._assertCompactionOwner(owner);
             return {
                 preparation: prepareCompaction(pathEntries, settings, allowShortSession),
+                pathEntries,
+                leafKind: pathEntries.at(-1)?.type,
                 maxSourceBytes: limits.maxSourceBytes,
             };
+        }
         return requests.readHistory(async (view) => {
             const messages = await new CanonicalContextCompiler().compile(view, limits, undefined, {}, resource, this._initialContextMode, false, "read");
             this._assertCompactionOwner(owner);
             const context = getCanonicalEpochContext(messages);
-            if (context.checkpoint?.includeSummary && pathEntries.at(-1)?.type === "compaction")
-                return { preparation: undefined, maxSourceBytes: limits.maxSourceBytes };
+            const entryIds = context.references.map((ref) => ref?.ref.entryId);
+            const selected = await compaction.readCompactionEntries(entryIds.filter((id) => id !== undefined));
+            this._assertCompactionOwner(owner);
+            const pathEntries = selected.entries;
+            if (context.checkpoint?.includeSummary && selected.leafKind === "compaction")
+                return {
+                    preparation: undefined,
+                    pathEntries,
+                    leafKind: selected.leafKind,
+                    maxSourceBytes: limits.maxSourceBytes,
+                };
             const authorization = getRecoveryCompactionAuthorization(capacity);
             const boundary = canonicalRecoveryBoundary(messages, authorization);
-            const preparation = budgetPressure || context.checkpoint || boundary
-                ? prepareViewCompaction(messages, context.references.map((ref) => ref?.ref.entryId), pathEntries, settings, boundary, allowShortSession, budgetPressure)
-                : prepareCompaction(pathEntries, settings, allowShortSession);
+            const preparation = prepareViewCompaction(messages, entryIds, pathEntries, settings, boundary, allowShortSession, budgetPressure, selected.suffixAnchors);
             // Refuse unsupported public data or open groups before starting the summary model call.
             if (preparation)
                 prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes, authorization);
             return {
                 preparation,
+                pathEntries,
+                leafKind: selected.leafKind,
                 messages,
                 resource: context.resourceRevision !== undefined ? resource : undefined,
                 maxSourceBytes: limits.maxSourceBytes,
@@ -7926,15 +7988,15 @@ export class AgentSession {
      * Error("Compaction cancelled") on abort or extension cancel.
      */
     async _performCompaction(options) {
-        const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, pathEntries, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, } = options;
-        const prepared = await this._prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
+        const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, } = options;
+        const prepared = await this._prepareCapturedCompaction(settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
         this._assertCompactionOwner(owner);
         if (prepared.resource)
             assertResourceCurrent(prepared.resource);
         const preparation = prepared.preparation;
+        const pathEntries = prepared.pathEntries;
         if (!preparation) {
-            const lastEntry = pathEntries[pathEntries.length - 1];
-            if (lastEntry?.type === "compaction") {
+            if (prepared.leafKind === "compaction") {
                 throw new CompactionSkippedError("Already compacted");
             }
             throw new CompactionSkippedError("Session is too short to compact — try again once it grows");
@@ -9366,7 +9428,6 @@ export class AgentSession {
             const semanticEdges = owner.semanticEdges;
             compaction = owner.manager.bindCompactionSink();
             requests = owner.requests.capture(compaction);
-            const pathEntries = await compaction.readBranch();
             this._assertCompactionOwner(owner);
             const authResult = model ? await this._modelRegistry.getApiKeyAndHeaders(model) : undefined;
             this._assertCompactionOwner(owner);
@@ -9385,7 +9446,6 @@ export class AgentSession {
             committed = await this._performCompaction({
                 model,
                 thinkingLevel,
-                pathEntries,
                 settings,
                 requests,
                 compaction,
@@ -10015,6 +10075,75 @@ export class AgentSession {
             return createNativeRecoveryRefusal("unavailable", "captured_history_unavailable", responseBytes);
         }
     }
+    _getJobWatchController() {
+        if (this._jobWatchController?.isCurrent())
+            return this._jobWatchController;
+        this._jobWatchController?.dispose();
+        const manager = this.sessionManager;
+        const ownsSource = manager.captureCompactionSourceOwner();
+        const controller = new JobWatchController({
+            sessionId: manager.getSessionId(),
+            sessionFile: manager.getSessionFile(),
+            current: () => !this._disposed && !this._disposing && this.sessionManager === manager && ownsSource(),
+            goalId: () => this._goalState.goalId,
+            persist: async (state) => {
+                if (this.sessionManager !== manager || !ownsSource())
+                    return;
+                await manager.appendCustomEntry(JOB_WATCH_STATE, state);
+            },
+            waitForDelivery: true,
+            stateBudgetBytes: Math.min(64 * 1024, Math.floor(this.settingsManager.getCanonicalContextLimits().maxSourceBytes / 2)),
+            probe: async (request) => {
+                const kernel = await this._ipythonKernelProvisioner?.ensure();
+                if (!kernel?.jobWatchProbe)
+                    throw new Error("Kernel job_watch_probe_v1 is unavailable");
+                const result = await kernel.jobWatchProbe({
+                    watchId: request.id,
+                    generation: request.generation,
+                    resourceId: request.resource_id,
+                    jobId: request.job_id,
+                    completionSource: request.completion_source,
+                    command: request.command ?? null,
+                    timeoutMs: request.timeout_ms,
+                });
+                await controller.observe({ id: request.id, generation: request.generation, ...result });
+            },
+            cancelProbe: (id) => this._ipythonKernelProvisioner?.manager?.cancelJobWatchProbe?.(id),
+            retain: async (output) => {
+                const directory = manager.getSessionArtifactDir();
+                if (!directory)
+                    return undefined;
+                const retained = await retainToolOutput(directory, [output], false);
+                return join(directory, retained.artifactId);
+            },
+            onError: (error) => this._surfaceSessionInputError(error),
+            admit: (text, eventId) => {
+                if (this._sessionInputAdmissionPauses.size)
+                    return false;
+                const content = `[job-watch] ${text}`;
+                const admission = this._admitSessionInput(this._createPreparedTurnAction("followUp", content, undefined, {
+                    message: {
+                        role: "custom",
+                        customType: "job_watch_event",
+                        content,
+                        display: true,
+                        timestamp: Date.now(),
+                    },
+                    queueKey: eventId,
+                    resumeIfIdle: !this._sessionInputPumpSuspended,
+                }), { wake: !this._sessionInputPumpSuspended });
+                if (admission.ticket)
+                    void admission.ticket.delivered
+                        .then((outcome) => outcome.status === "delivered"
+                        ? controller.acknowledge(eventId)
+                        : controller.releaseDelivery(eventId, true), () => controller.releaseDelivery(eventId, false))
+                        .catch((error) => this._surfaceSessionInputError(error));
+                return admission.accepted;
+            },
+        });
+        this._jobWatchController = controller;
+        return controller;
+    }
     _createKernelHostHandlers() {
         const handlers = {
             prime_context: async (payload, context) => {
@@ -10061,6 +10190,35 @@ export class AgentSession {
                 handlers[type] = async (payload) => this.handleRlmHeartbeatHostRequest(type, payload);
             }
         }
+        for (const type of ["watch", "status", "park", "unregister", "observation"]) {
+            handlers[`job_watch.${type}`] = async (payload) => {
+                if (this._disposed || this._disposing)
+                    throw new Error("Job watch source owner changed");
+                if (type === "observation" && !this._jobWatchController?.isCurrent())
+                    return { ignored: true };
+                const controller = this._getJobWatchController();
+                switch (type) {
+                    case "watch":
+                        return { ...(await controller.watch(payload)) };
+                    case "status":
+                        return controller.status(typeof payload.id === "string" ? payload.id : undefined);
+                    case "park":
+                        if (!Array.isArray(payload.ids) || !payload.ids.every((id) => typeof id === "string"))
+                            throw new Error("park requires watch ids");
+                        return controller.park(payload.ids);
+                    case "unregister":
+                        return controller.unregister(String(payload.id));
+                    default:
+                        if (typeof payload.id !== "string" ||
+                            typeof payload.generation !== "string" ||
+                            !payload.result ||
+                            typeof payload.result !== "object")
+                            throw new Error("Invalid job watch observation");
+                        await controller.observe({ ...payload.result, id: payload.id, generation: payload.generation });
+                        return {};
+                }
+            };
+        }
         const visibleKernelSkillNames = new Set(this._modelVisibleSkills()
             .filter((skill) => !skill.disableModelInvocation)
             .map((skill) => skill.name));