@prestyj/cli 5.5.0 → 5.7.0

package/dist/app-sidecar.js

@@ -18,11 +18,13 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
-import { formatError } from "@prestyj/ai";
+import { environmentSecrets, formatError, redactValue } from "@prestyj/ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { RunLifecycle } from "./core/run-lifecycle.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, sessionsDirForChatAgent, switchChatAgent, } from "./chat-agents/index.js";
+import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
 import { buildNolanSystemPrompt, buildNolanAutopilotSystemPrompt } from "./core/nolan-prompt.js";
 import { buildNolanDigest, buildNolanAutopilotContext, buildNolanAutopilotPlanContext, } from "./core/nolan-context.js";
@@ -517,6 +519,13 @@ async function main() {
             }
         },
     });
+    const jiwaStore = new JiwaStore({
+        onChange: ({ jiwa }) => {
+            for (const ctx of sessions.values()) {
+                ctx.broadcast("jiwa_change", { count: jiwa.length });
+            }
+        },
+    });
     // XP/rank progress — loaded once per daemon; awards fan out to every window.
     // Each frame is tagged `origin: true` only for the session that earned the
     // XP, so that window alone plays sounds/chips while the rest just re-render.
@@ -633,7 +642,7 @@ async function main() {
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths, progress, memoryStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({ auth, paths, progress, memoryStore, jiwaStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
                     log("INFO", "app-sidecar", "session created", {
                         id,
@@ -886,7 +895,7 @@ async function createProgressManager(agentDir, broadcastAll) {
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth, progress, memoryStore } = deps;
+    const { auth, progress, memoryStore, jiwaStore } = deps;
     const paths = deps.paths;
     const mode = opts.mode;
     let chatAgent = opts.chatAgent;
@@ -921,7 +930,8 @@ async function createSession(deps, opts) {
     const clients = new Set();
     let clientSeq = 0;
     function broadcast(type, data) {
-        const frame = `data: ${JSON.stringify({ type, data })}\n\n`;
+        const safePayload = redactValue({ type, data }, { secrets: environmentSecrets(process.env) });
+        const frame = `data: ${JSON.stringify(safePayload)}\n\n`;
         for (const c of clients)
             c.res.write(frame);
     }
@@ -1007,8 +1017,8 @@ async function createSession(deps, opts) {
         session = createChatAgent(chatAgent, {
             ...baseSessionOptions,
             sessionsDir: paths.sessionsDir,
-            additionalTools: buildMemoryTools(memoryStore),
-            getSystemPromptTail: () => memoryStore.renderForPrompt(),
+            additionalTools: [...buildMemoryTools(memoryStore), ...buildJiwaTools(jiwaStore)],
+            getSystemPromptTail: () => `${memoryStore.renderForPrompt()}\n\n${jiwaStore.renderForPrompt()}`,
             onAgentChange: async (nextAgent) => {
                 chatAgent = nextAgent;
                 broadcast("chat_agent_change", { chatAgent: nextAgent });
@@ -1129,6 +1139,13 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
+    const runLifecycle = new RunLifecycle((runState) => {
+        running = runState !== "idle";
+        if (runState === "cancelling")
+            broadcast("run_cancelling", { runState });
+    });
+    const cancelledRunEndGenerations = new Set();
+    let pendingCancelDrain = null;
     let titleGenerated = false;
     // Bumped by /cancel — a run whose cancel generation changed mid-flight was
     // canceled and earns no XP.
@@ -1151,6 +1168,7 @@ async function createSession(deps, opts) {
     let autopilotCancelled = false;
     // Hard cap on review→prompt→review rounds per user turn (loop safety).
     const MAX_AUTOPILOT_ROUNDS = 3;
+    const CANCEL_TIMEOUT_MS = 5_000;
     // Prompt bodies Autopilot Nolan injected into the BUILD session this
     // conversation. Passed into every Nolan digest so injected prompts render as
     // "Nolan autopilot (injected)" instead of `**User:**` — otherwise multi-round
@@ -1357,29 +1375,63 @@ async function createSession(deps, opts) {
             });
         }
     }
-    // Core run lifecycle shared by /prompt and the task runner: flips `running`,
-    // brackets the run with run_start/run_end, refreshes the footer extras, and
-    // generates the session title once. `label` is the text shown live with the
-    // run_start frame.
+    function abortOwnedWork() {
+        cancelGeneration++;
+        abort.abort();
+        // Stop a run-all sweep and every async child through AgentSession's signal.
+        taskRunAll = false;
+        autopilotCancelled = true;
+        nolanAutoAbort.abort();
+    }
+    function installFreshRunControllers() {
+        abort = new AbortController();
+        session.setSignal(abort.signal);
+        nolanAutoAbort = new AbortController();
+        nolanAutoSession?.setSignal(nolanAutoAbort.signal);
+    }
+    function finishOwnedGeneration(generation, emitCancelledFallback) {
+        const cancelled = runLifecycle.isCancellationRequested(generation);
+        const settlement = runLifecycle.settle(generation);
+        if (!settlement.settled)
+            return cancelled;
+        // A replacement signal is safe only after the provider-backed owner settled.
+        installFreshRunControllers();
+        if (cancelled && emitCancelledFallback && !cancelledRunEndGenerations.has(generation)) {
+            cancelledRunEndGenerations.add(generation);
+            broadcast("run_end", { cancelled: true, runState: runLifecycle.state });
+        }
+        return cancelled;
+    }
+    // Core provider-run bracket. Standalone runs own a lifecycle generation;
+    // injected autopilot runs share the cycle's outer generation.
     async function runAgent(label, run) {
-        running = true;
+        const ownsGeneration = !runLifecycle.running;
+        const generation = ownsGeneration
+            ? runLifecycle.begin(abortOwnedWork).generation
+            : runLifecycle.generation;
+        if (ownsGeneration)
+            pendingCancelDrain = null;
         // Progress (Ranks): completed, non-canceled runs with ≥1 assistant turn earn
         // XP — prompt + any commits authored during the run window.
         const runStartedAt = Date.now();
         const cancelGenAtStart = cancelGeneration;
         const assistantsBeforeRun = countAssistantMessages(session.getMessages());
         let runSucceeded = false;
-        broadcast("run_start", { text: label });
+        broadcast("run_start", { text: label, runState: runLifecycle.state });
         try {
-            await run();
+            if (!runLifecycle.isCancellationRequested(generation))
+                await run();
             runSucceeded = true;
         }
         catch (err) {
-            broadcastError("error", "run failed", err);
+            if (!runLifecycle.isCancellationRequested(generation)) {
+                broadcastError("error", "run failed", err);
+            }
         }
         finally {
-            running = false;
+            const cancelled = runLifecycle.isCancellationRequested(generation);
             if (runSucceeded &&
+                !cancelled &&
                 cancelGeneration === cancelGenAtStart &&
                 countAssistantMessages(session.getMessages()) > assistantsBeforeRun) {
                 // Fire-and-forget — XP must never delay or break run teardown.
@@ -1389,7 +1441,18 @@ async function createSession(deps, opts) {
             // background tasks — refresh the footer extras once it settles.
             gitBranch = await getGitBranch(cwd).catch(() => gitBranch);
             gitIsRepo = await isGitRepo(cwd).catch(() => gitIsRepo);
-            broadcast("run_end", {});
+            if (ownsGeneration)
+                finishOwnedGeneration(generation, false);
+            // A cancelled injected run is still owned by the surrounding autopilot
+            // cycle; its outer finalizer emits the one terminal cancelled run_end.
+            if (!(cancelled && !ownsGeneration)) {
+                if (cancelled)
+                    cancelledRunEndGenerations.add(generation);
+                broadcast("run_end", {
+                    ...(cancelled ? { cancelled: true } : {}),
+                    runState: runLifecycle.state,
+                });
+            }
             // Autopilot's review loop is driven explicitly from POST /prompt (see
             // runAutopilotCycle), NOT from this shared finally — that keeps the
             // injected EZ Coder runs this cycle triggers from recursively re-entering
@@ -1398,12 +1461,8 @@ async function createSession(deps, opts) {
             // completed ones so they drop out of the Tasks modal automatically (users
             // never have to delete finished tasks by hand).
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
-            // Queue drains into the run as steering, so it's empty by run_end —
-            // sync the webview indicator.
             broadcast("queued", { count: session.getQueuedCount() });
             broadcast("extras", footerExtras());
-            // Generate a session title once, after the first run, for the title bar
-            // (best-effort, async — don't block the response).
             if (!titleGenerated) {
                 titleGenerated = true;
                 void session.generateTitle().then((title) => {
@@ -1436,7 +1495,8 @@ async function createSession(deps, opts) {
             return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
         }
         catch (err) {
-            broadcastError("autopilot_error", "autopilot review failed", err);
+            if (!autopilotCancelled)
+                broadcastError("autopilot_error", "autopilot review failed", err);
             return null;
         }
         finally {
@@ -1511,6 +1571,8 @@ async function createSession(deps, opts) {
     async function runAutopilotCycle(originalRequest) {
         if (!autopilot || autopilotCancelled)
             return;
+        const generation = runLifecycle.begin(abortOwnedWork).generation;
+        pendingCancelDrain = null;
         autopilotActive = true;
         // Generation captured by the last plan review; acceptPlan re-checks it so
         // a user Accept/Reject landing mid-review always wins.
@@ -1625,6 +1687,8 @@ async function createSession(deps, opts) {
         }
         finally {
             autopilotActive = false;
+            finishOwnedGeneration(generation, true);
+            queueMicrotask(() => void runStrandedQueue());
         }
     }
     // ── Stranded-queue drain ───────────────────────────────
@@ -1817,7 +1881,7 @@ async function createSession(deps, opts) {
         });
     }
     function json(res, status, body) {
-        const payload = JSON.stringify(body);
+        const payload = JSON.stringify(redactValue(body, { secrets: environmentSecrets(process.env) }));
         res.writeHead(status, {
             "content-type": "application/json",
             "access-control-allow-origin": "*",
@@ -1833,6 +1897,7 @@ async function createSession(deps, opts) {
                 mode,
                 chatAgent,
                 running,
+                runState: runLifecycle.state,
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1867,6 +1932,26 @@ async function createSession(deps, opts) {
                 .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
             return;
         }
+        if (method === "GET" && url === "/jiwa") {
+            void jiwaStore
+                .snapshot()
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/jiwa/")) {
+            const id = decodeURIComponent(url.slice("/jiwa/".length));
+            if (!id) {
+                json(res, 400, { error: "Jiwa entry id is required" });
+                return;
+            }
+            void jiwaStore
+                .forget(id)
+                .then(() => jiwaStore.snapshot())
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
         if (method === "GET" && (url === "/events" || url.startsWith("/events?"))) {
             res.writeHead(200, {
                 "content-type": "text/event-stream",
@@ -1885,6 +1970,7 @@ async function createSession(deps, opts) {
                     mode,
                     chatAgent,
                     running,
+                    runState: runLifecycle.state,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                     supportsVideo: getModel(st.model)?.supportsVideo ?? false,
@@ -2381,6 +2467,13 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
+                if (runLifecycle.running && runLifecycle.isCancellationRequested(runLifecycle.generation)) {
+                    json(res, 409, {
+                        error: runLifecycle.state === "cancelling" ? "run_cancelling" : "cancel_failed",
+                        runState: runLifecycle.state,
+                    });
+                    return;
+                }
                 if (running || autopilotActive) {
                     // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
                     // an autopilot cycle is active but between injected runs (build idle,
@@ -2954,27 +3047,50 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/cancel") {
-            cancelGeneration++;
-            abort.abort();
-            abort = new AbortController();
-            session.setSignal(abort.signal);
-            running = false;
-            // Stop a run-all sweep so the next pending task isn't auto-started.
-            taskRunAll = false;
-            taskRunActive = false;
-            // Stop any in-flight autopilot cycle: flag it so the loop bails between
-            // steps, and abort a review that's mid-prompt on the nolanAuto session.
-            autopilotCancelled = true;
-            nolanAutoAbort.abort();
-            nolanAutoAbort = new AbortController();
-            nolanAutoSession?.setSignal(nolanAutoAbort.signal);
-            autopilotReviewing = false;
-            // Drop any queued steering and return it so the webview can restore it to
-            // the composer.
-            const drained = session.drainQueue();
-            broadcast("run_end", { cancelled: true });
-            broadcast("queued", { count: 0 });
-            json(res, 200, { cancelled: true, drained });
+            void (async () => {
+                // Even between task runs, cancellation stops the sweep. Active provider
+                // ownership invokes the full abort hook exactly once through lifecycle.
+                taskRunAll = false;
+                autopilotCancelled = true;
+                if (!runLifecycle.running) {
+                    nolanAutoAbort.abort();
+                    nolanAutoAbort = new AbortController();
+                    nolanAutoSession?.setSignal(nolanAutoAbort.signal);
+                }
+                const generation = runLifecycle.generation;
+                if (!pendingCancelDrain || pendingCancelDrain.generation !== generation) {
+                    pendingCancelDrain = { generation, text: session.drainQueue() };
+                    broadcast("queued", { count: 0 });
+                }
+                const result = await runLifecycle.cancel(CANCEL_TIMEOUT_MS);
+                const drained = pendingCancelDrain.text;
+                if (result.status === "failed") {
+                    broadcast("cancel_failed", {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                    });
+                    json(res, 504, {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                        drained,
+                    });
+                    return;
+                }
+                json(res, 200, {
+                    cancelled: result.status === "cancelled",
+                    runState: runLifecycle.state,
+                    drained,
+                });
+            })().catch((error) => {
+                broadcast("cancel_failed", { error: "cancel_failed", runState: runLifecycle.state });
+                json(res, 500, {
+                    error: "cancel_failed",
+                    message: error instanceof Error ? error.message : String(error),
+                    runState: runLifecycle.state,
+                });
+            });
             return;
         }
         if (method === "POST" && url === "/new-session") {