@agentconnect.md/daemon 1.0.0-rc.34 → 1.0.0-rc.36

package/dist/index.js

@@ -23240,19 +23240,46 @@ var LocalStore = class {
 		mkdirSync(dirname(dbPath), { recursive: true });
 		this.db = new DatabaseSync(dbPath);
 		this.db.exec("PRAGMA journal_mode = WAL");
+		this.migrateTranscript();
 		this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
         acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER
       );
       CREATE TABLE IF NOT EXISTS transcript (
-        channel TEXT, thread TEXT, ts TEXT, sender TEXT, text TEXT,
-        PRIMARY KEY (channel, thread, ts)
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        channel TEXT NOT NULL, thread TEXT NOT NULL, ts TEXT,
+        sender TEXT NOT NULL, kind TEXT NOT NULL, text TEXT NOT NULL
       );
+      CREATE INDEX IF NOT EXISTS transcript_thread_seq ON transcript (channel, thread, seq);
+      -- Dedup conversational rows by platform ts (double-fired inbound / redelivery);
+      -- internal events have no platform ts and are intentionally never deduped here.
+      CREATE UNIQUE INDEX IF NOT EXISTS transcript_text_ts
+        ON transcript (channel, thread, ts) WHERE kind = 'text';
       CREATE TABLE IF NOT EXISTS cp_routing (
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
+    `);
+	}
+	/**
+	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
+	* text. Rebuild them onto the `seq`/`kind` schema, tagging legacy rows `text`. No-op on
+	* a fresh DB (CREATE handles it) or an already-migrated one.
+	*/
+	migrateTranscript() {
+		const cols = this.db.prepare("PRAGMA table_info(transcript)").all();
+		if (cols.length === 0 || cols.some((c) => c.name === "kind")) return;
+		this.db.exec(`
+      ALTER TABLE transcript RENAME TO transcript_legacy;
+      CREATE TABLE transcript (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        channel TEXT NOT NULL, thread TEXT NOT NULL, ts TEXT,
+        sender TEXT NOT NULL, kind TEXT NOT NULL, text TEXT NOT NULL
+      );
+      INSERT INTO transcript (channel, thread, ts, sender, kind, text)
+        SELECT channel, thread, ts, sender, 'text', text FROM transcript_legacy ORDER BY ts ASC;
+      DROP TABLE transcript_legacy;
     `);
 	}
 	getSession(key) {
@@ -23266,11 +23293,20 @@ var LocalStore = class {
            lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`).run(rec);
 	}
 	appendTranscript(e) {
-		this.db.prepare("INSERT OR IGNORE INTO transcript (channel, thread, ts, sender, text) VALUES (@channel, @thread, @ts, @sender, @text)").run(e);
+		this.db.prepare("INSERT OR IGNORE INTO transcript (channel, thread, ts, sender, kind, text) VALUES (@channel, @thread, @ts, @sender, @kind, @text)").run(e);
 	}
+	/**
+	* §8.5 cross-agent catch-up: conversational (`text`) rows only — tool/reasoning rows
+	* are audit/UI data and must never be replayed back into an agent's prompt. Ordered by
+	* platform `ts` (every text row carries one), compared against the session marker.
+	*/
 	transcriptSince(channel, thread, sinceTs) {
-		if (sinceTs === null) return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? ORDER BY ts ASC").all(channel, thread);
-		return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? AND ts > ? ORDER BY ts ASC").all(channel, thread, sinceTs);
+		if (sinceTs === null) return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? AND kind = 'text' ORDER BY ts ASC").all(channel, thread);
+		return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? AND kind = 'text' AND ts > ? ORDER BY ts ASC").all(channel, thread, sinceTs);
+	}
+	/** Full activity log for a thread (all kinds), in insertion order — for the Web UI. */
+	threadTranscript(channel, thread) {
+		return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? ORDER BY seq ASC").all(channel, thread);
 	}
 	openSessionAgents(channel, thread) {
 		return this.db.prepare("SELECT agentId FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed'").all(channel, thread).map((r) => r.agentId);
@@ -23379,6 +23415,7 @@ var SessionManager = class {
 			thread,
 			ts,
 			sender: msg.sender.id,
+			kind: "text",
 			text: mention ? `${msg.text}\n${mention}`.trim() : msg.text
 		});
 		let rec = this.deps.store.getSession(key);
@@ -23435,6 +23472,7 @@ var SessionManager = class {
 					thread,
 					ts: h.ts,
 					sender: h.sender,
+					kind: "text",
 					text: h.text
 				});
 			}
@@ -23487,6 +23525,58 @@ function transcriptCoords(msg) {
 	};
 }
 //#endregion
