@prestyj/cli 5.30.1 → 5.30.3

package/dist/app-sidecar.js

@@ -42,7 +42,7 @@ import { SettingsManager } from "./core/settings-manager.js";
 import { getModel, getDefaultThinkingLevel, getContextWindow, clearRuntimeModels, registerRuntimeModels, } from "./core/model-registry.js";
 import { resolveStartOrFallback } from "./core/resolve-start.js";
 import { getGitBranch, getGitDirtyFileCount, isGitRepo } from "./utils/git.js";
-import { getGitHubRepoSlug } from "./utils/github.js";
+import { scoreProjectHealth } from "./core/project-health-score.js";
 import { createRepoPolls } from "./app-sidecar/repo-polls.js";
 import { extractPlanSteps } from "./utils/plan-steps.js";
 import { getSupportedThinkingLevels, isThinkingLevelSupported } from "./core/thinking-level.js";
@@ -54,7 +54,7 @@ import { installTerminationHandlers } from "./core/shutdown.js";
 import { stopRadio } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
 import { createElicitationBridge } from "./core/mcp/index.js";
-import { askSoftDeadlineMs, createAskUserBridge, deliverLateAnswer } from "./core/ask-user.js";
+import { askSoftDeadlineMs, createAskUserBridge, deliverLateAnswer, } from "./core/ask-user.js";
 import { createAskUserTool } from "./tools/ask-user.js";
 import { createUsageService } from "./app-sidecar/usage.js";
 import { daemonReadBody, daemonJson, json } from "./app-sidecar/http.js";
