@caupulican/pi-adaptative 0.81.40 → 0.81.42

package/dist/modes/interactive/session-flow-commands.js

@@ -10,10 +10,11 @@
  * `handleSessionCommand`) take their own minimal host shapes so their behaviour
  * tests keep exercising them through interactive-mode's thin wrappers unchanged.
  */
+import { randomUUID } from "node:crypto";
 import { Loader, Spacer, Text } from "@caupulican/pi-tui";
-import { resumeBlockedPersistedGoal, resumePersistedGoal } from "../../core/goals/goal-lifecycle.js";
+import { cancelPersistedGoal, clearPersistedGoal, editPersistedGoal, getGoalStateRevision, pausePersistedGoal, replaceGoal, resumeGoal, resumePersistedGoal, } from "../../core/goals/goal-lifecycle.js";
 import { applyGoalAction, completeGoalManually } from "../../core/goals/goal-tool-core.js";
-import { findExactModelReferenceMatch, resolveModelScope } from "../../core/model-resolver.js";
+import { findExactModelReferenceMatch, resolveModelScope, resolveModelScopeWithDiagnostics, } from "../../core/model-resolver.js";
 import { MissingSessionCwdError } from "../../core/session-cwd.js";
 import { listAllSessions, listSessions, openSession } from "../../core/session-manager-factory.js";
 import { parseTaskCommand } from "../../core/tasks/task-command.js";