+//#region src/session/transcript-recorder.ts
+/**
+* Turns the raw ACP `session/update` stream into the *full* activity log — tool calls
+* and reasoning — independent of the agent's Slack `output.mode`. (Output mode only
+* decides what reaches the platform; the transcript records everything.)
+*
+* It deliberately does NOT emit `text`: conversational rows are recorded at the
+* platform-send boundary instead, where the real message `ts` is known (so they sort
+* against the §8.5 replay marker). Reasoning chunks are coalesced into one block per
+* run; each tool invocation is recorded once (keyed by toolCallId, so the burst of
+* `tool_call_update`s for one call collapses to a single row).
+*/
+var TranscriptRecorder = class {
+	thought = "";
+	seenTools = /* @__PURE__ */ new Set();
+	onUpdate(update) {
+		switch (update.sessionUpdate) {
+			case "agent_thought_chunk": {
+				const content = update.content;
+				this.thought += content?.text ?? "";
+				return [];
+			}
+			case "tool_call":
+			case "tool_call_update": {
+				const flushed = this.flushThought();
+				const u = update;
+				const id = u.toolCallId ?? "";
+				if (id && this.seenTools.has(id)) return flushed;
+				if (id) this.seenTools.add(id);
+				return [...flushed, {
+					kind: "tool",
+					text: u.title ?? (id || "tool")
+				}];
+			}
+			case "agent_message_chunk": return this.flushThought();
+			default: return [];
+		}
+	}
+	/** Flush any trailing reasoning when the turn ends. */
+	onFinal() {
+		return this.flushThought();
+	}
+	flushThought() {
+		const text = this.thought.trim();
+		this.thought = "";
+		return text ? [{
+			kind: "reasoning",
+			text
+		}] : [];
+	}
+};
+//#endregion
 //#region src/mcp/ipc.ts
 /** Frame a message for the wire: compact JSON + a single trailing newline. */
 function encodeFrame(msg) {
@@ -80400,7 +80490,7 @@ var OutputConverger = class {
 		};
 		if (this.mode === "low") return [...this.flush(), clear];
 		const footer = link ? [{
-			kind: "post",
+			kind: "notice",
 			text: `:white_check_mark: done — <${link}|details>`
 		}] : [];
 		return [
@@ -81977,6 +82067,7 @@ var Daemon = class {
 				thread: thread ?? ctx.thread,
 				ts,
 				sender: ctx.agentId,
+				kind: "text",
 				text
 			}),
 			maxAttachmentBytes: cfg.limits.maxAttachmentBytes
@@ -82272,6 +82363,7 @@ var Daemon = class {
 			thread,
 			ts,
 			sender: msg.sender.id,
+			kind: "text",
 			text: msg.text
 		});
 		this.log.debug(`transcript: recorded unrouted msg ch=${msg.channel} thread=${thread} ts=${ts} (live session)`);
@@ -82383,6 +82475,7 @@ var Daemon = class {
 	}
 	async dispatch(agentId, msg, integrationId) {
 		const conv = new OutputConverger(this.agents.get(agentId).output.mode);
+		const rec = new TranscriptRecorder();
 		const replyConn = this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
@@ -82390,6 +82483,8 @@ var Daemon = class {
 		const { sessionId, blocks } = await this.sessions.handle(agentId, msg);
 		const p = {
 			conv,
+			rec,
+			agentId,
 			channel: msg.channel,
 			thread: msg.thread,
 			statusThread,
@@ -82404,6 +82499,7 @@ var Daemon = class {
 			this.clearIdle(p);
 			const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
 			for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
+			for (const ev of rec.onFinal()) this.recordEvent(agentId, msg.channel, statusThread, ev);
 			await p.applyChain;
 		} finally {
 			this.clearIdle(p);
@@ -82414,7 +82510,10 @@ var Daemon = class {
 	/**
 	* Apply one converger action against the session's Slack connection:
 	*  - set-status → assistant.threads.setStatus (best-effort; '' clears)
-	*  - post       → a new thread message
+	*  - post       → a new thread message; ALSO recorded to the transcript as the
+	*    agent's reply text (sender = agentId), so other agents replaying the thread
+	*    see what it said. Keyed on `statusThread` (the §8.5 replay key).
+	*  - notice     → posted to the thread but NOT recorded (system chrome, e.g. footer).
 	*  - progress / plan → the single in-place message of that kind, posted once
 	*    then chat.update-ed (§9.1 就地更新). The first post's ts is remembered on `p`.
 	*/
@@ -82425,7 +82524,19 @@ var Daemon = class {
 			case "set-status":
 				if (p.statusThread) await conn.setStatus(p.channel, p.statusThread, action.text, action.loadingMessages);
 				return;
-			case "post":
+			case "post": {
+				const ts = await conn.postMessage(p.channel, action.text, p.thread);
+				this.store.appendTranscript({
+					channel: p.channel,
+					thread: p.statusThread,
+					ts: ts ?? `local-${Date.now()}`,
+					sender: p.agentId,
+					kind: "text",
+					text: action.text
+				});
+				return;
+			}
+			case "notice":
 				await conn.postMessage(p.channel, action.text, p.thread);
 				return;
 			case "progress":
@@ -82469,6 +82580,19 @@ var Daemon = class {
 		if (!p) return;
 		for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
 		this.armIdle(p);
+		for (const ev of p.rec.onUpdate(update)) this.recordEvent(p.agentId, p.channel, p.statusThread, ev);
+	}
+	/** Persist one internal activity event (tool/reasoning). Ordered by row `seq`, so its
+	*  `ts` is just a wall-clock stamp for display — never used for replay/sorting. */
+	recordEvent(agentId, channel, thread, ev) {
+		this.store.appendTranscript({
+			channel,
+			thread,
+			ts: String(Date.now()),
+			sender: agentId,
+			kind: ev.kind,
+			text: ev.text
+		});
 	}
 	async ensureHostAsync(agentId) {
 		const host = this.ensureHost(agentId, this.cfg);