@agentconnect.md/daemon 1.0.0-rc.65 → 1.0.0-rc.67

package/dist/index.js

@@ -13227,7 +13227,9 @@ const SessionListItem = object({
 	status: string().optional(),
 	lastActivityAt: string().optional(),
 	usage: SessionUsage.optional(),
-	triggeredBy: string().optional()
+	triggeredBy: string().optional(),
+	channelName: string().optional(),
+	triggeredByName: string().optional()
 });
 /** C→D REQ: list the daemon's sessions (optionally just one agent's). */
 const SessionListReq = object({ agentId: string().uuid().optional() });
@@ -13237,6 +13239,7 @@ const SessionListPage = object({ sessions: array(SessionListItem) });
 const SessionMessage = object({
 	seq: number().int(),
 	sender: string(),
+	senderName: string().optional(),
 	ts: string(),
 	kind: string(),
 	text: string()
@@ -13319,6 +13322,50 @@ const WorkspaceReadContent = object({
 	nextOffset: number().int().nonnegative().optional(),
 	truncated: boolean().optional()
 });
+/**
+* Agent workspace git ops (C→D REQ → REP) — the console's on-demand controls for
+* a git-repo workspace. Like list/read these run daemon-local; the CP proxies the
+* outcome and stores nothing.
+*
+* These are DATA-oriented: a non-repo workspace (`isRepo:false`), a dirty tree,
+* or a pull that can't fast-forward (offline, diverged, local edits) all come
+* back as a normal REP — NOT an `error` frame. Only an unknown agent
+* (`BAD_PAYLOAD`) or an unexpected git/fs failure (`INTERNAL`) is an error.
+*/
+/** C→D REQ: report `git status` of the agent's workspace (is it clean?). */
+const WorkspaceGitStatusReq = object({ agentId: string().min(1) });
+/** One changed path in a `git status`. `index`/`workingDir` are git's per-file XY
+*  status chars (' ', 'M', 'A', 'D', 'R', 'C', 'U', '?', …). */
+const WorkspaceGitFile = object({
+	path: string(),
+	index: string(),
+	workingDir: string()
+});
+/** D→C REP (corr = the req id): the working-tree status. */
+const WorkspaceGitStatus = object({
+	agentId: string(),
+	isRepo: boolean(),
+	clean: boolean(),
+	branch: string().optional(),
+	tracking: string().optional(),
+	ahead: number().int().nonnegative().optional(),
+	behind: number().int().nonnegative().optional(),
+	files: array(WorkspaceGitFile).optional(),
+	truncated: boolean().optional()
+});
+/** C→D REQ: force a fast-forward-only `git pull` in the agent's workspace now. */
+const WorkspaceGitPullReq = object({ agentId: string().min(1) });
+/** D→C REP (corr = the req id): the pull outcome. A failed pull is DATA
+*  (`ok:false` + `detail`), not an error frame (see the section docblock). */
+const WorkspaceGitPullResult = object({
+	agentId: string(),
+	isRepo: boolean(),
+	ok: boolean(),
+	detail: string().optional(),
+	changed: number().int().nonnegative().optional(),
+	insertions: number().int().nonnegative().optional(),
+	deletions: number().int().nonnegative().optional()
+});
 //#endregion
 //#region ../protocol/dist/frames/telemetry.js
 /**
@@ -13443,6 +13490,10 @@ const FRAME_SCHEMAS = {
 	"workspace/list/page": WorkspaceListPage,
 	"workspace/read": WorkspaceReadReq,
 	"workspace/read/content": WorkspaceReadContent,
+	"workspace/gitstatus": WorkspaceGitStatusReq,
+	"workspace/gitstatus/result": WorkspaceGitStatus,
+	"workspace/gitpull": WorkspaceGitPullReq,
+	"workspace/gitpull/result": WorkspaceGitPullResult,
 	"config/push": object({ keys: record(string(), unknown()) }),
 	"daemon/restart": object({
 		reason: string(),
@@ -13542,6 +13593,10 @@ discriminatedUnion("type", [
 	frame("workspace/list/page", FRAME_SCHEMAS["workspace/list/page"]),
 	frame("workspace/read", FRAME_SCHEMAS["workspace/read"]),
 	frame("workspace/read/content", FRAME_SCHEMAS["workspace/read/content"]),
+	frame("workspace/gitstatus", FRAME_SCHEMAS["workspace/gitstatus"]),
+	frame("workspace/gitstatus/result", FRAME_SCHEMAS["workspace/gitstatus/result"]),
+	frame("workspace/gitpull", FRAME_SCHEMAS["workspace/gitpull"]),
+	frame("workspace/gitpull/result", FRAME_SCHEMAS["workspace/gitpull/result"]),
 	frame("config/push", FRAME_SCHEMAS["config/push"]),
 	frame("daemon/restart", FRAME_SCHEMAS["daemon/restart"]),
 	frame("daemon/upgrade", FRAME_SCHEMAS["daemon/upgrade"]),
@@ -13668,7 +13723,7 @@ function isFrame(type) {
 }
 //#endregion
 //#region src/workspace/workspace-manager.ts
-const PULL_TIMEOUT_MS = 4500;
+const PULL_TIMEOUT_MS$1 = 4500;
 const cloneInFlight = /* @__PURE__ */ new Map();
 async function prepareWorkspace(agent) {
 	const cwd = agent.workspace.path;
@@ -13683,7 +13738,7 @@ async function prepareWorkspace(agent) {
 		return cwd;
 	}
 	if (agent.workspace.pullOnNewSession) try {
-		await Promise.race([simpleGit(cwd).pull(["--ff-only"]), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("pull timeout")), PULL_TIMEOUT_MS))]);
+		await Promise.race([simpleGit(cwd).pull(["--ff-only"]), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("pull timeout")), PULL_TIMEOUT_MS$1))]);
 	} catch {}
 	return cwd;
 }
