@caupulican/pi-adaptative 0.81.39 → 0.81.41

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

@@ -10,9 +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 { 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";
@@ -25,6 +27,7 @@ import { SessionSelectorComponent } from "./components/session-selector.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { TrustSelectorComponent } from "./components/trust-selector.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
+import { handleNonFatalSessionReplacementError } from "./session-replacement-errors.js";
 import { theme } from "./theme/theme.js";
 export async function showModelSelector(host, initialSearchInput) {
     try {
@@ -65,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;
@@ -78,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,
@@ -113,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");
             },
@@ -311,6 +324,31 @@ export function showSessionSelector(host) {
         return { component: selector, focus: selector };
     });
 }
+async function switchSession(host, sessionPath, options, cwdOverride) {
+    return host.runtimeHost.switchSession(sessionPath, {
+        cwdOverride,
+        withSession: options?.withSession,
+    });
+}
+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) {
         host.loadingAnimation.stop();
@@ -318,33 +356,43 @@ export async function handleResumeSession(host, sessionPath, options) {
     }
     host.statusContainer.clear();
     try {
-        const result = await host.runtimeHost.switchSession(sessionPath, {
-            withSession: options?.withSession,
-        });
+        const result = await switchSession(host, sessionPath, options);
         if (result.cancelled) {
             return result;
         }
         host.renderCurrentSessionState();
-        host.showStatus("Resumed session");
+        const goalResumed = await offerRestoredGoalResume(host);
+        host.showStatus(goalResumed ? "Resumed session and goal" : "Resumed session; goal state preserved");
         return result;
     }
     catch (error) {
+        const disposition = handleNonFatalSessionReplacementError(host, error);
+        if (disposition)
+            return { cancelled: disposition === "previous_restored" };
         if (error instanceof MissingSessionCwdError) {
             const selectedCwd = await host.promptForMissingSessionCwd(error);
             if (!selectedCwd) {
                 host.showStatus("Resume cancelled");
                 return { cancelled: true };
             }
-            const result = await host.runtimeHost.switchSession(sessionPath, {
-                cwdOverride: selectedCwd,
-                withSession: options?.withSession,
-            });
-            if (result.cancelled) {
+            try {
+                const result = await switchSession(host, sessionPath, options, selectedCwd);
+                if (result.cancelled) {
+                    return result;
+                }
+                host.renderCurrentSessionState();
+                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;
             }
-            host.renderCurrentSessionState();
-            host.showStatus("Resumed session in current cwd");
-            return result;
+            catch (retryError) {
+                const retryDisposition = handleNonFatalSessionReplacementError(host, retryError);
+                if (retryDisposition)
+                    return { cancelled: retryDisposition === "previous_restored" };
+                return host.handleFatalRuntimeError("Failed to resume session", retryError);
+            }
         }
         return host.handleFatalRuntimeError("Failed to resume session", error);
     }
@@ -398,6 +446,15 @@ export async function handleCloneCommand(host, newSessionName) {
         host.showError(error instanceof Error ? error.message : String(error));
     }
 }
+/** Canonical persisted transition used by both `/goal resume` and session `/resume`. */
+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 formatGoalStatus(snapshot) {
     const state = snapshot.goalState;
     if (!state)
@@ -408,24 +465,55 @@ 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();
     const current = host.session.getGoalStateSnapshot();
     if (input === "resume") {
-        const resumed = applyGoalAction(current, { action: "resume_goal" }, now);
+        const resumed = resumeCurrentGoal(host, now);
         if (!resumed.ok) {
             host.showError(resumed.error);
             return;
         }
-        host.session.saveGoalStateSnapshot(resumed.state);
         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;
     }
@@ -435,18 +523,27 @@ export async function handleGoalCommand(host, text) {
             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;
@@ -470,20 +567,21 @@ export async function handleGoalCommand(host, text) {
         }
         let active = current;
         if (active.status === "blocked") {
-            const resumed = applyGoalAction(active, { action: "resume_goal" }, now);
+            const resumed = resumeGoal(active, now);
             if (!resumed.ok) {
                 host.showError(resumed.error);
                 return;
             }
             active = resumed.state;
-            host.session.saveGoalStateSnapshot(active);
         }
         const reopened = applyGoalAction(active, { action: "reopen_requirement", requirementId }, now);
         if (!reopened.ok) {
             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;
@@ -494,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") {
@@ -536,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) {
@@ -592,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,