teapot-coding-agent 0.37.92 → 0.37.94

package/dist/agent/agent.js

@@ -7,7 +7,6 @@ import { auditPrompt, parseAuditVerdict } from "./goal-audit.js";
 import { createCatalog } from "./tool-catalog.js";
 import { resetToolCatalog, executeTool, toolSpecs, currentSkills, safeJoin, isContextOverflow, isRequestNodeLimit, hasRunningBgShells, hasRunningBgShellsFor, killBgShells } from "./tools.js";
 import { effortChoosable } from "./llm.js";
-import { sessionTitleFrom } from "../session-title.js";
 import { mcp } from "./mcp-registry.js";
 import { flattenToolName } from "./mcp-registry.js";
 import { metaToolSpecs } from "./meta-tools.js";
@@ -298,10 +297,6 @@ export class Agent {
     skillsStamp = "";
     lastCompactSummary;
     compactRules = [];
-    setSessionTitle(title) {
-        this.sessionTitle = title?.trim() || undefined;
-    }
-    sessionTitle;
     overflowRecoveries = 0;
     consecutiveCompactFailures = 0;
     memoryDigestText() {
@@ -747,9 +742,6 @@ export class Agent {
         const last = lineage[lineage.length - 1];
         const msgs = await rebuildMessagesFrom(lineage, this.imagesDir);
         for (const e of own) {
-            if (this.sessionTitle === undefined && e.type === "prompt" && e.data?.source === "user") {
-                this.sessionTitle = sessionTitleFrom(e.data?.text) ?? undefined;
-            }
             if (e.type === "state") {
                 const d = e.data;
                 if (d.detail === "llm turn start")
@@ -1059,6 +1051,16 @@ export class Agent {
         });
     }
     snapshot() {
+        /**
+         * The session's name comes from ONE place — `config.sessionTitles`, via the resolver Master hands
+         * down. The agent used to keep its own copy, seeded at creation and never updated when the map
+         * learned the real title, so the panel showed the internal id while `config.json` had the name
+         * ("config.jsonにチャットタイトルが生成されているのに表示が内部IDになってる").
+         *
+         * A copy that has to be PUSHED is a copy that goes stale; deriving it means there is nothing to
+         * push. The session id is the fallback so the panel is never blank.
+         */
+        const title = this.opts.sessionTitleOf?.(this.currentSession) || this.currentSession;
         return {
             id: this.opts.id,
             status: this.status === "idle" && this.isLive() ? "waiting" : this.status,
@@ -1067,7 +1069,7 @@ export class Agent {
             workspace: this.workspace,
             workspaceMissing: this.isGhost,
             session: this.currentSession,
-            ...(this.sessionTitle ? { sessionTitle: this.sessionTitle } : {}),
+            ...(title ? { sessionTitle: title } : {}),
             branch: this.currentBranch,
             goal: {
                 status: this.goal.status,
@@ -1155,7 +1157,7 @@ export class Agent {
         })
             .then(() => {
             if (source === "user")
-                this.opts.onFirstUserPrompt?.(this.currentSession);
+                this.opts.onFirstUserPrompt?.(this.currentSession, text);
         })
             .then(() => bus.emit("update", { kind: "agent-update", agentId: this.opts.id }))
             .catch(() => { });
@@ -1792,7 +1794,7 @@ export class Agent {
                         reasoning: partial.reasoning,
                         interrupted: true,
                     });
-                    this.messages.push({ role: "assistant", content: partial.text ?? "" });
+                    this.messages.push(assistantTurn({ role: "assistant", content: partial.text ?? "" }, partial.reasoning));
                 }
                 else if (this.stopRequested) {
                     await this.log.append("system_note", this.currentSession, this.currentBranch, {
@@ -1859,16 +1861,8 @@ export class Agent {
                 };
                 await this.log.append("usage", this.currentSession, this.currentBranch, res.usage);
             }
-            const m = res.message;
-            /**
-             * Carry the thinking on the message itself, not only in the log.
-             *
-             * `res.reasoning` was written to `chat.jsonl` and then dropped: `this.messages.push(m)` stored a
-             * message with no reasoning, so the NEXT request sent back an assistant turn with its thinking
-             * missing. Providers that require it (Beam, #187) answered 400; the rest simply lost the thread.
-             */
-            if (res.reasoning && !m.reasoning)
-                m.reasoning = res.reasoning;
+            // `assistantTurn` carries the thinking, which is what `reasoning_content` is sent from (#187)
+            const m = assistantTurn(res.message, res.reasoning);
             const isPlaceholder = m.content === "(tool call)" || m.content === "(no content)";
             await this.log.append("message", this.currentSession, this.currentBranch, {
                 role: "assistant",
@@ -2191,7 +2185,7 @@ export class Agent {
                     await step({ step: "reply", text: text.slice(0, 400) });
                 return text;
             }
-            messages.push({ role: "assistant", content: text, tool_calls: calls });
+            messages.push(assistantTurn({ role: "assistant", content: text, tool_calls: calls }, res.reasoning));
             for (const call of calls) {
                 await step({ step: "tool", name: call.function?.name, args: String(call.function?.arguments ?? "").slice(0, 200) });
                 let out;
@@ -2224,6 +2218,22 @@ export class Agent {
     async handleFinish(argsJson) {
         const args = safeParse(argsJson);
         if (args.goalComplete === true && this.goal.status !== "done") {
+            /**
+             * A PAUSED goal is not the agent's to complete.
+             *
+             * `paused` means the operator took the goal off the agent's hands, so a `finish(goalComplete)`
+             * must not run the audit — reported as "goal pausedでもgoal auditが動く". It also must not flip the
+             * status to done: that would silently undo the pause. The final message is still appended, because
+             * the work itself is real and the operator should see the summary.
+             */
+            if (this.goal.status === "paused") {
+                await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                    event: "finish-ignored-while-paused",
+                    detail: "the goal is paused, so a completion claim neither runs the audit nor marks it done",
+                });
+                await this.appendFinalMessage(args);
+                return;
+            }
             if (this.goal.verify?.trim()) {
                 await this.log.append("goal", this.currentSession, this.currentBranch, {
                     event: "audit-started",
@@ -2973,6 +2983,23 @@ function safeParse(json) {
         return {};
     }
 }
+/**
+ * The conversation entry for a reply, with its thinking attached.
+ *
+ * THREE places used to build this by hand — the main loop, the AUDITOR's loop, and the interrupted-partial
+ * path — and each independently forgot `reasoning`, which is what `reasoning_content` is derived from
+ * (#187). MEASURED consequences: every audit attempt on `mizuki-rakutenai-3-205c7912` died with
+ * `messages[1].reasoning_content` (index 1 IS the auditor's synthetic assistant turn) and the run ended
+ * at `audit-unavailable-cap`, while the main loop had already been fixed.
+ *
+ * One builder means a fourth caller cannot be forgotten.
+ */
+function assistantTurn(m, reasoning) {
+    const out = { ...m };
+    if (reasoning && !out.reasoning)
+        out.reasoning = reasoning;
+    return out;
+}
 function lineageOf(events) {
     if (events.length === 0)
         return [];

package/dist/master.js

@@ -648,9 +648,11 @@ export class Master {
         const agent = new Agent({
             id: ac.id,
             workspace: resolveWorkspace(ac.workspace, path.dirname(this.configPath)),
-            onFirstUserPrompt: (sessionId) => {
-                void this.ensureSessionTitle(ac.id, sessionId);
+            onFirstUserPrompt: (sessionId, firstText) => {
+                void this.ensureSessionTitle(ac.id, sessionId, firstText);
             },
+            // ONE owner for a session's name: this map. The agent derives it on every snapshot.
+            sessionTitleOf: (sessionId) => this.readSessionTitle(sessionId) ?? undefined,
             llm,
             sessionDir,
             // boot must touch ONLY config.json and skills; this agent's directory is opened when it is used
@@ -740,27 +742,13 @@ export class Master {
         }
         await agent.init();
         /**
-         * Seed the title from the SESSION, so a restart shows the name the operator gave it.
+         * No title is seeded, and nothing is derived here.
          *
-         * `snapshot().sessionTitle` comes from the agent's own field, and that was only ever set by
-         * `renameSession` — so after a restart the UI fell back to the auto-generated name even though the
-         * title was on disk. The title comes from `config.sessionTitles`, which is the one copy.
+         * The agent derives its name from `config.sessionTitles` on every `snapshot()` (see
+         * `sessionTitleOf`), so there is no copy to seed. Deriving a missing one here would read
+         * `chat.jsonl`, and boot must not open session directories — "起動中に読んでいいのはconfig.jsonと
+         * skillsだけ / セッションディレクトリはセッションがロードされるまで開かない".
          */
-        const seedTitle = this.readSessionTitle(path.basename(sessionDir));
-        if (seedTitle)
-            agent.setSessionTitle(seedTitle);
-        else {
-            /**
-             * NOT derived here. Deriving a missing title reads `chat.jsonl`, and boot must not open session
-             * directories at all — "起動中に読んでいいのはconfig.jsonとskillsだけ / セッションディレクトリは
-             * セッションがロードされるまで開かない".
-             *
-             * The session ID is a perfectly good fallback for the panel, and the real derivation happens
-             * when that session is actually loaded (`ensureSessionTitle`, via the agent's first prompt).
-             */
-            const id = path.basename(sessionDir);
-            agent.setSessionTitle(this.readSessionTitle(id) ?? id);
-        }
         this.agents.set(ac.id, agent);
         if (opts.persist) {
             this.config.agents.push(ac);
@@ -1105,6 +1093,17 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         }
         this.config.sessionTitles ??= {};
         this.config.sessionTitles[sessionId] = title;
+        /**
+         * …and the LIVE agent has to be told, or the panel keeps showing the id.
+         *
+         * `addAgent` seeds an agent's title from this map when it is created, falling back to the session id.
+         * A NEW session gets its entry written later (on the first prompt, from `chat.jsonl`), and nothing
+         * pushed it back — so the agent still held the id and the panel displayed it while `config.json` had
+         * the real name. Reported as "config.jsonにチャットタイトルが生成されているのに表示が内部IDになってる".
+         *
+         * Pushing here rather than in each caller means every writer (the derivation, a rename) is covered by
+         * one rule: the map changed, so the agent that is showing it changes too.
+         */
         this.saveConfig();
     }
     /**
@@ -1114,14 +1113,23 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
      * per session on every call (MEASURED earlier: 0.87s for one archive toggle). Writing it down once,
      * where the session lives, keeps that scan off the hot path and keeps the answer in ONE place.
      */
-    async ensureSessionTitle(agentId, sessionId) {
+    async ensureSessionTitle(agentId, sessionId, firstText) {
         const a = this.config.agents.find((x) => x.id === agentId);
         if (!a || a.session !== sessionId)
             return;
+        // the map is the master: once it has a name, nothing may replace it
         if (this.readSessionTitle(sessionId))
             return;
-        const dir = path.join(this.sessionsRoot(), sessionId);
-        this.writeSessionTitle(sessionId, this.sessionTitleOf(dir) ?? sessionId);
+        /**
+         * A session is named from its FIRST USER MESSAGE — that is the whole point of this hook, and it must
+         * keep working for a session created at runtime.
+         *
+         * The text arrives from the agent, which already has it, so this needs no read of `chat.jsonl`. The
+         * log is only a fallback for a caller that could not supply it.
+         */
+        const fromText = sessionTitleFrom(firstText) ?? undefined;
+        const derived = fromText ?? this.sessionTitleOf(path.join(this.sessionsRoot(), sessionId)) ?? sessionId;
+        this.writeSessionTitle(sessionId, derived);
     }
     sessionTitleOf(dirPath) {
         let fd;
@@ -1355,7 +1363,7 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
          */
         this.writeSessionTitle(sessionId, clean);
         delete a.sessionTitle;
-        this.agents.get(agentId)?.setSessionTitle(clean);
+        // no field to set: the panel derives the name from the map, so the bus nudge is the whole update
         bus.emit("update", { kind: "agent-update", agentId });
         return { title: clean };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.37.92",
+  "version": "0.37.94",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",