@@ -64,6 +64,10 @@ import { ALL_PROVIDERS, loadProjectModelPrefs, loadNolanModelPref, loadAutopilot
 import { NOLAN_ALLOWED_TOOLS } from "./app-sidecar/nolan-context.js";
 import { createProgressManager } from "./app-sidecar/progress-manager.js";
 import { handleSessionRoutes } from "./app-sidecar/session-routes.js";
+import { handleGoalRoutes } from "./app-sidecar/goal-routes.js";
+import { readGitState, resolveGitCwd } from "./app-sidecar/git-target.js";
+import { goalPhase, goalsRoot, isGoalDir, startGoalOnAnswer, readGoal, } from "./core/goals-store.js";
+import { createGoalsAgentSession, goalCritterPick, loadGoalBriefExtras, } from "./goals-agent/goals-agent.js";
 import { handleWorkspaceRoutes } from "./app-sidecar/workspace-routes.js";
 import { handleHistoryRoutes } from "./app-sidecar/history-routes.js";
 import { handlePromptRoutes } from "./app-sidecar/prompt-routes.js";
@@ -176,6 +180,18 @@ async function main() {
         for (const ctx of sessions.values())
             ctx.broadcast(type, data);
     };
+    const sessionIdsAt = (cwd) => {
+        const target = path.resolve(cwd);
+        return [...sessions.values()]
+            .filter((ctx) => path.resolve(ctx.cwd) === target)
+            .map((ctx) => ctx.id)
+            .sort();
+    };
+    /** Whether any live window session in `cwd` is working right now. */
+    const busyAt = (cwd) => {
+        const target = path.resolve(cwd);
+        return [...sessions.values()].some((ctx) => path.resolve(ctx.cwd) === target && ctx.isBusy());
+    };
     // Providers currently mid-OAuth in some window. Daemon-level so two windows
     // cannot race two browser flows for the same provider into one auth file.
     const oauthInFlightProviders = new Set();
@@ -270,6 +286,8 @@ async function main() {
                         broadcastAll,
                         oauthInFlightProviders,
                         repoPolls,
+                        sessionIdsAt,
+                        busyAt,
                     }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
                     log("INFO", "app-sidecar", "session created", {
@@ -278,7 +296,13 @@ async function main() {
                         chatAgent,
                         cwd: sessionCwd,
                     });
-                    daemonJson(res, 200, { sessionId: id });
+                    // The conversation file too, so the app can reopen this exact
+                    // session if the daemon restarts (a new session has no path yet
+                    // on the app's side).
+                    daemonJson(res, 200, {
+                        sessionId: id,
+                        sessionPath: ctx.session.getState().sessionPath ?? null,
+                    });
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -432,7 +456,7 @@ async function main() {
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth, progress, memoryStore, jiwaStore, broadcastAll, oauthInFlightProviders, repoPolls, } = deps;
+    const { auth, progress, memoryStore, jiwaStore, broadcastAll, oauthInFlightProviders, repoPolls, sessionIdsAt, busyAt, } = deps;
     const paths = deps.paths;
     const mode = opts.mode;
     let chatAgent = opts.chatAgent;
@@ -441,6 +465,10 @@ async function createSession(deps, opts) {
     // root; create it on first use so a fresh install can start a video at once.
     if (mode === "motion")
         await fs.mkdir(cwd, { recursive: true });
+    // A coding session whose cwd is a Goal folder is that goal's coordinator.
+    let goal = mode === "code" && isGoalDir(goalsRoot(paths.agentDir), cwd)
+        ? await readGoal(cwd).then((record) => (record ? { dir: cwd, record } : null))
+        : null;
     // Base host for parsing request-URL query params (value is irrelevant to
     // parsing); the daemon owns the real listen host.
     const host = "127.0.0.1";
@@ -586,7 +614,9 @@ async function createSession(deps, opts) {
         onClosed: (ids) => broadcast("ask_user_closed", { ids }),
         onLateAnswer: (late) => {
             log("INFO", "app-sidecar", "ask_user late answer queued", { id: late.prompt.id });
-            deliverLateAnswer(late, {
+            // A late "Start the goal now" starts the goal before EZ Goals hears it,
+            // so the run it wakes into may already hand out work.
+            void startGoalFrom({ action: "answer", answers: late.answers }, late.prompt.questions).then(() => deliverLateAnswer(late, {
                 queueMessage: (text) => session.queueMessage(text),
                 isBusy: () => running || runClaim.active || autopilotActive,
                 onQueued: () => broadcast("queued", {
@@ -594,13 +624,44 @@ async function createSession(deps, opts) {
                     messages: session.listQueuedMessages(),
                 }),
                 startIdleRun: () => void runStrandedQueue(),
-            });
+            }));
         },
     });
-    const askUserTool = createAskUserTool(asks.park);
+    // A goal starts when the user picks "Start the goal now" from EZ Goals'
+    // question: answered while it waits, or late, after its deadline (see
+    // onLateAnswer). Recorded once, and announced so the window can switch to
+    // the goal's world view. Never throws: a failed write leaves it briefing.
+    const startGoalFrom = async (result, questions) => {
+        const current = goal;
+        if (!current)
+            return;
+        const started = await startGoalOnAnswer(current.dir, current.record, result, new Date(), questions).catch((err) => {
+            log("WARN", "app-sidecar", "couldn't record goal start", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        });
+        if (started) {
+            goal = { dir: current.dir, record: started };
+            broadcast("goal_state", { id: started.id, phase: goalPhase(started) });
+        }
+    };
+    const askUserTool = createAskUserTool(async (request) => {
+        const result = await asks.park(request);
+        await startGoalFrom(result, request.questions);
+        return result;
+    });
     // The session file path to resume (passed by the daemon's POST /session);
-    // empty/unset starts a fresh session.
-    const resumeSessionPath = opts.sessionPath;
+    // empty/unset starts a fresh session. A file that's gone (retention cleaned
+    // it up, or its goal was deleted) starts fresh too: failing instead left
+    // the window with no session at all, so not even its goal list loaded.
+    const resumeSessionPath = opts.sessionPath &&
+        (await fs.access(opts.sessionPath).then(() => true, () => false))
+        ? opts.sessionPath
+        : undefined;
+    if (opts.sessionPath && !resumeSessionPath) {
+        log("WARN", "app-sidecar", "session file gone, starting fresh", { cwd });
+    }
     let abort = new AbortController();
     const baseSessionOptions = {
         provider,
@@ -647,6 +708,19 @@ async function createSession(deps, opts) {
             additionalTools: [askUserTool],
         });
     }
+    else if (goal) {
+        // A Goal window talks to EZ Goals, the orchestrator, not the coding agent.
+        session = createGoalsAgentSession({
+            ...baseSessionOptions,
+            goal,
+            // Memory and the attached projects' rules, read once for this session.
+            extras: await loadGoalBriefExtras(goal),
+            // Read live: the goal turns active mid-session when the user starts it.
+            isActive: () => Boolean(goal?.record.startedAt),
+            getChildModel: () => goalCritterPick(goal?.record),
+            additionalTools: [askUserTool],
+        });
+    }
     else {
         session = new AgentSession({
             ...baseSessionOptions,
@@ -685,6 +759,18 @@ async function createSession(deps, opts) {
         });
     }
     await session.initialize();
+    // A goal's attached folders join its workspace so the coordinator can read
+    // them. A resumed session may already carry them; `addDirectory` skips those.
+    if (goal) {
+        for (const item of goal.record.context) {
+            if (item.kind !== "folder")
+                continue;
+            const added = await session.addDirectory(item.path);
+            if (!added.ok && !added.error.startsWith("Already in the workspace")) {
+                log("WARN", "app-sidecar", "goal context folder unavailable", { error: added.error });
+            }
+        }
+    }
     if (mode === "chat") {
         const restoredAgent = [...session.getAppMarkers()]
             .reverse()
@@ -798,23 +884,38 @@ async function createSession(deps, opts) {
         });
     }
     // Workspace extras (context window, git status, background tasks). Git state
-    // is resolved once at startup and refreshed after every run; the context
-    // window follows the active model.
-    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount, initialGitHubSlug] = await Promise.all([
-        getGitBranch(cwd).catch(() => null),
-        isGitRepo(cwd).catch(() => false),
-        getGitDirtyFileCount(cwd).catch(() => 0),
-        getGitHubRepoSlug(cwd).catch(() => null),
-    ]);
-    let gitBranch = initialGitBranch;
-    let gitIsRepo = initialGitIsRepo;
-    let gitDirtyFileCount = initialDirtyFileCount;
+    // is resolved at startup and refreshed after every run; the context window
+    // follows the active model. A Goal window reads git from its attached
+    // project folder, not the goal folder (see resolveGitCwd), and re-targets
+    // when the goal's folders change (`retargetGit`).
+    let gitCwd = await resolveGitCwd(cwd, goal?.record ?? null);
+    const initialGit = await readGitState(gitCwd);
+    let gitBranch = initialGit.branch;
+    let gitIsRepo = initialGit.isRepo;
+    let gitDirtyFileCount = initialGit.dirtyFileCount;
     // Open issue/PR counts for the origin repo's GitHub slug, via the `gh` CLI's
     // auth. null = unknown (gh missing/unauthed, non-GitHub origin) → chips hidden.
-    const gitHubSlug = initialGitHubSlug;
+    let gitHubSlug = initialGit.gitHubSlug;
     let gitHubIssues = null;
     let gitHubPRs = null;
     let gitHubCI = null;
+    // Latest Project Health scan (code mode only); scored with the live CI result.
+    let projectHealthScan = null;
+    // Footer extras go out on every git/CI/task change; score only when the scan
+    // or CI result actually changed.
+    let scoredHealth = null;
+    function currentProjectHealth() {
+        if (!projectHealthScan)
+            return null;
+        if (scoredHealth?.scan !== projectHealthScan || scoredHealth.ci !== gitHubCI) {
+            scoredHealth = {
+                scan: projectHealthScan,
+                ci: gitHubCI,
+                health: scoreProjectHealth(projectHealthScan, gitHubCI),
+            };
+        }
+        return scoredHealth.health;
+    }
     function currentContextWindow() {
         const st = session.getState();
         return getContextWindow(st.model, { provider: st.provider, accountId: st.accountId });
@@ -831,6 +932,7 @@ async function createSession(deps, opts) {
             gitHubPRs,
             gitHubCI,
             gitHubRepoUrl: gitHubSlug ? `https://github.com/${gitHubSlug}` : null,
+            projectHealth: currentProjectHealth(),
             tasks: session.listBackgroundProcesses(),
             // Roots added with /add-dir — the header shows a badge when non-empty.
             additionalRoots: session.getAdditionalRoots(),
@@ -1404,7 +1506,11 @@ async function createSession(deps, opts) {
         }
         finally {
             const cancelled = runLifecycle.isCancellationRequested(generation);
-            const verificationProblem = cancelled ? null : session.getVerificationProblem();
+            // A plain reply has no real end (the user keeps building), so checks are
+            // left to the commit and unchecked edits are not "Unverified". Only an
+            // Autopilot cycle, which does end, reports unchecked work. A check that
+            // ran and failed still shows as failed (from the evidence).
+            const verificationProblem = cancelled || !autopilotActive ? null : session.getVerificationProblem();
             if (runSucceeded && verificationProblem && ownsGeneration) {
                 // Expected control outcome: run_end and the journal already carry Unverified.
                 // Do not format it as a crash or persist a misleading error marker.
@@ -1421,14 +1527,15 @@ async function createSession(deps, opts) {
             // A run may have switched branches, changed files, or spawned/finished
             // background tasks. Refresh the workspace extras once it settles.
             [gitBranch, gitIsRepo, gitDirtyFileCount] = await Promise.all([
-                getGitBranch(cwd).catch(() => gitBranch),
-                isGitRepo(cwd).catch(() => gitIsRepo),
-                getGitDirtyFileCount(cwd).catch(() => gitDirtyFileCount),
+                getGitBranch(gitCwd).catch(() => gitBranch),
+                isGitRepo(gitCwd).catch(() => gitIsRepo),
+                getGitDirtyFileCount(gitCwd).catch(() => gitDirtyFileCount),
             ]);
             // A run may have opened/closed issues or PRs — refresh fire-and-forget so
             // teardown isn't delayed by the network. Broadcasts itself on change.
-            gitHubCountsPoll?.refresh();
-            ciPoll.refresh();
+            repoWatch.gitHubCounts?.refresh();
+            repoWatch.ci.refresh();
+            repoWatch.health?.refresh();
             // Serialize behind any marker/tool-triggered refresh so the terminal
             // progress snapshot uses the live plan file. Once every canonical step
             // is complete, remove the approved plan from future system prompts and
@@ -1771,30 +1878,82 @@ async function createSession(deps, opts) {
     // (they change outside the agent: editor saves, commits, teammates). Branch/
     // repo state already refreshes after agent runs. The pollers are shared with
     // every other window on the same repo; each window broadcasts only changes.
-    const repoKey = path.resolve(cwd);
-    const dirtyFilesPoll = repoPolls.dirtyFiles.subscribe(repoKey, (next) => {
-        if (next === gitDirtyFileCount)
-            return;
-        gitDirtyFileCount = next;
-        broadcast("extras", footerExtras());
-    });
-    // Failed checks publish nothing, so the chips keep their last-known numbers
-    // instead of flickering off on a timeout. None when origin isn't GitHub.
-    const gitHubCountsPoll = gitHubSlug
-        ? repoPolls.gitHubCounts.subscribe(gitHubSlug, (counts) => {
-            if (counts.issues === gitHubIssues && counts.prs === gitHubPRs)
+    function watchRepo(dir) {
+        const repoKey = path.resolve(dir);
+        const dirtyFiles = repoPolls.dirtyFiles.subscribe(repoKey, (next) => {
+            if (next === gitDirtyFileCount)
                 return;
-            gitHubIssues = counts.issues;
-            gitHubPRs = counts.prs;
+            gitDirtyFileCount = next;
             broadcast("extras", footerExtras());
-        })
-        : null;
-    const ciPoll = repoPolls.gitHubCI.subscribe(repoKey, (next) => {
-        if (JSON.stringify(next) === JSON.stringify(gitHubCI))
+        });
+        // Failed checks publish nothing, so the chips keep their last-known numbers
+        // instead of flickering off on a timeout. None when origin isn't GitHub.
+        const gitHubCounts = gitHubSlug
+            ? repoPolls.gitHubCounts.subscribe(gitHubSlug, (counts) => {
+                if (counts.issues === gitHubIssues && counts.prs === gitHubPRs)
+                    return;
+                gitHubIssues = counts.issues;
+                gitHubPRs = counts.prs;
+                broadcast("extras", footerExtras());
+            })
+            : null;
+        const ci = repoPolls.gitHubCI.subscribe(repoKey, (next) => {
+            if (JSON.stringify(next) === JSON.stringify(gitHubCI))
+                return;
+            gitHubCI = next;
+            broadcast("extras", footerExtras());
+        });
+        // Project Health is a code-workspace signal; chat and motion windows skip the scan.
+        const health = mode === "code"
+            ? repoPolls.projectHealth.subscribe(repoKey, (next) => {
+                if (JSON.stringify(next) === JSON.stringify(projectHealthScan))
+                    return;
+                projectHealthScan = next;
+                broadcast("extras", footerExtras());
+            })
+            : null;
+        return {
+            gitHubCounts,
+            ci,
+            health,
+            unsubscribe() {
+                dirtyFiles.unsubscribe();
+                gitHubCounts?.unsubscribe();
+                ci.unsubscribe();
+                health?.unsubscribe();
+            },
+        };
+    }
+    let repoWatch = watchRepo(gitCwd);
+    let repoWatchStopped = false;
+    let gitTargetGeneration = 0;
+    /**
+     * A goal's attached folders changed: point the titlebar's git state at the
+     * new project folder. No-op when the target is unchanged; a newer call or
+     * teardown supersedes one still reading git.
+     */
+    async function retargetGit() {
+        const generation = ++gitTargetGeneration;
+        const next = await resolveGitCwd(cwd, goal?.record ?? null);
+        if (generation !== gitTargetGeneration || repoWatchStopped || next === gitCwd)
+            return;
+        const state = await readGitState(next);
+        if (generation !== gitTargetGeneration || repoWatchStopped)
             return;
-        gitHubCI = next;
+        repoWatch.unsubscribe();
+        gitCwd = next;
+        gitBranch = state.branch;
+        gitIsRepo = state.isRepo;
+        gitDirtyFileCount = state.dirtyFileCount;
+        gitHubSlug = state.gitHubSlug;
+        // The old repo's numbers don't apply; the new watchers fill these in.
+        gitHubIssues = null;
+        gitHubPRs = null;
+        gitHubCI = null;
+        projectHealthScan = null;
+        repoWatch = watchRepo(gitCwd);
         broadcast("extras", footerExtras());
-    });
+    }
     const routeCtx = {
         get session() {
             return session;
@@ -1846,6 +2005,23 @@ async function createSession(deps, opts) {
         cwd,
         asks,
         runClaim,
+        sessionId: opts.id,
+        sessionIdsAt,
+        busyAt,
+        get goal() {
+            return goal;
+        },
+        set goal(v) {
+            const foldersBefore = JSON.stringify(goal?.record.context ?? []);
+            goal = v;
+            if (JSON.stringify(goal?.record.context ?? []) !== foldersBefore) {
+                retargetGit().catch((err) => {
+                    log("WARN", "app-sidecar", "goal git retarget failed", {
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+        },
         broadcast,
         get scheduledRunActive() {
             return scheduledRunActive;
@@ -2003,6 +2179,8 @@ async function createSession(deps, opts) {
             return;
         if (handleWorkspaceRoutes(routeCtx, req, res, url, method))
             return;
+        if (handleGoalRoutes(routeCtx, req, res, url, method))
+            return;
         if (handleHistoryRoutes(routeCtx, req, res, url, method))
             return;
         if (handlePromptRoutes(routeCtx, req, res, url, method))
@@ -2020,6 +2198,12 @@ async function createSession(deps, opts) {
         json(res, 404, { error: "not found" });
     }
     async function dispose() {
+        // A window closed (or switched project) mid-run: stop the run itself, any
+        // run-all sweep or autopilot turn, and a model download this window
+        // started. Otherwise they keep streaming tokens and running tools on a
+        // session that is being torn down.
+        abortOwnedWork();
+        cancelHfPull();
         releaseRunAwake?.();
         releaseRunAwake = null;
         releaseSubagentAwake?.();
@@ -2029,9 +2213,8 @@ async function createSession(deps, opts) {
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);
-        dirtyFilesPoll.unsubscribe();
-        gitHubCountsPoll?.unsubscribe();
-        ciPoll.unsubscribe();
+        repoWatchStopped = true;
+        repoWatch.unsubscribe();
         // Stop the Telegram serve loop + dispose its per-chat sessions.
         if (serveController)
             await serveController.stop().catch(() => { });
@@ -2062,6 +2245,10 @@ async function createSession(deps, opts) {
         handle,
         dispose,
         stopBackgroundProcesses,
+        isBusy: () => running ||
+            runClaim.active ||
+            autopilotActive ||
+            session.listSubAgents().some((w) => w.state === "running" || w.state === "starting"),
     };
 }
 main().catch(async (err) => {