@ponythewhite/base-context 1.0.15 → 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))
@@ -3548,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;
@@ -3590,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;
@@ -4412,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) {
@@ -4460,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)
@@ -4812,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;
@@ -4844,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({
@@ -4855,7 +4902,6 @@ export class AgentSession {
                 display: false,
                 timestamp: Date.now(),
             });
-        leafId = entryId;
         return assertCurrent;
     }
     _refreshExtensionSystemPrompt(extensionPrompt, baseSnapshot) {
@@ -7065,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();
             },
@@ -7181,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() {
@@ -10027,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) => {
@@ -10073,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));