@@ -23761,7 +23816,12 @@ var LocalStore = class {
       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,
-        usage TEXT, muted INTEGER
+        usage TEXT, muted INTEGER, triggeredBy TEXT
+      );
+      -- Platform id → human display name (Slack channel/user names, daemon-resolved
+      -- and cached here so session read-back can label ids without a Slack call).
+      CREATE TABLE IF NOT EXISTS display_names (
+        id TEXT PRIMARY KEY, name TEXT NOT NULL, updatedAt INTEGER
       );
       CREATE TABLE IF NOT EXISTS transcript (
         seq INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -23780,14 +23840,15 @@ var LocalStore = class {
     `);
 		this.migrateSessionUsage();
 	}
-	/** Add the `sessions.usage` (JSON token accounting) and `sessions.muted` (`!stop`
-	*  thread mute) columns to a pre-existing DB. CREATE TABLE IF NOT EXISTS above adds
-	*  them for fresh DBs but never alters an existing table, so upgrade in place.
-	*  No-op once the columns are present. */
+	/** Add the `sessions.usage` (JSON token accounting), `sessions.muted` (`!stop`
+	*  thread mute) and `sessions.triggeredBy` columns to a pre-existing DB. CREATE
+	*  TABLE IF NOT EXISTS above adds them for fresh DBs but never alters an existing
+	*  table, so upgrade in place. No-op once the columns are present. */
 	migrateSessionUsage() {
 		const cols = this.db.prepare("PRAGMA table_info(sessions)").all();
 		if (!cols.some((c) => c.name === "usage")) this.db.exec("ALTER TABLE sessions ADD COLUMN usage TEXT");
 		if (!cols.some((c) => c.name === "muted")) this.db.exec("ALTER TABLE sessions ADD COLUMN muted INTEGER");
+		if (!cols.some((c) => c.name === "triggeredBy")) this.db.exec("ALTER TABLE sessions ADD COLUMN triggeredBy TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -23837,11 +23898,12 @@ var LocalStore = class {
 		};
 	}
 	upsertSession(rec) {
-		this.db.prepare(`INSERT INTO sessions (key, agentId, platform, channel, thread, acpSessionId, state, lastDeliveredTs, updatedAt)
-         VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt)
+		this.db.prepare(`INSERT INTO sessions (key, agentId, platform, channel, thread, acpSessionId, state, lastDeliveredTs, updatedAt, triggeredBy)
+         VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt, @triggeredBy)
          ON CONFLICT(key) DO UPDATE SET
            acpSessionId=excluded.acpSessionId, state=excluded.state,
-           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`).run({
+           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt,
+           triggeredBy=COALESCE(sessions.triggeredBy, excluded.triggeredBy)`).run({
 			key: rec.key,
 			agentId: rec.agentId,
 			platform: rec.platform,
@@ -23850,7 +23912,8 @@ var LocalStore = class {
 			acpSessionId: rec.acpSessionId,
 			state: rec.state,
 			lastDeliveredTs: rec.lastDeliveredTs,
-			updatedAt: rec.updatedAt
+			updatedAt: rec.updatedAt,
+			triggeredBy: rec.triggeredBy ?? null
 		});
 	}
 	/** Targeted state transition for an existing session (§7.3), stamping `updatedAt`
@@ -23947,6 +24010,22 @@ var LocalStore = class {
 	activeSessionCountSince(channel, thread, sinceTs) {
 		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed' AND updatedAt >= ?").get(channel, thread, sinceTs)?.n ?? 0;
 	}
+	/** Cache a platform id's human display name (channel or user; Slack ids don't
+	*  collide across the two). Latest-wins — renames overwrite. */
+	setDisplayName(id, name, updatedAt) {
+		this.db.prepare(`INSERT INTO display_names (id, name, updatedAt) VALUES (?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET name=excluded.name, updatedAt=excluded.updatedAt`).run(id, name, updatedAt);
+	}
+	/** Display names for a set of platform ids — only the ids that have one.
+	*  One batched `IN (…)` query, not a round-trip per id. */
+	getDisplayNames(ids) {
+		const out = /* @__PURE__ */ new Map();
+		const unique = [...new Set(ids)];
+		if (unique.length === 0) return out;
+		const rows = this.db.prepare(`SELECT id, name FROM display_names WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+		for (const r of rows) if (r.name) out.set(r.id, r.name);
+		return out;
+	}
 	getCpRouting() {
 		return this.db.prepare("SELECT routingEpoch, assignments, globalRules FROM cp_routing WHERE id = 1").get();
 	}
@@ -24067,7 +24146,8 @@ var SessionManager = class {
 				acpSessionId,
 				state: "idle",
 				lastDeliveredTs: null,
-				updatedAt: Date.now()
+				updatedAt: Date.now(),
+				triggeredBy: msg.sender.id
 			};
 			this.deps.store.upsertSession(rec);
 		} else if (host.hasSession?.(rec.acpSessionId) === false) {
@@ -80959,6 +81039,74 @@ var SlackConnection = class {
 	}
 };
 //#endregion
+//#region src/slack/name-resolver.ts
+/**
+* Resolves Slack ids (channel "C…", user "U…/W…") to human display names off the
+* inbound-message path and caches the results into the LocalStore `display_names`
+* table, so session read-back (`session/list` / `session/history`) can label ids
+* without ever calling Slack at read time.
+*
+* Design constraints:
+*  - Fire-and-forget: never on the dispatch hot path, never throws into it.
+*  - Rate-friendly: an in-memory attempt cache means each id hits the Web API at
+*    most once per TTL (short TTL after a failure, long after success/no-name),
+*    regardless of message volume.
+*  - Names persist in SQLite, so a daemon restart keeps stale-but-useful names
+*    while the cache warms back up (rename lag is bounded by OK_TTL_MS).
+*/
+const OK_TTL_MS = 360 * 60 * 1e3;
+const FAIL_TTL_MS = 600 * 1e3;
+const MAX_TRACKED_IDS = 5e3;
+var SlackNameResolver = class {
+	save;
+	log;
+	now;
+	/** id → epoch ms until which we won't re-attempt a lookup. */
+	nextAttemptAt = /* @__PURE__ */ new Map();
+	constructor(save, log, now = Date.now) {
+		this.save = save;
+		this.log = log;
+		this.now = now;
+	}
+	/** Kick off (cached) resolution for a message's channel + human sender. */
+	noteMessage(conn, msg) {
+		this.resolveChannel(conn, msg.channel);
+		if (!msg.sender.isBot && /^[UW]/.test(msg.sender.id)) this.resolveUser(conn, msg.sender.id);
+	}
+	claim(id) {
+		const at = this.nextAttemptAt.get(id);
+		if (at !== void 0 && this.now() < at) return false;
+		this.nextAttemptAt.delete(id);
+		this.nextAttemptAt.set(id, this.now() + OK_TTL_MS);
+		for (const key of this.nextAttemptAt.keys()) {
+			if (this.nextAttemptAt.size <= MAX_TRACKED_IDS) break;
+			this.nextAttemptAt.delete(key);
+		}
+		return true;
+	}
+	async resolveChannel(conn, channel) {
+		if (!this.claim(channel)) return;
+		try {
+			const info = await conn.getChannelInfo(channel);
+			if (info.name) this.save(channel, info.name);
+		} catch (err) {
+			this.nextAttemptAt.set(channel, this.now() + FAIL_TTL_MS);
+			this.log?.debug(`slack: name lookup failed for channel ${channel}: ${err.message}`);
+		}
+	}
+	async resolveUser(conn, user) {
+		if (!this.claim(user)) return;
+		try {
+			const p = await conn.getUserProfile(user);
+			const name = p.realName || p.name;
+			if (name) this.save(user, name);
+		} catch (err) {
+			this.nextAttemptAt.set(user, this.now() + FAIL_TTL_MS);
+			this.log?.debug(`slack: name lookup failed for user ${user}: ${err.message}`);
+		}
+	}
+};
+//#endregion
 //#region src/slack/formatter.ts
 /**
 * Last-mile Slack formatting (§9.1 / §9.3). Two pure helpers:
@@ -82667,6 +82815,12 @@ var CpClient = class {
 			case "workspace/read":
 				this.deps.workspaceRead.read(frame.payload).then((content) => this.reply(frame, "workspace/read/content", content)).catch((err) => this.workspaceError(frame.id, "workspace/read", err));
 				return;
+			case "workspace/gitstatus":
+				this.deps.workspaceGit.status(frame.payload.agentId).then((status) => this.reply(frame, "workspace/gitstatus/result", status)).catch((err) => this.workspaceError(frame.id, "workspace/gitstatus", err));
+				return;
+			case "workspace/gitpull":
+				this.deps.workspaceGit.pull(frame.payload.agentId).then((result) => this.reply(frame, "workspace/gitpull/result", result)).catch((err) => this.workspaceError(frame.id, "workspace/gitpull", err));
+				return;
 			case "agent/prompt":
 				this.sendError(frame.id, "INTERNAL", "agent/prompt not implemented", false);
 				return;
@@ -82711,8 +82865,12 @@ function parseUsage(raw) {
 function createSessionReader(store) {
 	return {
 		list(req) {
-			return { sessions: store.listSessions(req.agentId).map((r) => {
+			const rows = store.listSessions(req.agentId);
+			const names = store.getDisplayNames(rows.flatMap((r) => [r.channel, ...r.triggeredBy ? [r.triggeredBy] : []]));
+			return { sessions: rows.map((r) => {
 				const usage = parseUsage(r.usage);
+				const channelName = names.get(r.channel);
+				const triggeredByName = r.triggeredBy ? names.get(r.triggeredBy) : void 0;
 				return {
 					sessionId: r.acpSessionId,
 					sessionKey: {
@@ -82723,7 +82881,10 @@ function createSessionReader(store) {
 					agentId: r.agentId,
 					status: r.state,
 					lastActivityAt: new Date(r.updatedAt).toISOString(),
-					...usage ? { usage } : {}
+					...usage ? { usage } : {},
+					...r.triggeredBy ? { triggeredBy: r.triggeredBy } : {},
+					...channelName ? { channelName } : {},
+					...triggeredByName ? { triggeredByName } : {}
 				};
 			}) };
 		},
@@ -82735,13 +82896,19 @@ function createSessionReader(store) {
 			};
 			const before = req.cursor != null && Number.isFinite(Number(req.cursor)) ? Number(req.cursor) : null;
 			const { rows, hasMore } = store.transcriptPage(rec.channel, rec.thread, before, req.limit);
-			const messages = rows.slice().reverse().map((r) => ({
-				seq: r.seq,
-				sender: r.sender,
-				ts: r.ts,
-				kind: r.kind,
-				text: r.text
-			}));
+			const ordered = rows.slice().reverse();
+			const names = store.getDisplayNames(ordered.map((r) => r.sender));
+			const messages = ordered.map((r) => {
+				const senderName = names.get(r.sender);
+				return {
+					seq: r.seq,
+					sender: r.sender,
+					...senderName ? { senderName } : {},
+					ts: r.ts,
+					kind: r.kind,
+					text: r.text
+				};
+			});
 			return {
 				sessionId: req.sessionId,
 				messages,
@@ -82751,6 +82918,104 @@ function createSessionReader(store) {
 	};
 }
 //#endregion
+//#region src/cp/workspace-git.ts
+/**
+* `WorkspaceGit` — the seam answering the CP's `workspace/gitstatus` and
+* `workspace/gitpull` REQs against an agent's local git-repo workspace. Sibling
+* to {@link WorkspaceReader}: git runs daemon-local and only the outcome is
+* proxied to the console (§1/§12), never the repo.
+*
+* DATA vs error: a from-scratch workspace (`isRepo:false`), a dirty tree, or a
+* pull that can't fast-forward (offline, diverged, would clobber local edits) are
+* all normal REPs — the caller renders them. Only an unknown agentId throws
+* ({@link WorkspaceViolationError} → `BAD_PAYLOAD`); an unexpected git/fs failure
+* on `status` propagates (→ `INTERNAL`). Git-provided text is scrubbed of the
+* absolute workspace path before it leaves the daemon (raw git errors embed host
+* paths that must not reach the CP/UI).
+*/
+/** On-demand pull is interactive, so allow more headroom than the 4.5s
+*  best-effort pull at session start (workspace-manager.ts). */
+const PULL_TIMEOUT_MS = 2e4;
+/** Cap the changed-file list so a huge working tree can't overflow the frame. */
+const MAX_STATUS_FILES = 500;
+function createWorkspaceGit(workspaceRootByAgent) {
+	function rootFor(agentId) {
+		const root = workspaceRootByAgent(agentId);
+		if (!root) throw new WorkspaceViolationError(`unknown agent "${agentId}"`);
+		return root;
+	}
+	/** A git-repo workspace has a `.git` at its root; from-scratch does not. */
+	function isRepo(root) {
+		return existsSync(join(root, ".git"));
+	}
+	/** Strip the absolute workspace path out of git-provided text so no host path
+	*  leaks to the CP/UI. Repo-relative paths in the message are kept. */
+	function scrub(root, msg) {
+		return msg.split(root).join("<workspace>").trim();
+	}
+	return {
+		async status(agentId) {
+			const root = rootFor(agentId);
+			if (!isRepo(root)) return {
+				agentId,
+				isRepo: false,
+				clean: true
+			};
+			const s = await simpleGit(root).status();
+			const files = s.files.slice(0, MAX_STATUS_FILES).map((f) => ({
+				path: f.path,
+				index: f.index,
+				workingDir: f.working_dir
+			}));
+			return {
+				agentId,
+				isRepo: true,
+				clean: s.isClean(),
+				...s.current ? { branch: s.current } : {},
+				...s.tracking ? { tracking: s.tracking } : {},
+				ahead: s.ahead,
+				behind: s.behind,
+				...files.length ? { files } : {},
+				...s.files.length > files.length ? { truncated: true } : {}
+			};
+		},
+		async pull(agentId) {
+			const root = rootFor(agentId);
+			if (!isRepo(root)) return {
+				agentId,
+				isRepo: false,
+				ok: false,
+				detail: "workspace is not a git checkout"
+			};
+			let timer;
+			try {
+				const res = await Promise.race([simpleGit(root).pull(["--ff-only"]), new Promise((_, rej) => {
+					timer = setTimeout(() => rej(/* @__PURE__ */ new Error("pull timed out")), PULL_TIMEOUT_MS);
+				})]);
+				const changed = res.files.length;
+				return {
+					agentId,
+					isRepo: true,
+					ok: true,
+					changed,
+					insertions: res.summary.insertions,
+					deletions: res.summary.deletions,
+					detail: changed > 0 ? `Fast-forwarded — updated ${changed} file${changed === 1 ? "" : "s"}.` : "Already up to date."
+				};
+			} catch (err) {
+				return {
+					agentId,
+					isRepo: true,
+					ok: false,
+					detail: scrub(root, err?.message ?? "pull failed")
+				};
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/cp/cp-cron.ts
 /**
 * `CpCronRegistry` — the daemon's set of CP-pushed crons, keyed by `cronId`
@@ -83178,6 +83443,7 @@ var Daemon = class Daemon {
 	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	connections = [];
+	nameResolver;
 	scheduler;
 	sessions;
 	connByIntegration = /* @__PURE__ */ new Map();
@@ -83247,6 +83513,7 @@ var Daemon = class Daemon {
 		const skipped = Object.keys(resolvedRuntimes).filter((id) => !this.runtimes[id]);
 		if (skipped.length) this.log.info(`runtimes not installed (skipped): ${skipped.join(", ")}`);
 		this.store = new LocalStore(statePath(root));
+		this.nameResolver = new SlackNameResolver((id, name) => this.store.setDisplayName(id, name, Date.now()), this.log);
 		this.cpRouting = new CpRoutingLayer({
 			load: () => {
 				const row = this.store.getCpRouting();
@@ -83321,7 +83588,10 @@ var Daemon = class Daemon {
 			const conn = new SlackConnection({
 				group,
 				newTraceId: () => randomUUID(),
-				onMessage: (msg) => this.onInbound(msg),
+				onMessage: (msg) => {
+					this.nameResolver?.noteMessage(conn, msg);
+					this.onInbound(msg);
+				},
 				onChannelsChanged: () => void this.refreshChannels(conn),
 				log: this.log,
 				boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
@@ -83495,7 +83765,10 @@ var Daemon = class Daemon {
 				const conn = new SlackConnection({
 					group,
 					newTraceId: () => randomUUID(),
-					onMessage: (msg) => this.onInbound(msg),
+					onMessage: (msg) => {
+						this.nameResolver?.noteMessage(conn, msg);
+						this.onInbound(msg);
+					},
 					onChannelsChanged: () => void this.refreshChannels(conn),
 					log: this.log,
 					boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
@@ -83526,6 +83799,7 @@ var Daemon = class Daemon {
 		try {
 			const channels = await conn.listBotChannels();
 			if (!channels) return;
+			for (const c of channels) if (c.name) this.store.setDisplayName(c.id, c.name, Date.now());
 			for (const [integrationId, c] of this.connByIntegration) {
 				if (c !== conn) continue;
 				this.channelSnapshots.set(integrationId, channels);
@@ -84250,6 +84524,7 @@ var Daemon = class Daemon {
 			configApply: this.cpConfigApply(),
 			sessionRead: createSessionReader(this.store),
 			workspaceRead: createWorkspaceReader((id) => this.agents.get(id)?.workspace.path),
+			workspaceGit: createWorkspaceGit((id) => this.agents.get(id)?.workspace.path),
 			clock: systemClock,
 			connect: () => ClientTransport.dial(url),
 			log: this.log