@@ -67,12 +68,17 @@ export async function showModelsSelector(host) {
     // Get all available models
     host.session.modelRegistry.refresh();
     const allModels = host.session.modelRegistry.getAvailable();
-    if (allModels.length === 0) {
+    const allModelIds = new Set(allModels.map((model) => `${model.provider}/${model.id}`));
+    const configuredPatterns = host.settingsManager.getEnabledModels();
+    const sessionScopedModels = host.session.scopedModels;
+    if (allModels.length === 0 && !configuredPatterns?.length && sessionScopedModels.length === 0) {
         host.showStatus("No models available");
         return;
     }
+    const configuredScope = configuredPatterns?.length
+        ? await resolveModelScopeWithDiagnostics(configuredPatterns, host.session.modelRegistry)
+        : undefined;
     // Check if session has scoped models (from previous session-only changes or CLI --models)
-    const sessionScopedModels = host.session.scopedModels;
     const hasSessionScope = sessionScopedModels.length > 0;
     // Build enabled model IDs from session state or settings
     let currentEnabledIds = null;
@@ -80,18 +86,22 @@ export async function showModelsSelector(host) {
         // Use current session's scoped models
         currentEnabledIds = sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
     }
-    else {
-        // Fall back to settings
-        const patterns = host.settingsManager.getEnabledModels();
-        if (patterns !== undefined && patterns.length > 0) {
-            const scopedModels = await resolveModelScope(patterns, host.session.modelRegistry);
-            currentEnabledIds = scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
-        }
+    else if (configuredScope) {
+        currentEnabledIds = configuredScope.scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+    }
+    for (const diagnostic of configuredScope?.diagnostics ?? []) {
+        if (diagnostic.code !== "no-match")
+            continue;
+        currentEnabledIds ??= [];
+        if (!currentEnabledIds.includes(diagnostic.pattern))
+            currentEnabledIds.push(diagnostic.pattern);
     }
     // Helper to update session's scoped models (session-only, no persist)
     const updateSessionModels = async (enabledIds) => {
         currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-        if (enabledIds && enabledIds.length > 0 && enabledIds.length < allModels.length) {
+        const hasEnabledAvailableModel = enabledIds?.some((id) => allModelIds.has(id)) ?? false;
+        const allAvailableModelsEnabled = enabledIds !== null && [...allModelIds].every((id) => enabledIds.includes(id));
+        if (enabledIds && hasEnabledAvailableModel && !allAvailableModelsEnabled) {
             const newScopedModels = await resolveModelScope(enabledIds, host.session.modelRegistry);
             host.session.setScopedModels(newScopedModels.map((sm) => ({
                 model: sm.model,
@@ -115,9 +125,10 @@ export async function showModelsSelector(host) {
             },
             onPersist: (enabledIds) => {
                 // Persist to settings
-                const newPatterns = enabledIds === null || enabledIds.length === allModels.length
-                    ? undefined // All enabled = clear filter
-                    : enabledIds;
+                const allEnabled = enabledIds !== null &&
+                    enabledIds.length === allModels.length &&
+                    enabledIds.every((id) => allModelIds.has(id));
+                const newPatterns = enabledIds === null || allEnabled ? undefined : enabledIds;
                 host.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
                 host.showStatus("Model selection saved to settings");
             },
@@ -313,19 +324,30 @@ export function showSessionSelector(host) {
         return { component: selector, focus: selector };
     });
 }
-async function switchSessionAndResumeGoal(host, sessionPath, options, cwdOverride) {
-    let goalResume = { ok: true, resumed: false };
-    const result = await host.runtimeHost.switchSession(sessionPath, {
+async function switchSession(host, sessionPath, options, cwdOverride) {
+    return host.runtimeHost.switchSession(sessionPath, {
         cwdOverride,
-        beforeSessionResourcesStart: (session) => {
-            const resumed = resumeBlockedGoalAfterSessionSwitch(session, () => host.refreshAutonomyFooterStatus());
-            if (!resumed.ok)
-                throw new Error(`Goal resume failed: ${resumed.error}`);
-            goalResume = resumed;
-        },
         withSession: options?.withSession,
     });
-    return { ...result, goalResume };
+}
+async function offerRestoredGoalResume(host) {
+    const state = host.session.getGoalStateSnapshot();
+    if (!state || (state.status !== "paused" && state.status !== "blocked" && state.status !== "usage_limited")) {
+        host.session.restoreGoalRuntimeAfterResume();
+        return false;
+    }
+    const choice = await host.extensionUiHost?.showExtensionSelector("Resume stopped goal?", [
+        "Resume goal",
+        "Leave stopped",
+    ]);
+    if (choice !== "Resume goal")
+        return false;
+    const resumed = resumePersistedGoal(host.session);
+    if (!resumed.ok)
+        throw new Error(`Goal resume failed: ${resumed.error}`);
+    host.session.restoreGoalRuntimeAfterResume();
+    host.refreshAutonomyFooterStatus();
+    return true;
 }
 export async function handleResumeSession(host, sessionPath, options) {
     if (host.loadingAnimation) {
@@ -334,12 +356,13 @@ export async function handleResumeSession(host, sessionPath, options) {
     }
     host.statusContainer.clear();
     try {
-        const result = await switchSessionAndResumeGoal(host, sessionPath, options);
+        const result = await switchSession(host, sessionPath, options);
         if (result.cancelled) {
             return result;
         }
         host.renderCurrentSessionState();
-        host.showStatus(result.goalResume.resumed ? "Resumed session and goal" : "Resumed session");
+        const goalResumed = await offerRestoredGoalResume(host);
+        host.showStatus(goalResumed ? "Resumed session and goal" : "Resumed session; goal state preserved");
         return result;
     }
     catch (error) {
@@ -353,12 +376,15 @@ export async function handleResumeSession(host, sessionPath, options) {
                 return { cancelled: true };
             }
             try {
-                const result = await switchSessionAndResumeGoal(host, sessionPath, options, selectedCwd);
+                const result = await switchSession(host, sessionPath, options, selectedCwd);
                 if (result.cancelled) {
                     return result;
                 }
                 host.renderCurrentSessionState();
-                host.showStatus(result.goalResume.resumed ? "Resumed session and goal in current cwd" : "Resumed session in current cwd");
+                const goalResumed = await offerRestoredGoalResume(host);
+                host.showStatus(goalResumed
+                    ? "Resumed session and goal in current cwd"
+                    : "Resumed session in current cwd; goal state preserved");
                 return result;
             }
             catch (retryError) {
@@ -425,15 +451,10 @@ export function resumeCurrentGoal(host, now = new Date().toISOString()) {
     const resumed = resumePersistedGoal(host.session, now);
     if (!resumed.ok)
         return resumed;
+    host.session.restoreGoalRuntimeAfterResume();
     host.refreshAutonomyFooterStatus();
     return { ok: true, resumed: true, state: resumed.state };
 }
-function resumeBlockedGoalAfterSessionSwitch(session, refreshAutonomyFooterStatus) {
-    const resumed = resumeBlockedPersistedGoal(session);
-    if (resumed.ok && resumed.resumed)
-        refreshAutonomyFooterStatus();
-    return resumed;
-}
 function formatGoalStatus(snapshot) {
     const state = snapshot.goalState;
     if (!state)
@@ -444,12 +465,17 @@ function formatGoalStatus(snapshot) {
     });
     const blockedReason = state.blockedReason ? `\nBlocked reason: ${state.blockedReason}` : "";
     const requirementDetails = requirements.length > 0 ? `\n${requirements.join("\n")}` : "";
-    return `Goal: ${state.userGoal}\nStatus: ${state.status}${blockedReason}\nRequirements: open ${snapshot.continuation.openRequirementIds.length}, blocked ${snapshot.continuation.blockedRequirementIds.length}, satisfied ${snapshot.continuation.satisfiedRequirementIds.length}${requirementDetails}\nContinuation: ${snapshot.continuation.action}/${snapshot.continuation.reasonCode}\nControls: /goal resume | /goal reopen <requirement-id> | /goal complete | /goal close | /goal override <text>`;
+    const tokenUsage = state.tokenBudget !== undefined
+        ? `\nTokens: ${state.tokensUsed ?? 0}/${state.tokenBudget}`
+        : (state.tokensUsed ?? 0) > 0
+            ? `\nTokens: ${state.tokensUsed ?? 0}`
+            : "";
+    return `Goal: ${state.userGoal}\nStatus: ${state.status}${blockedReason}${tokenUsage}\nRequirements: open ${snapshot.continuation.openRequirementIds.length}, blocked ${snapshot.continuation.blockedRequirementIds.length}, satisfied ${snapshot.continuation.satisfiedRequirementIds.length}${requirementDetails}\nContinuation: ${snapshot.continuation.action}/${snapshot.continuation.reasonCode}\nControls: /goal edit | /goal pause | /goal resume | /goal reopen <requirement-id> | /goal complete | /goal clear | /goal override <text>`;
 }
 export async function handleGoalCommand(host, text) {
     const input = text.replace(/^\/goal\s*/, "").trim();
     if (!input || input === "status") {
-        host.showStatus(formatGoalStatus(host.session.getGoalRuntimeSnapshot({ maxStallTurns: 20 })));
+        host.showStatus(formatGoalStatus(host.session.getGoalRuntimeSnapshot({ maxStallTurns: host.getMaxStallTurns?.() ?? 20 })));
         return;
     }
     const now = new Date().toISOString();
@@ -463,24 +489,61 @@ export async function handleGoalCommand(host, text) {
         host.showStatus("Goal resumed.");
         return;
     }
+    if (input === "pause") {
+        const paused = pausePersistedGoal(host.session, now);
+        if (!paused.ok) {
+            host.showError(paused.error);
+            return;
+        }
+        host.showStatus("Goal paused.");
+        host.refreshAutonomyFooterStatus();
+        return;
+    }
+    if (input === "edit" || input.startsWith("edit ")) {
+        const inlineObjective = input.slice("edit".length).trim();
+        const objective = inlineObjective || (current ? await host.promptForGoalEdit?.(current.userGoal) : undefined);
+        if (!objective) {
+            host.showError(current ? "Usage: /goal edit <objective>" : "No goal exists to edit.");
+            return;
+        }
+        const edited = editPersistedGoal(host.session, { userGoal: objective }, now);
+        if (!edited.ok) {
+            host.showError(edited.error);
+            return;
+        }
+        if (edited.state.status === "active")
+            host.session.restoreGoalRuntimeAfterResume();
+        host.showStatus("Goal updated.");
+        host.refreshAutonomyFooterStatus();
+        return;
+    }
     if (input === "complete") {
         const completed = completeGoalManually(current, now);
         if (!completed.ok) {
             host.showError(completed.error);
             return;
         }
-        host.session.saveGoalStateSnapshot(completed.state);
+        host.session.saveGoalStateSnapshot(completed.state, current ? getGoalStateRevision(current) : undefined);
         host.showStatus("Goal completed manually.");
         host.refreshAutonomyFooterStatus();
         return;
     }
+    if (input === "clear") {
+        const cleared = clearPersistedGoal(host.session, now);
+        if (!cleared.ok) {
+            host.showError(cleared.error);
+            return;
+        }
+        host.showStatus(cleared.cleared ? "Goal cleared." : "No goal exists to clear.");
+        host.refreshAutonomyFooterStatus();
+        return;
+    }
     if (input === "close" || input === "cancel") {
-        const cancelled = applyGoalAction(current, { action: "cancel" }, now);
+        const cancelled = cancelPersistedGoal(host.session, now);
         if (!cancelled.ok) {
             host.showError(cancelled.error);
             return;
         }
-        host.session.saveGoalStateSnapshot(cancelled.state);
         host.showStatus("Goal closed.");
         host.refreshAutonomyFooterStatus();
         return;
@@ -504,7 +567,7 @@ export async function handleGoalCommand(host, text) {
         }
         let active = current;
         if (active.status === "blocked") {
-            const resumed = resumePersistedGoal(host.session, now);
+            const resumed = resumeGoal(active, now);
             if (!resumed.ok) {
                 host.showError(resumed.error);
                 return;
@@ -516,7 +579,9 @@ export async function handleGoalCommand(host, text) {
             host.showError(reopened.error);
             return;
         }
-        host.session.saveGoalStateSnapshot(reopened.state);
+        host.session.saveGoalStateSnapshot(reopened.state, getGoalStateRevision(current));
+        if (reopened.state.status === "active")
+            host.session.restoreGoalRuntimeAfterResume();
         host.showStatus(`Requirement '${requirementId}' reopened${current.status === "blocked" ? " and goal resumed" : ""}.`);
         host.refreshAutonomyFooterStatus();
         return;
@@ -527,40 +592,26 @@ export async function handleGoalCommand(host, text) {
         host.showError("Usage: /goal override <text>");
         return;
     }
-    let startFrom = current;
-    if (overriding && startFrom && (startFrom.status === "active" || startFrom.status === "blocked")) {
-        const cancelled = applyGoalAction(startFrom, { action: "cancel" }, now);
-        if (!cancelled.ok) {
-            host.showError(cancelled.error);
-            return;
-        }
-        startFrom = cancelled.state;
-        host.session.saveGoalStateSnapshot(startFrom);
-    }
-    const goalId = `goal-${Date.now().toString(36)}`;
-    const started = applyGoalAction(startFrom, { action: "start", goalId, userGoal: goalText }, now);
+    const goalId = `goal-${randomUUID()}`;
+    const started = overriding
+        ? replaceGoal({ goalId, userGoal: goalText }, now)
+        : applyGoalAction(current, { action: "start", goalId, userGoal: goalText }, now);
     if (!started.ok) {
         host.showError(`${started.error} Use /goal override <text> to replace it explicitly.`);
         return;
     }
-    host.session.saveGoalStateSnapshot(started.state);
-    // Deterministic producer completion: a goal with zero open requirements evaluates to
-    // finalize/no_open_requirements, so the loop would be undrivable whenever the model skips
-    // decomposition (observed in the field). Seed one requirement from the goal text itself —
-    // the model's decomposition below refines alongside it.
-    const seeded = applyGoalAction(started.state, { action: "add_requirement", requirementId: `${goalId}-r1`, text: goalText }, now);
-    if (seeded.ok) {
-        host.session.saveGoalStateSnapshot(seeded.state);
-    }
-    await host.session.sendUserMessage(`Start goal: ${goalText}\n\nUse the goal tool this turn to decompose this goal into concrete open requirements with add_requirement actions, and satisfy_requirement ${goalId}-r1 once the decomposed requirements cover it.`);
+    host.session.saveGoalStateSnapshot(started.state, current ? getGoalStateRevision(current) : undefined);
     const verb = overriding ? "overridden" : "started";
     try {
-        const result = await host.session.continueGoalLoop({ maxTurns: 1, maxStallTurns: 20, maxWallClockMinutes: 0 });
+        // Submit one bootstrap pass, then yield to the event-driven idle scheduler. This is a scheduling
+        // quantum, not a goal ceiling: an active goal is immediately rearmed and the configured goal turn
+        // limit (unbounded by default) governs subsequent continuation.
+        const result = await host.session.continueGoalLoop({
+            maxTurns: 1,
+            maxStallTurns: host.getMaxStallTurns?.() ?? 20,
+            maxWallClockMinutes: 0,
+        });
         if (result.stopReason === "already_continuing") {
-            // The idle autosteer timer armed by `sendUserMessage` above already won the single-flight
-            // guard (`BackgroundLaneController.continueGoalLoopExclusive`) — this request never ran a
-            // pass, so reporting `finalSnapshot.continuation` here would misleadingly imply a fresh
-            // decision was made.
             host.showStatus(`Goal ${verb}: the autonomy loop is already continuing this goal.`);
         }
         else if (result.stopReason === "session_disposed") {
@@ -569,6 +620,8 @@ export async function handleGoalCommand(host, text) {
         else {
             const continuation = result.finalSnapshot.continuation;
             host.showStatus(`Goal ${verb}: ${continuation.action}/${continuation.reasonCode}.`);
+            if (continuation.action === "continue")
+                host.session.restoreGoalRuntimeAfterResume();
         }
     }
     catch (error) {
@@ -625,7 +678,7 @@ export async function handleGoalContinueCommand(host, text) {
         host.showError(parsed.error);
         return;
     }
-    host.showStatus(`Goal continuation started: up to ${parsed.maxTurns} turn(s), stall limit ${parsed.maxStallTurns}, wall-clock limit ${parsed.maxWallClockMinutes || "disabled"} minute(s).`);
+    host.showStatus(`Goal continuation started: ${parsed.maxTurns === 0 ? "unbounded turns" : `up to ${parsed.maxTurns} turn(s)`}, stall limit ${parsed.maxStallTurns}, wall-clock limit ${parsed.maxWallClockMinutes || "disabled"} minute(s).`);
     try {
         const result = await host.session.continueGoalLoop({
             maxTurns: parsed.maxTurns,