open-multi-agent-kit 0.98.5 → 1.0.0

package/dist/core/agent-session.js

@@ -18,7 +18,7 @@ import { basename, dirname, join as joinPath } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { getVisionRouteModel } from "omk-agent-core";
 import { clampThinkingLevel, cleanupSessionResources, deriveContextPromptCacheKey, getSupportedThinkingLevels, isBuiltinStreamFn, modelsAreEqual, resetApiProviders, } from "omk-ai";
-import { APP_NAME, VERSION } from "../config.js";
+import { APP_NAME, getAgentDir, VERSION } from "../config.js";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { resolvePath } from "../utils/paths.js";
@@ -33,6 +33,7 @@ import { getCompactionHeadroomThreshold } from "./compaction/compaction.js";
 import { createCompactionHysteresisConfig, createCompactionHysteresisState, stepCompactionHysteresis, } from "./compaction/hysteresis.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateProjectedContextTokens, generateBranchSummary, prepareCompaction, resolveCompactionModel, } from "./compaction/index.js";
 import { summarizeWithOAuthRecovery } from "./compaction/oauth-recovery.js";
+import { overflowRetryBlocked } from "./compaction/overflow-retry-guard.js";
 import { compactionEmitWillRetry } from "./compaction/resume-policy.js";
 import { isSessionModelOverflow, shouldSkipCompactionCheck } from "./compaction-gate.js";
 import { estimateToolResultReserve, } from "./context-budget-reserved-tokens.js";
