@loompad/cli 1.2.0 → 1.2.2

package/dist/daemon/runtime.js

@@ -55,9 +55,11 @@ import { ContinuityEngine } from "../core/continuity/engine.js";
 import { ContinuityError } from "../core/continuity/contracts.js";
 import { HarnessMonitor, isNativeKind } from "../core/continuity/capabilities.js";
 import { ProviderAgent } from "../providers/agent.js";
-import { READ_ONLY_RULE } from "../core/review.js";
+import { READ_ONLY_RULE, decisionText } from "../core/review.js";
+import { parseVerdicts } from "../core/council.js";
 import { ReviewRunner } from "./review.js";
 import { CouncilRunner } from "./council.js";
+import { coldResume, observedInputRate, priceBook } from "../core/prices.js";
 import { LiveDeltaThrottle } from "../providers/live.js";
 import { AdapterBase } from "../adapters/base.js";
 export { BudgetExceededError, CLOCK_TICK_MS, LOOM_ASK_TIMEOUT_MESSAGE, LOOM_ASK_TIMEOUT_MS, LoomAskTimeoutError, QuarantinedError, activityLine, planModeBriefing, relativeToProject, withLoomAskTimeout } from './runtime-support.js';
@@ -304,6 +306,7 @@ export class ProjectRuntime {
             projectId: info.id,
             projectName: info.name,
             projectDir: info.dir,
+            worktreeDir: () => this.config.orchestra?.worktreeDir,
             roster: () => this.config.agents.filter((a) => a.enabled !== false && tierForKind(a.kind) === "adapter" && !isWithdrawnKind(a.kind)),
             installedKinds: () => this.installedKinds,
             makeAgent: (cfg, dir) => {
@@ -355,6 +358,7 @@ export class ProjectRuntime {
             config: () => this.config,
             busy: (id) => { const a = this.agents.get(id); return Boolean(a && isAdapter(a) && a.busy()) || this.turns.busySince.has(id); },
             turnChat: (id) => this.turns.turnChat.get(id),
+            inSubtask: (id) => [...this.subtasks.values()].some((t) => t.agentId === id),
             available: async (id) => { const a = this.agents.get(id); return Boolean(a && isAdapter(a) && (await a.available())); },
             interrupt: (chat) => this.interrupt({ chat, source: "route" }),
             handoff: (to) => this.handoff(to, { source: "route" }),
@@ -396,6 +400,7 @@ export class ProjectRuntime {
             list: (opts) => this.log.list(opts),
             append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
             warn: (message, detail) => logbook.warn("shift", message, String(detail), this.info.id),
+            noteDirtyStart: (chat, what) => this.noteDirtyStart(chat, what),
         });
         this.reviews = new ReviewRunner({
             hasAgent: (id) => this.config.agents.some((a) => a.id === id),
@@ -416,6 +421,18 @@ export class ProjectRuntime {
                 this.brain.add({ kind: "decision", text, provenance: { agentId: "user", eventId: event.id, ts: event.ts } });
             },
             maxReviewers: ProjectRuntime.MAX_CONCURRENT_SUBTASKS,
+            reviewerTimeoutMs: () => Math.max(1, Number(this.config.review?.timeoutMin) || 15) * 60_000,
+            // a reviewer left out at its time limit is stopped, and its process with it — an opencode serve
+            // outlived a left-out review by 42 minutes (#312); its next turn starts it again
+            stopReviewer: async (agentId) => {
+                const a = this.agents.get(agentId);
+                if (!a || !isAdapter(a))
+                    return;
+                if (a.busy())
+                    await a.interrupt();
+                setTimeout(() => { if (!this.closed && !a.busy())
+                    void a.stop().catch(() => { }); }, 30_000).unref?.();
+            },
         });
         this.councils = new CouncilRunner({
             hasAgent: (id) => this.config.agents.some((a) => a.id === id),
@@ -451,6 +468,7 @@ export class ProjectRuntime {
             append: (e) => (this.closed ? { ...e, id: -1, ts: Date.now() } : this.log.append(e)),
             lastId: () => this.log.list({ limit: 1 }).at(-1)?.id ?? 0,
             warn: (message, detail) => logbook.warn("council", message, String(detail), this.info.id),
+            noteDirtyStart: (chat, what) => this.noteDirtyStart(chat, what),
         });
         this.crews = new CrewEngine({
             projectId: info.id,
@@ -552,6 +570,10 @@ export class ProjectRuntime {
         }
         rt.configMtime = configMtimeOf(info.dir);
         rt.rehydrateCosts();
+        rt.rehydrateSignIns();
+        // finished orchestra runs older than a week give their disk back (#295)
+        setTimeout(() => void (rt.closed ? Promise.resolve([]) : rt.orchestra.sweep()).then((ids) => { if (ids.length)
+            logbook.info("orchestra", `removed the worktrees of ${ids.length} finished run(s)`, ids.join(", "), rt.info.id); }).catch(() => { }), 30_000).unref?.();
         // Pull each connected ADE's native memory into the shared brain on open.
         try {
             rt.importMemories();
@@ -2378,8 +2400,8 @@ export class ProjectRuntime {
     }
     /**
      * A plan turn on a provider agent runs in the agent's own plan mode, which
-     * changes nothing; Loom keeps the plan it proposes under plans/, as its plan
-     * mode always has.
+     * changes nothing; Loom keeps the plan it proposes under .loom/plans/ — its
+     * own folder, not a new untracked one in your repo (#279).
      */
     saveProposedPlan(agentId, chat, markdown) {
         if (!markdown.trim())
@@ -2388,7 +2410,7 @@ export class ProjectRuntime {
             const heading = /^#+\s*(.+)$/m.exec(markdown)?.[1] ?? markdown.split("\n")[0] ?? "plan";
             const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "plan";
             const day = new Date().toISOString().slice(0, 10);
-            const dir = path.join(this.agentDir(agentId), "plans");
+            const dir = path.join(projectLoomDir(this.agentDir(agentId)), "plans");
             fs.mkdirSync(dir, { recursive: true });
             let file = path.join(dir, `${day}-${slug}.md`);
             for (let n = 2; fs.existsSync(file); n++)
@@ -2502,6 +2524,107 @@ export class ProjectRuntime {
         if (message && SIGNED_OUT.test(message))
             this.signedOutAgents.set(event.agentId, message.split("\n")[0].slice(0, 200));
     }
+    /**
+     * The size of an agent's native session in a chat — the context its last
+     * turn sent — and how long ago that was; a resumed session past the cache's
+     * life is re-read in full (#280).
+     */
+    sessionWeight(agentId, chat = MAIN_CHAT) {
+        const last = this.log.list({ chat, agentId, kinds: ["run_complete"], limit: 50 }).at(-1);
+        if (!last)
+            return null;
+        const tokens = Number(last.payload.inputTokens ?? 0) || 0;
+        const model = typeof last.payload.model === "string" ? last.payload.model : undefined;
+        const ageMs = Date.now() - last.ts;
+        // what this agent is really billed per token, from its own recent priced turns (any chat)
+        const rate = observedInputRate(this.log.list({ agentId, kinds: ["run_complete"], limit: 40 }).map((e) => ({
+            costUsd: Number(e.payload.costUsd ?? 0) || 0, tokensIn: Number(e.payload.inputTokens ?? 0) || 0,
+            cachedIn: Number(e.payload.cachedInputTokens ?? 0) || 0, tokensOut: Number(e.payload.outputTokens ?? 0) || 0
+        })));
+        return { tokens, ageMs, ...(model ? { model } : {}), ...coldResume({ tokens, ageMs, rate, ...(model ? { model } : {}) }, priceBook()) };
+    }
+    /**
+     * Uncommitted changes in the tree right now (Loom's own .loom/ aside) —
+     * a shift or council starting on top of an interrupted turn's edits says so,
+     * rather than building on them silently (#313).
+     */
+    dirtyFiles() {
+        try {
+            const out = execFileSync("git", ["status", "--porcelain", "--", ".", ":(exclude).loom"], { cwd: this.info.dir, encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "ignore"] });
+            return out.split("\n").map((l) => l.slice(3).trim()).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Say, in the chat that's starting, that the tree isn't clean — and how to put it back. */
+    noteDirtyStart(chat, what) {
+        const files = this.dirtyFiles();
+        if (!files.length)
+            return;
+        this.log.append({ kind: "status", ...(chat !== MAIN_CHAT ? { chat } : {}), payload: { state: "dirty_start", files: files.slice(0, 40),
+                text: `${what} starts on ${files.length} uncommitted change${files.length === 1 ? "" : "s"} already in the tree (${files.slice(0, 4).join(", ")}${files.length > 4 ? ", …" : ""}) — commit them first, or Rewind to a turn's checkpoint to put them back` } });
+    }
+    /**
+     * Decisions recorded from a council's verdicts before #275 lost every `_`
+     * ("test_reach.py" became "testreach.py") and briefings carried them on.
+     * Rebuild each from the review finding (kept intact) and the planner's own
+     * reply, still in the chat — the note exactly as written (#318). Returns
+     * how many memories were mended.
+     */
+    repairDecisions() {
+        const findings = [];
+        const chats = new Map(); // finding id → the review's chat
+        for (const e of this.log.list({ kinds: ["review"] })) {
+            if (e.payload.phase !== "done")
+                continue;
+            for (const f of e.payload.findings ?? []) {
+                findings.push(f);
+                chats.set(f.id, String(e.chat ?? e.payload.chat ?? MAIN_CHAT));
+            }
+        }
+        let repaired = 0, checked = 0;
+        for (const m of this.brain.all()) {
+            if (m.kind !== "decision" || !m.text.startsWith("Review finding accepted ("))
+                continue;
+            checked++;
+            const f = findings.find((x) => m.text.startsWith(decisionText(x)));
+            if (!f)
+                continue;
+            // the planner's raw verdict line for this finding, anywhere in that chat
+            let note;
+            for (const msg of this.log.list({ chat: chats.get(f.id) ?? MAIN_CHAT, kinds: ["message"], limit: 2000 }).reverse()) {
+                if (!msg.agentId || typeof msg.payload.text !== "string")
+                    continue;
+                const v = parseVerdicts(msg.payload.text, [f.id]).get(f.id);
+                if (v) {
+                    note = v.note;
+                    break;
+                }
+            }
+            const fixed = decisionText(f, note);
+            if (fixed === m.text)
+                continue;
+            this.brain.update(m.id, { text: fixed }, "loom");
+            repaired++;
+        }
+        return { repaired, checked };
+    }
+    /** Resolves once the agent isn't mid-turn (or after `maxMs`, when the send gets the adapter's own answer). */
+    async whenIdle(agentId, maxMs = 20 * 60_000) {
+        const busy = () => { const a = this.agents.get(agentId); return Boolean(a && isAdapter(a) && a.busy()) || this.turns.busySince.has(agentId); };
+        for (const end = Date.now() + maxMs; busy() && Date.now() < end && !this.closed;)
+            await new Promise((r) => setTimeout(r, 1000));
+    }
+    /** The agents a real turn found signed out, with what the CLI said (for `loom doctor`). */
+    learnedSignOuts() {
+        return [...this.signedOutAgents.entries()].map(([agentId, message]) => ({ agentId, kind: this.config.agents.find((a) => a.id === agentId)?.kind ?? "", message }));
+    }
+    /** What a restart would forget: each agent's latest sign-in failure that no successful turn has cleared since. */
+    rehydrateSignIns() {
+        for (const e of this.log.list({ kinds: ["error", "run_complete"], limit: 3000 }))
+            this.noteSignIn(e);
+    }
     /** What status says about an agent's sign-in: a real failure beats the CLI's own (cached) check. */
     signInState(agentId, kind) {
         const learned = this.signedOutAgents.get(agentId);
@@ -2547,6 +2670,18 @@ export class ProjectRuntime {
     }
     /** The loop card's buttons: stop the turn, nudge the agent, or hand the task to another agent. */
     async actOnLoop(chat, agentId, action, to, loop) {
+        if (action !== "stop") {
+            const release = this.queueCoordinator.hold();
+            try {
+                return await this.actOnLoopNow(chat, agentId, action, to, loop);
+            }
+            finally {
+                release();
+            }
+        }
+        return this.actOnLoopNow(chat, agentId, action, to, loop);
+    }
+    async actOnLoopNow(chat, agentId, action, to, loop) {
         const card = loop ?? this.lastLoop(chat, agentId);
         await this.interrupt({ chat, source: "route" });
         if (action === "stop")
@@ -2800,8 +2935,9 @@ export class ProjectRuntime {
         const startedAt = Date.now();
         // the child's reply belongs to the chat it was asked in, not wherever it last talked
         this.turns.turnChat.set(opts.agentId, chat);
-        void child
-            .send(input)
+        // an agent that's mid-turn finishes it first: a review sent to a busy reviewer used to fail at once (#310)
+        void this.whenIdle(opts.agentId)
+            .then(() => { this.turns.turnChat.set(opts.agentId, chat); return child.send(input); })
             .then(() => {
             this.subtasks.delete(id);
             // an adapter can report a failed turn as an error event and still resolve: that subtask
@@ -3183,8 +3319,24 @@ export class ProjectRuntime {
             // "the self-heal did nothing".
             quarantine: this.quarantined(),
             orchestra: this.orchestraSummary(),
+            activity: this.inFlight(),
         };
     }
+    /** What's in flight besides an agent's own turn — an orchestra planning, a crew, a council — so "idle" isn't said of a busy project (#294). */
+    inFlight() {
+        const out = [];
+        if (this.orchestra.active())
+            out.push("orchestra");
+        for (const c of this.crews.workingCrews)
+            out.push(`crew ${c}`);
+        if (this.councils.active)
+            out.push("council");
+        if (this.shifts.active)
+            out.push("night shift");
+        if (this.reviews.running)
+            out.push("review");
+        return out;
+    }
     /**
      * What every agent in this project is doing right now — for the fleet view.
      *