@@ -40,17 +41,21 @@ import { createDiskContextBudgetCacheProviderV2, DiskContextBudgetCacheProviderV
 import { applyContextCacheInvalidation, createContextCacheInvalidationSnapshot, } from "./context-budget-v2-cache-invalidation.js";
 import { createMemoryContextBudgetCacheProviderV2 } from "./context-budget-v2-cache-provider.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { devinHarnessAutoApplyEnabled, devinPlaybookAppendForProvider, isDevinProvider, selectDevinHarnessSkills, } from "./devin-harness.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { assertTextChatModelForCompletion, grokHarnessAutoApplyEnabled, isGrokOAuthProvider, selectGrokHarnessSkills, } from "./grok-harness.js";
 import { grokPlaybookAppendForProvider } from "./grok-playbook.js";
+import { loadHookInventory } from "./hook-inventory.js";
 import { captureHostResourceSnapshot } from "./host-resource-snapshot.js";
 import { decideLoadoutAccess } from "./loadout-access-policy.js";
+import { buildCapabilityInventory } from "./loadout-runtime.js";
 import { loadMcpServerConfigs } from "./mcp/config.js";
 import { McpManager } from "./mcp/manager.js";
 import { buildRuntimeProvenance } from "./runtime-provenance.js";
+import { createSubagentLaneAuthority } from "./subagent-lane-authority.js";
 import { TurnMetricsSink } from "./turn-metrics.js";
 /** Values that disable a session-level feature through its environment variable. */
 const DISABLED_ENV_VALUES = new Set(["0", "false", "off", "disable", "disabled"]);
@@ -93,12 +98,12 @@ import { classifyPromptCacheTransition } from "./prompt-cache.js";
 import * as promptSettlement from "./prompt-settlement.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { isQuotaExhaustionMessage, isStickySafetyModel, isUpstreamUnavailableMessage, pickFailoverCandidate, resolveFailoverCandidates, resolveProviderResilience, sameModelRouteCandidates, shouldEjectStickySafetyModel, shouldHonorSafetyFailover, stickySafetyBlockMessage, } from "./provider-resilience.js";
-import { computeRetryDelayMs, failoverModelKey, isFailoverTriggerError, isRetryableAssistantError, nextRetryAttempt, retryBudgetForAssistantError, } from "./provider-retry.js";
+import { computeRetryDelayMs, failoverModelKey, isEmptyStreamedCompletion, isFailoverTriggerError, isRetryableAssistantError, nextRetryAttempt, retryBudgetForAssistantError, } from "./provider-retry.js";
 import { getBiasStepsForCell, parseRouterBiasSnapshot } from "./reasoning-router-bias.js";
 import { classifyTaskV4, deriveRouterFeedbackFeaturesV4, resolveThinkingLevelV4WithUncertainty, TASK_CLASS_THINKING_LEVELS_V4, } from "./reasoning-router-v4.js";
 import { redactSensitiveText, redactSensitiveTextForced } from "./redaction.js";
 import { getRepositoryRouterLearningPaths } from "./repository-learning-scope.js";
-import { decideResourceAdmission } from "./resource-admission.js";
+import { createResourcePressureStabilizer, decideResourceAdmission, evaluateResourcePressure, rederiveResourceAdmissionForPressure, } from "./resource-admission.js";
 import { resolveResourceGovernorSettings } from "./resource-governor-settings.js";
 import { admissionObservationFacts, classificationObservationFacts, ResourceObservationJournal, settledObservationFacts, snapshotObservationFacts, soundObservationFacts, } from "./resource-observation-journal.js";
 import { decideResourceSafetyGate, RESOURCE_PRESSURE_REQUIRED_ACTION } from "./resource-safety-gate.js";
@@ -288,6 +293,10 @@ export class AgentSession {
     _resourceObservationJournals = new Map();
     _latestResourcePromptRunId = null;
     _lastResourceAdmission = null;
+    // Per-session pressure hysteresis (audit §16.1): escalation is immediate,
+    // recovery requires consecutive healthier probes so the applied cap does
+    // not flap around a threshold between prompts.
+    _resourcePressureStabilizer;
     _workloadPermitPool;
     _pendingRuntimeTerminationCause;
     _activeRunToolTermination;
@@ -534,6 +543,12 @@ export class AgentSession {
         this._emit({ type: "session_termination", termination });
     }
     _publishRuntimeFailure(error) {
+        // A caller rejected by "Agent is already processing" never owned a run: the
+        // open journal run belongs to the live run, and closing it here would make
+        // that run die later with "agent_end without run_started". Let the caller
+        // surface its own error and leave the live run's journal alone.
+        if (this.isStreaming)
+            return;
         const cause = this._pendingRuntimeTerminationCause ?? runtimeFailureCause(error);
         const runId = this._activeRunId ?? `runtime-${randomUUID()}`;
         const timestamp = new Date().toISOString();
@@ -854,8 +869,13 @@ export class AgentSession {
                     this._overflowRecoveryAttempts = 0;
                 }
                 // Reset retry counter immediately on successful assistant response
-                // This prevents accumulation across multiple LLM calls within a turn
-                if (assistantMsg.stopReason !== "error" && this._retryAttempt > 0) {
+                // This prevents accumulation across multiple LLM calls within a turn.
+                // An empty streamed completion wears a success shape (stop=stop, zero
+                // usable output) but is a dead stream — counting it as success reset
+                // the budget every cycle and retried forever (union-alpha relay loop).
+                if (assistantMsg.stopReason !== "error" &&
+                    !isEmptyStreamedCompletion(assistantMsg) &&
+                    this._retryAttempt > 0) {
                     this._emit({
                         type: "auto_retry_end",
                         success: true,
@@ -1364,16 +1384,19 @@ export class AgentSession {
      * Extract the most recent user query text from conversation messages.
      * Returns undefined when no user message exists or content is empty.
      * Handles both string content and multimodal (array) content.
+     *
+     * The scan walks the whole transcript backwards and stops at the first user
+     * message. A fixed tail window cannot work here: tool results are their own
+     * messages, so a single turn that calls two tools already leaves
+     * `[user, assistant, toolResult, toolResult]` and buries the task four deep.
+     * Losing it mid-turn collapses every skill to the neutral relevance score and
+     * degrades ranking to catalogue order, precisely while tools are running and
+     * a matching skill matters most.
      */
     _extractCurrentQuery() {
         const messages = this.messages;
-        if (messages.length === 0) {
-            return undefined;
-        }
-        // Scan recent messages (last 3) for the most recent user message
-        const recent = messages.slice(-3);
-        for (let i = recent.length - 1; i >= 0; i--) {
-            const msg = recent[i];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
             if (!msg || !("role" in msg) || msg.role !== "user") {
                 continue;
             }
@@ -1470,7 +1493,7 @@ export class AgentSession {
             toolPromptGuidelines: this._toolPromptGuidelines,
             customPrompt: this._resourceLoader.getSystemPrompt(),
             appendSystemPrompt: this._resourceLoader.getAppendSystemPrompt(),
-            providerAppend: grokPlaybookAppendForProvider(model?.provider),
+            providerAppend: grokPlaybookAppendForProvider(model?.provider) ?? devinPlaybookAppendForProvider(model?.provider),
             skills: this._resourceLoader.getSkills().skills,
             activeSkillNames: defaultActiveSkills,
             activeSkillSource: defaultActiveSkills.length > 0 ? "settings" : undefined,
@@ -1569,8 +1592,12 @@ export class AgentSession {
             }
             const snapshot = await captureHostResourceSnapshot(probeOptions);
             const decision = decideResourceAdmission({ snapshot, config: resolved.admission, configuredCaps });
+            const stabilized = this._stabilizeResourcePressure(snapshot, resolved);
+            const appliedDecision = stabilized === decision.pressure
+                ? decision
+                : rederiveResourceAdmissionForPressure(decision, resolved.admission.caps, configuredCaps, stabilized);
             if (this._latestResourcePromptRunId === promptRunId) {
-                this._lastResourceAdmission = decision;
+                this._lastResourceAdmission = appliedDecision;
             }
             resourceObservations?.record("resource_snapshot_v1", snapshotObservationFacts(snapshot));
             resourceObservations?.record("resource_admission_v1", admissionObservationFacts(decision));
@@ -1580,7 +1607,7 @@ export class AgentSession {
                     this.agent.maxToolConcurrency = cap;
                 },
             });
-            const lease = this._resourceLeaseController.acquire({ promptRunId, decision });
+            const lease = this._resourceLeaseController.acquire({ promptRunId, decision: appliedDecision });
             resourceObservations?.record("resource_lease_acquired_v1", {
                 decisionId: decision.decisionId,
                 appliedToolCap: decision.maxToolConcurrency,
@@ -1591,6 +1618,15 @@ export class AgentSession {
             return null;
         }
     }
+    /**
+     * Feed one snapshot's raw pressure through the per-session stabilizer.
+     * Created lazily so sessions that never probe carry no state; the first
+     * observation installs its own level directly (no warmup lag).
+     */
+    _stabilizeResourcePressure(snapshot, resolved) {
+        this._resourcePressureStabilizer ??= createResourcePressureStabilizer();
+        return this._resourcePressureStabilizer.observe(evaluateResourcePressure(snapshot, resolved.admission.thresholds));
+    }
     _openResourceObservations(promptRunId) {
         this._latestResourcePromptRunId = promptRunId;
         try {
@@ -1626,6 +1662,30 @@ export class AgentSession {
     getCurrentResourceAdmission() {
         return this._lastResourceAdmission;
     }
+    /**
+     * Spec 020 Req1 — canonical subagent lane authority bound to this session.
+     * Rebuilt on each call so it tracks the live admission decision, shared
+     * permit pool, and open prompt run. Extension tool contexts read it through
+     * `ctx.getSubagentLaneAuthority()`.
+     */
+    _getSubagentLaneAuthority() {
+        const hookInventory = loadHookInventory(getAgentDir());
+        const sessionView = {
+            _baseToolDefinitions: this._baseToolDefinitions,
+            _extensionRunner: this._extensionRunner,
+            _customTools: this._customTools,
+        };
+        const inventory = buildCapabilityInventory(sessionView, this._resourceLoader, this._cwd, hookInventory);
+        return createSubagentLaneAuthority({
+            runId: this._activeRunId ?? `session-${this.sessionManager.getSessionId() ?? "unknown"}`,
+            promptRunId: this._promptLifecycle.activePromptRunId,
+            decision: this._lastResourceAdmission,
+            permitPool: this.workloadPermitPool,
+            inventory,
+            signal: this.agent?.signal,
+            noteDetachedChild: () => this._promptLifecycle.noteDetachedChild(),
+        });
+    }
     /** §19.4 read-only SDK surface: capture a fresh host resource snapshot. */
     async getHostResourceSnapshot() {
         const resolved = resolveResourceGovernorSettings(this.settingsManager.getResourceGovernorSettings());
@@ -1734,12 +1794,15 @@ export class AgentSession {
         if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
             return true;
         }
-        if (msg.stopReason === "error" && this._retryAttempt > 0) {
+        // The retry budget is exhausted without a real answer. This covers the
+        // empty-streamed-completion path whose success-shaped stopReason
+        // otherwise left the UI pinned in the retrying state forever.
+        if (this._retryAttempt > 0) {
             this._emit({
                 type: "auto_retry_end",
                 success: false,
                 attempt: this._retryAttempt,
-                finalError: msg.errorMessage,
+                finalError: msg.errorMessage ?? "The provider returned an empty response.",
             });
             this._retryAttempt = 0;
             this._refusedModels.clear();
@@ -1893,6 +1956,13 @@ export class AgentSession {
                 });
                 promptSkills = addActiveSkills(promptSkills, grokSkills, "grok-harness");
             }
+            else if (isDevinProvider(this.model?.provider) && devinHarnessAutoApplyEnabled(process.env)) {
+                const skillQuery = isBangSkillInvocation ? currentText : expandedText;
+                const devinSkills = selectDevinHarnessSkills(skillQuery, this._resourceLoader.getSkills().skills, {
+                    contextPressure: this._computePressureBucket(messages) > 0,
+                });
+                promptSkills = addActiveSkills(promptSkills, devinSkills, "devin-harness");
+            }
             const turnSystemPromptOptions = {
                 ...this._baseSystemPromptOptions,
                 contextBudget: this._getContextBudgetOptions(expandedText),
@@ -2124,7 +2194,10 @@ export class AgentSession {
         if (options?.deliverAs === "nextTurn") {
             this._pendingNextTurnMessages.push(appMessage);
         }
-        else if (this.isStreaming) {
+        else if (this.isStreaming || this.isRetrying) {
+            // Retry backoff still owns the session (mirrors prompt()): starting a
+            // top-level run here races the pending agent.continue() and wedges the
+            // run journal, so queue for the retried run to drain instead.
             if (options?.deliverAs === "followUp") {
                 this.agent.followUp(appMessage);
             }
@@ -2991,8 +3064,13 @@ export class AgentSession {
     /**
      * Effective context window for the upcoming turn.
      * Image-bearing turns with a text-only session model are auto-routed to the
-     * vision model (gpt-5.6-luna, 1M) — that window is the real limit. Text-only
-     * turns keep the session model's (typically much larger) window.
+     * vision model (gpt-5.6-luna, 1M), so the request has to fit both windows and
+     * the binding limit is the smaller one. Session windows fall on both sides of
+     * 1M: most catalogued models are smaller (median near 300K) and keep their own
+     * window as the limit, while the larger-than-1M models are the ones the clamp
+     * exists for — without it their threshold is computed against a window the
+     * vision route will not honour, and the request overflows before compaction
+     * fires. Text-only turns keep the session model's window untouched.
      */
     _effectiveTurnContextWindow(pendingMessages, sessionWindow) {
         // Vision routing keys off the full transcript, not just the pending turn:
@@ -3271,16 +3349,25 @@ export class AgentSession {
             // the compaction_end event (so the TUI flushes its queued messages
             // correctly) and the return value below.
             const resumeMessages = this.agent.state.messages;
-            let lastAssistantMsg;
-            for (let i = resumeMessages.length - 1; i >= 0; i--) {
-                const candidate = resumeMessages[i];
-                if (candidate.role === "assistant") {
-                    lastAssistantMsg = candidate;
-                    break;
-                }
-            }
+            const lastAssistantMsg = this._findLastAssistantMessage();
             const endedCleanly = lastAssistantMsg?.stopReason === "stop";
             const willResume = this.agent.hasQueuedMessages() || !endedCleanly;
+            // overflow-retry-guard 배선: 압축 후 재전송 컨텍스트가 창을 확실히 초과하면
+            // 재시도는 프로바이더 왕복만 소모한다 — 정확한 수치 진단과 함께 차단한다.
+            const overflowBlock = willRetry
+                ? overflowRetryBlocked(resumeMessages, this.model?.contextWindow ?? 0)
+                : undefined;
+            if (overflowBlock !== undefined) {
+                this._emit({
+                    type: "compaction_end",
+                    reason,
+                    result,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage: overflowBlock,
+                });
+                return false;
+            }
             const emitWillRetry = compactionEmitWillRetry(willRetry, willResume);
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry: emitWillRetry });
             if (willRetry) {
@@ -3517,6 +3604,10 @@ export class AgentSession {
             },
             getSystemPrompt: () => this.systemPrompt,
             getSystemPromptOptions: () => this._baseSystemPromptOptions,
+            // Spec 020 Req1 — session-bound lane authority for extension tool
+            // contexts (subagent spawn funnel). Rebuilt on demand so it always
+            // sees the live admission decision, permit pool, and prompt run.
+            getSubagentLaneAuthority: () => this._getSubagentLaneAuthority(),
         }, {
             registerProvider: (name, config) => {
                 this._modelRegistry.registerProvider(name, config);
@@ -3948,10 +4039,13 @@ export class AgentSession {
         if (attempt === undefined)
             return false;
         this._retryAttempt = attempt;
-        // Upstream-unavailable (gateway 5xx / dropped stream): rotate to another
-        // authenticated route of the SAME model family so the retry lands on a
-        // live endpoint instead of hammering the dead one.
-        const rotatedTo = isUpstreamUnavailableMessage(message.errorMessage)
+        // Upstream-unavailable (gateway 5xx / dropped stream / dead relay stream):
+        // rotate to another authenticated route of the SAME model family so the
+        // retry lands on a live endpoint instead of hammering the dead one. An
+        // empty streamed completion is the same dead-stream signature wearing a
+        // success stopReason, so it rotates too — otherwise the retry re-hits the
+        // route that just returned nothing.
+        const rotatedTo = isUpstreamUnavailableMessage(message.errorMessage) || isEmptyStreamedCompletion(message)
             ? await this._maybeRotateModelRoutes()
             : undefined;
         // Content/safety stop (Fable/Opus/Sonnet): switch model BEFORE delay so retry is not same-model refusal.