@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/session/filesystem-capture.js

@@ -0,0 +1,231 @@
+import { peekSessionSandbox, sessionLayout } from "../sandbox/session-sandbox.js";
+import { peekSessionEnvironment } from "./environment-state-processor.js";
+import { isMeaningfulToolName } from "./first-exec-capture.js";
+//#region src/session/filesystem-capture.ts
+/** Exit code of `GIT_CHANGED_FILES_SCRIPT` when the checkout is not there: the repository is skipped, not failed. */
+const CHECKOUT_MISSING_EXIT_CODE = 3;
+const GIT_CHANGED_FILES_SCRIPT = `
+set -e
+workdir=$1
+base_branch=$2
+test -d "$workdir" || exit ${CHECKOUT_MISSING_EXIT_CODE}
+base=HEAD
+if merge_base=$(git -C "$workdir" merge-base HEAD "origin/$base_branch" 2>/dev/null); then
+  base=$merge_base
+fi
+git -C "$workdir" diff --name-only -z --find-renames --diff-filter=ACMRTUXB "$base"
+git -C "$workdir" ls-files --others --exclude-standard -z
+`;
+const ARTIFACTS_LIST_COMMAND = "cd \"$1\" && test -d .artifacts && find .artifacts -type f -print0 || true";
+/**
+* Regular files directly under the workspace root written since the session
+* was created ($2 is a UTC `touch -t` stamp, `YYYYMMDDhhmm.SS`), such as the
+* agent's notes. Files the template shipped with predate the session and stay
+* out; the checkouts are covered by git. Dotfiles are never listed: a listed
+* path becomes readable through the thread's file route, and the root is where
+* setup leaves `.env`, `.pgpass`, `.netrc` and other credential files.
+* `touch -t` plus `-newer` works on GNU and BSD find alike; `-newermt
+* "@epoch"` is GNU only.
+*/
+const ROOT_FILES_LIST_COMMAND = [
+	"cd \"$1\" && ref=$(mktemp) && TZ=UTC touch -t \"$2\" \"$ref\"",
+	"&& find . -mindepth 1 -maxdepth 1 -type f ! -name '.*' -newer \"$ref\" -print0",
+	"; status=$?; rm -f \"$ref\"; exit $status"
+].join(" ");
+/** `touch -t` stamp of a moment, in UTC. */
+function touchStamp(date) {
+	const two = (value) => String(value).padStart(2, "0");
+	return `${date.getUTCFullYear()}${two(date.getUTCMonth() + 1)}${two(date.getUTCDate())}${two(date.getUTCHours())}${two(date.getUTCMinutes())}.${two(date.getUTCSeconds())}`;
+}
+function parseFilesystemCaptureFiles(output) {
+	const files = /* @__PURE__ */ new Map();
+	for (const record of output.split("\0")) {
+		if (!record) continue;
+		const path = record.replace(/^\.\//, "");
+		if (path) files.set(path, { path });
+	}
+	return [...files.values()].toSorted((a, b) => a.path.localeCompare(b.path));
+}
+async function captureSessionFilesystem(session, { filesystem, sourceControl }, ids) {
+	try {
+		const resourceId = ids?.resourceId ?? session.identity.getResourceId();
+		const threadId = ids?.threadId ?? session.thread.requireId();
+		const sourceSession = await sourceControl.sessions.getBySessionId(resourceId);
+		const sandbox = session.getWorkspace()?.sandbox;
+		if (!sourceSession || !sandbox?.executeCommand) return;
+		const entry = peekSessionSandbox(sourceSession.id);
+		if (!entry) return;
+		if (entry.sandbox.status !== "running") return;
+		const layout = sessionLayout(entry);
+		if (!layout) return;
+		const multiRepo = layout.repos.length > 1;
+		const environment = multiRepo ? peekSessionEnvironment(sourceSession.sessionId) : void 0;
+		const ownRepo = entry.ownRepo.toLowerCase();
+		const baseBranchFor = (repo) => {
+			if (repo.slug.toLowerCase() === ownRepo) return sourceSession.baseBranch;
+			return (environment?.repositories.find((candidate) => candidate.slug.toLowerCase() === repo.slug.toLowerCase()))?.defaultBranch ?? "HEAD";
+		};
+		const targets = layout.repos.map((repo) => ({
+			repo,
+			baseBranch: baseBranchFor(repo)
+		}));
+		const executeCommand = sandbox.executeCommand.bind(sandbox);
+		const results = await Promise.all(targets.map(({ repo, baseBranch }) => executeCommand("sh", [
+			"-c",
+			GIT_CHANGED_FILES_SCRIPT,
+			"mastracode-changed-files",
+			repo.dir,
+			baseBranch
+		], { timeout: 3e4 })));
+		const files = /* @__PURE__ */ new Map();
+		let captured = 0;
+		for (const [index, result] of results.entries()) {
+			if (result.exitCode === CHECKOUT_MISSING_EXIT_CODE) continue;
+			if (result.exitCode !== 0) {
+				console.warn("[Factory filesystem capture] Unable to inspect Git changes.", result.stderr);
+				return;
+			}
+			captured += 1;
+			const prefix = targets[index].repo.prefix;
+			for (const file of parseFilesystemCaptureFiles(result.stdout)) files.set(`${prefix}${file.path}`, { path: `${prefix}${file.path}` });
+		}
+		if (captured === 0) return;
+		const artifacts = await executeCommand("sh", [
+			"-c",
+			ARTIFACTS_LIST_COMMAND,
+			"sh",
+			layout.root
+		], { timeout: 3e4 });
+		if (artifacts.exitCode !== 0) {
+			console.warn("[Factory filesystem capture] Unable to list workspace artifacts.", artifacts.stderr);
+			return;
+		}
+		for (const path of artifacts.stdout.split("\0")) {
+			const normalizedPath = path.replace(/^\.\//, "");
+			if (normalizedPath) files.set(normalizedPath, { path: normalizedPath });
+		}
+		if (multiRepo) {
+			const since = touchStamp(sourceSession.createdAt);
+			const rootFiles = await executeCommand("sh", [
+				"-c",
+				ROOT_FILES_LIST_COMMAND,
+				"sh",
+				layout.root,
+				since
+			], { timeout: 3e4 });
+			if (rootFiles.exitCode !== 0) console.warn("[Factory filesystem capture] Unable to list workspace root files.", rootFiles.stderr);
+			else for (const path of rootFiles.stdout.split("\0")) {
+				const normalizedPath = path.replace(/^\.\//, "");
+				if (normalizedPath && !normalizedPath.startsWith(".")) files.set(normalizedPath, { path: normalizedPath });
+			}
+		}
+		await filesystem.replaceFiles({
+			resourceId,
+			threadId,
+			files: [...files.values()].toSorted((a, b) => a.path.localeCompare(b.path))
+		});
+	} catch (error) {
+		console.warn("[Factory filesystem capture] Unable to persist files.", error);
+	}
+}
+/**
+* In-flight capture chains keyed by session resource id. Serves two purposes:
+* readers of the persisted file listing (the /web/workspace routes) await the
+* capture for the turn that just ended instead of racing it, and captures for
+* the same resource stay sequential (last write wins) even when multiple
+* scoped sessions observe the same resource id. In-process only: the factory
+* server that runs the session controller also serves those routes.
+*/
+const pendingCaptures = /* @__PURE__ */ new Map();
+/**
+* Resolve once the session's in-flight filesystem capture (if any) has
+* persisted, or after `timeoutMs` so a reader that arrives mid-capture is
+* never blocked by the execs' worst-case 30s timeouts. Never rejects: the
+* capture body is fully try/catch contained.
+*/
+async function waitForPendingFilesystemCapture(resourceId, timeoutMs = 1e4) {
+	let pending = pendingCaptures.get(resourceId);
+	if (!pending) return;
+	let timer;
+	let timedOut = false;
+	const deadline = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			timedOut = true;
+			resolve();
+		}, timeoutMs);
+	});
+	try {
+		while (pending && !timedOut) {
+			await Promise.race([pending, deadline]);
+			const next = pendingCaptures.get(resourceId);
+			pending = next === pending ? void 0 : next;
+		}
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function observeSessionFilesystem(session, dependencies) {
+	let fallbackChain = Promise.resolve();
+	let workspaceTouched = false;
+	const toolNames = /* @__PURE__ */ new Map();
+	const suspended = /* @__PURE__ */ new Set();
+	const unsubscribeEvents = session.subscribe((event) => {
+		switch (event.type) {
+			case "tool_start":
+				toolNames.set(event.toolCallId, event.toolName);
+				return;
+			case "tool_suspended":
+				suspended.add(event.toolCallId);
+				return;
+			case "tool_suspension_cancelled":
+				toolNames.delete(event.toolCallId);
+				suspended.delete(event.toolCallId);
+				return;
+			case "agent_end":
+				for (const id of toolNames.keys()) if (!suspended.has(id)) toolNames.delete(id);
+				return;
+			case "tool_end": {
+				const toolName = toolNames.get(event.toolCallId);
+				toolNames.delete(event.toolCallId);
+				suspended.delete(event.toolCallId);
+				if (event.isError || event.denied) return;
+				if (isMeaningfulToolName(toolName)) workspaceTouched = true;
+				return;
+			}
+		}
+	});
+	const unsubscribeEnd = session.onBeforeAgentEnd(() => {
+		if (!workspaceTouched) return;
+		workspaceTouched = false;
+		let resourceId;
+		try {
+			resourceId = session.identity.getResourceId();
+		} catch {
+			fallbackChain = fallbackChain.then(() => captureSessionFilesystem(session, dependencies));
+			return;
+		}
+		let threadId;
+		try {
+			threadId = session.thread.requireId();
+		} catch {
+			return;
+		}
+		const ids = {
+			resourceId,
+			threadId
+		};
+		const chain = (pendingCaptures.get(resourceId) ?? Promise.resolve()).then(() => captureSessionFilesystem(session, dependencies, ids));
+		pendingCaptures.set(resourceId, chain);
+		chain.finally(() => {
+			if (pendingCaptures.get(resourceId) === chain) pendingCaptures.delete(resourceId);
+		});
+	});
+	return () => {
+		unsubscribeEvents();
+		unsubscribeEnd();
+	};
+}
+//#endregion
+export { ROOT_FILES_LIST_COMMAND, captureSessionFilesystem, observeSessionFilesystem, parseFilesystemCaptureFiles, touchStamp, waitForPendingFilesystemCapture };
+
+//# sourceMappingURL=filesystem-capture.js.map

package/dist/session/filesystem-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-capture.js","names":[],"sources":["../../src/session/filesystem-capture.ts"],"sourcesContent":["import type { AgentControllerEvent, SessionBeforeAgentEndListener } from '@mastra/core/agent-controller';\nimport type { WorkspaceSandbox } from '@mastra/core/workspace';\nimport { peekSessionSandbox, sessionLayout } from '../sandbox/session-sandbox.js';\nimport type { SessionLayoutRepository } from '../sandbox/session-sandbox.js';\n\nimport type { FilesystemFile, FilesystemStorage } from '../storage/domains/filesystem/base.js';\nimport type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';\nimport { peekSessionEnvironment } from './environment-state-processor.js';\nimport { isMeaningfulToolName } from './first-exec-capture.js';\n\n/** Exit code of `GIT_CHANGED_FILES_SCRIPT` when the checkout is not there: the repository is skipped, not failed. */\nconst CHECKOUT_MISSING_EXIT_CODE = 3;\nconst GIT_CHANGED_FILES_SCRIPT = `\nset -e\nworkdir=$1\nbase_branch=$2\ntest -d \"$workdir\" || exit ${CHECKOUT_MISSING_EXIT_CODE}\nbase=HEAD\nif merge_base=$(git -C \"$workdir\" merge-base HEAD \"origin/$base_branch\" 2>/dev/null); then\n  base=$merge_base\nfi\ngit -C \"$workdir\" diff --name-only -z --find-renames --diff-filter=ACMRTUXB \"$base\"\ngit -C \"$workdir\" ls-files --others --exclude-standard -z\n`;\nconst ARTIFACTS_LIST_COMMAND = 'cd \"$1\" && test -d .artifacts && find .artifacts -type f -print0 || true';\n/**\n * Regular files directly under the workspace root written since the session\n * was created ($2 is a UTC `touch -t` stamp, `YYYYMMDDhhmm.SS`), such as the\n * agent's notes. Files the template shipped with predate the session and stay\n * out; the checkouts are covered by git. Dotfiles are never listed: a listed\n * path becomes readable through the thread's file route, and the root is where\n * setup leaves `.env`, `.pgpass`, `.netrc` and other credential files.\n * `touch -t` plus `-newer` works on GNU and BSD find alike; `-newermt\n * \"@epoch\"` is GNU only.\n */\nexport const ROOT_FILES_LIST_COMMAND = [\n  'cd \"$1\" && ref=$(mktemp) && TZ=UTC touch -t \"$2\" \"$ref\"',\n  '&& find . -mindepth 1 -maxdepth 1 -type f ! -name \\'.*\\' -newer \"$ref\" -print0',\n  '; status=$?; rm -f \"$ref\"; exit $status',\n].join(' ');\n\n/** `touch -t` stamp of a moment, in UTC. */\nexport function touchStamp(date: Date): string {\n  const two = (value: number) => String(value).padStart(2, '0');\n  return (\n    `${date.getUTCFullYear()}${two(date.getUTCMonth() + 1)}${two(date.getUTCDate())}` +\n    `${two(date.getUTCHours())}${two(date.getUTCMinutes())}.${two(date.getUTCSeconds())}`\n  );\n}\n\nexport interface FilesystemCaptureSession {\n  readonly identity: { getResourceId(): string };\n  readonly thread: { requireId(): string };\n  getWorkspace(): { sandbox?: Pick<WorkspaceSandbox, 'executeCommand'> } | undefined;\n  onBeforeAgentEnd(listener: SessionBeforeAgentEndListener): () => void;\n  subscribe(listener: (event: AgentControllerEvent) => void): () => void;\n}\n\nexport interface FilesystemCaptureDependencies {\n  filesystem: Pick<FilesystemStorage, 'replaceFiles'>;\n  sourceControl: {\n    sessions: Pick<SourceControlStorageHandle['sessions'], 'getBySessionId'>;\n  };\n}\n\nexport function parseFilesystemCaptureFiles(output: string): FilesystemFile[] {\n  const files = new Map<string, FilesystemFile>();\n  for (const record of output.split('\\0')) {\n    if (!record) continue;\n    const path = record.replace(/^\\.\\//, '');\n    if (path) files.set(path, { path });\n  }\n\n  return [...files.values()].toSorted((a, b) => a.path.localeCompare(b.path));\n}\n\nexport async function captureSessionFilesystem(\n  session: FilesystemCaptureSession,\n  { filesystem, sourceControl }: FilesystemCaptureDependencies,\n  ids?: { resourceId: string; threadId: string },\n): Promise<void> {\n  try {\n    // Scheduled captures pass ids read at schedule time: a session deleted\n    // before the queued capture runs has already cleared its thread.\n    const resourceId = ids?.resourceId ?? session.identity.getResourceId();\n    const threadId = ids?.threadId ?? session.thread.requireId();\n    const sourceSession = await sourceControl.sessions.getBySessionId(resourceId);\n    // Chat-only sessions run without a workspace; there is nothing to capture.\n    const sandbox = session.getWorkspace()?.sandbox;\n    if (!sourceSession || !sandbox?.executeCommand) return;\n    // The live workdir comes from the per-process memo (the deterministic\n    // truth) ONLY — never the persisted observability column, which a row\n    // written under a previous provider can point at a workdir that no\n    // longer exists (the stale-workdir incident class). No memo entry means\n    // no live sandbox worth capturing in this replica; capture is\n    // best-effort telemetry, so skip.\n    const entry = peekSessionSandbox(sourceSession.id);\n    if (!entry) return;\n    // Telemetry must never provision a VM: executeCommand lazily starts the\n    // sandbox via ensureRunning, so a chat turn that never touched the\n    // workspace would otherwise boot (and clone into) a fresh VM just to\n    // capture an empty git status. Only capture when the turn already has a\n    // running sandbox.\n    if (entry.sandbox.status !== 'running') return;\n    // Running-but-unresolved should not happen (the start hook resolves the\n    // workdir), but capture is best-effort: skip rather than guess.\n    const layout = sessionLayout(entry);\n    if (!layout) return;\n\n    // One git pass per checkout, in parallel so three repositories stay well\n    // inside the 10 s readers wait for a pending capture. The session's own\n    // repository compares against the session base branch; the others sit on\n    // their default branch and compare against that. A repository whose\n    // checkout is missing (exit 3) is skipped: it has nothing to list and\n    // must not block the others. Any other failure is treated as transient\n    // and leaves the previous listing in place.\n    const multiRepo = layout.repos.length > 1;\n    const environment = multiRepo ? peekSessionEnvironment(sourceSession.sessionId) : undefined;\n    const ownRepo = entry.ownRepo.toLowerCase();\n    // The boot records the state at its end, after every setup command; until\n    // then a secondary checkout compares against its own `origin/HEAD`.\n    const baseBranchFor = (repo: SessionLayoutRepository): string => {\n      if (repo.slug.toLowerCase() === ownRepo) return sourceSession.baseBranch;\n      const state = environment?.repositories.find(\n        candidate => candidate.slug.toLowerCase() === repo.slug.toLowerCase(),\n      );\n      return state?.defaultBranch ?? 'HEAD';\n    };\n    const targets = layout.repos.map(repo => ({ repo, baseBranch: baseBranchFor(repo) }));\n    const executeCommand = sandbox.executeCommand.bind(sandbox);\n    const results = await Promise.all(\n      targets.map(({ repo, baseBranch }) =>\n        executeCommand('sh', ['-c', GIT_CHANGED_FILES_SCRIPT, 'mastracode-changed-files', repo.dir, baseBranch], {\n          timeout: 30_000,\n        }),\n      ),\n    );\n    const files = new Map<string, FilesystemFile>();\n    let captured = 0;\n    for (const [index, result] of results.entries()) {\n      if (result.exitCode === CHECKOUT_MISSING_EXIT_CODE) continue;\n      if (result.exitCode !== 0) {\n        console.warn('[Factory filesystem capture] Unable to inspect Git changes.', result.stderr);\n        return;\n      }\n      captured += 1;\n      const prefix = targets[index]!.repo.prefix;\n      for (const file of parseFilesystemCaptureFiles(result.stdout)) {\n        files.set(`${prefix}${file.path}`, { path: `${prefix}${file.path}` });\n      }\n    }\n    if (captured === 0) return;\n\n    const artifacts = await executeCommand('sh', ['-c', ARTIFACTS_LIST_COMMAND, 'sh', layout.root], {\n      timeout: 30_000,\n    });\n    if (artifacts.exitCode !== 0) {\n      console.warn('[Factory filesystem capture] Unable to list workspace artifacts.', artifacts.stderr);\n      return;\n    }\n    for (const path of artifacts.stdout.split('\\0')) {\n      const normalizedPath = path.replace(/^\\.\\//, '');\n      if (normalizedPath) {\n        files.set(normalizedPath, { path: normalizedPath });\n      }\n    }\n\n    // With several checkouts the root is a plain directory nothing else lists.\n    // A failed listing is logged and the git and artifact results still land.\n    if (multiRepo) {\n      const since = touchStamp(sourceSession.createdAt);\n      const rootFiles = await executeCommand('sh', ['-c', ROOT_FILES_LIST_COMMAND, 'sh', layout.root, since], {\n        timeout: 30_000,\n      });\n      if (rootFiles.exitCode !== 0) {\n        console.warn('[Factory filesystem capture] Unable to list workspace root files.', rootFiles.stderr);\n      } else {\n        for (const path of rootFiles.stdout.split('\\0')) {\n          const normalizedPath = path.replace(/^\\.\\//, '');\n          if (normalizedPath && !normalizedPath.startsWith('.')) {\n            files.set(normalizedPath, { path: normalizedPath });\n          }\n        }\n      }\n    }\n\n    await filesystem.replaceFiles({\n      resourceId,\n      threadId,\n      files: [...files.values()].toSorted((a, b) => a.path.localeCompare(b.path)),\n    });\n  } catch (error) {\n    console.warn('[Factory filesystem capture] Unable to persist files.', error);\n  }\n}\n\n/**\n * In-flight capture chains keyed by session resource id. Serves two purposes:\n * readers of the persisted file listing (the /web/workspace routes) await the\n * capture for the turn that just ended instead of racing it, and captures for\n * the same resource stay sequential (last write wins) even when multiple\n * scoped sessions observe the same resource id. In-process only: the factory\n * server that runs the session controller also serves those routes.\n */\nconst pendingCaptures = new Map<string, Promise<void>>();\n\n/**\n * Resolve once the session's in-flight filesystem capture (if any) has\n * persisted, or after `timeoutMs` so a reader that arrives mid-capture is\n * never blocked by the execs' worst-case 30s timeouts. Never rejects: the\n * capture body is fully try/catch contained.\n */\nexport async function waitForPendingFilesystemCapture(resourceId: string, timeoutMs = 10_000): Promise<void> {\n  let pending = pendingCaptures.get(resourceId);\n  if (!pending) return;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let timedOut = false;\n  const deadline = new Promise<void>(resolve => {\n    timer = setTimeout(() => {\n      timedOut = true;\n      resolve();\n    }, timeoutMs);\n  });\n  try {\n    // A turn that ends while we wait chains a successor capture; keep waiting\n    // until the latest chain settles so the final snapshot is not lost.\n    while (pending && !timedOut) {\n      await Promise.race([pending, deadline]);\n      const next = pendingCaptures.get(resourceId);\n      pending = next === pending ? undefined : next;\n    }\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\nexport function observeSessionFilesystem(\n  session: FilesystemCaptureSession,\n  dependencies: FilesystemCaptureDependencies,\n): () => void {\n  let fallbackChain = Promise.resolve();\n  // Capture only runs after a turn that actually touched the workspace: a\n  // successful workspace tool call both proves the sandbox is awake and is\n  // the only way the listing can have changed. Without this gate every chat\n  // turn would run two sandbox execs — and since executeCommand resumes an\n  // idle VM, a pure-chat turn would keep waking a sandbox it never used.\n  // Same bookkeeping as first-exec capture: tool names resolve at tool_end\n  // via the tool_start map, and suspended calls survive agent_end so a\n  // resumed run's eventual completion still counts for that turn.\n  let workspaceTouched = false;\n  const toolNames = new Map<string, string>();\n  const suspended = new Set<string>();\n  const unsubscribeEvents = session.subscribe(event => {\n    switch (event.type) {\n      case 'tool_start': {\n        toolNames.set(event.toolCallId, event.toolName);\n        return;\n      }\n      case 'tool_suspended': {\n        suspended.add(event.toolCallId);\n        return;\n      }\n      case 'tool_suspension_cancelled': {\n        toolNames.delete(event.toolCallId);\n        suspended.delete(event.toolCallId);\n        return;\n      }\n      case 'agent_end': {\n        for (const id of toolNames.keys()) {\n          if (!suspended.has(id)) toolNames.delete(id);\n        }\n        return;\n      }\n      case 'tool_end': {\n        const toolName = toolNames.get(event.toolCallId);\n        toolNames.delete(event.toolCallId);\n        suspended.delete(event.toolCallId);\n        if (event.isError || event.denied) return;\n        if (isMeaningfulToolName(toolName)) workspaceTouched = true;\n        return;\n      }\n    }\n  });\n  const unsubscribeEnd = session.onBeforeAgentEnd(() => {\n    // onBeforeAgentEnd fires before agent_end is emitted, so every tool_end\n    // of the finishing run has already been observed; read then reset.\n    if (!workspaceTouched) return;\n    workspaceTouched = false;\n    // Chain so captures stay sequential (last write wins), but do NOT return\n    // the chain: finishAgentRun awaits every listener before emitting\n    // agent_end, and the capture's sandbox execs (git status + artifacts\n    // find, 30s timeouts each) must not gate turn completion. Readers that\n    // need the fresh listing await the pending capture through\n    // waitForPendingFilesystemCapture instead. The un-returned chain cannot\n    // leak an unhandled rejection: captureSessionFilesystem's entire body\n    // runs inside its own try/catch, and disposal of this listener does not\n    // cancel an in-flight chain, so a final turn's capture still persists.\n    let resourceId: string | undefined;\n    try {\n      resourceId = session.identity.getResourceId();\n    } catch {\n      // No resource id means no route can address this session's listing;\n      // keep a per-observer chain so captures still run sequentially.\n      fallbackChain = fallbackChain.then(() => captureSessionFilesystem(session, dependencies));\n      return;\n    }\n    // Extend the resource-level chain rather than a per-session one: sessions\n    // are deduplicated by (resourceId, scope), so multiple scoped sessions can\n    // observe the same resource, and their captures must not interleave.\n    let threadId: string;\n    try {\n      threadId = session.thread.requireId();\n    } catch {\n      return;\n    }\n    const ids = { resourceId, threadId };\n    const chain = (pendingCaptures.get(resourceId) ?? Promise.resolve()).then(() =>\n      captureSessionFilesystem(session, dependencies, ids),\n    );\n    pendingCaptures.set(resourceId, chain);\n    void chain.finally(() => {\n      if (pendingCaptures.get(resourceId) === chain) {\n        pendingCaptures.delete(resourceId);\n      }\n    });\n  });\n  return () => {\n    unsubscribeEvents();\n    unsubscribeEnd();\n  };\n}\n"],"mappings":"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"}

package/dist/session/first-exec-capture.d.ts

@@ -0,0 +1,38 @@
+import type { AgentControllerEvent } from '@mastra/core/agent-controller';
+import type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';
+export interface FirstExecCaptureSession {
+    readonly identity: {
+        getResourceId(): string;
+    };
+    subscribe(listener: (event: AgentControllerEvent) => void): () => void;
+}
+export interface FirstExecCaptureDependencies {
+    sourceControl: {
+        sessions: Pick<SourceControlStorageHandle['sessions'], 'markFirstMeaningfulExec'>;
+    };
+}
+export declare function isMeaningfulToolName(name: string | undefined): boolean;
+/**
+ * Record when a session's agent completed its first successful meaningful
+ * tool call (the TTFME anchor — "time to first meaningful exec").
+ *
+ * Meaningful = a workspace tool the agent invoked itself (filesystem,
+ * search, code intelligence, sandbox exec, process control). We accept any
+ * tool whose name starts with the workspace prefix `mastra_workspace_` or
+ * matches the post-remap mastracode tool names. Non-workspace tools (memory,
+ * notification inbox, subagent, etc.) and skill-loader / preflight /
+ * materializer `sandbox.executeCommand()` calls that never flow through the
+ * tool layer are intentionally excluded.
+ *
+ * Failed tool calls (`isError === true`) don't count. Approval-denied and
+ * abort-while-parked tool completions (`denied === true`) also don't count:
+ * the run-engine emits `tool_end` with `isError: false` for those paths
+ * because the tool didn't fail, but it also never ran, so treating them as
+ * "meaningful exec" would re-introduce the same contamination this fix is
+ * removing on the message side. The listener stays subscribed until a
+ * successful qualifying end, then unsubscribes. The storage write is guarded
+ * (`first_meaningful_exec_at IS NULL`), so restarts, re-materialized
+ * sessions, and sessions without a source-control row are no-ops.
+ */
+export declare function observeSessionFirstExec(session: FirstExecCaptureSession, { sourceControl }: FirstExecCaptureDependencies): () => void;
+//# sourceMappingURL=first-exec-capture.d.ts.map

package/dist/session/first-exec-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-exec-capture.d.ts","sourceRoot":"","sources":["../../src/session/first-exec-capture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAG1E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AAE5F,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE;QAAE,aAAa,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/C,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACxE;AAED,MAAM,WAAW,4BAA4B;IAC3C,aAAa,EAAE;QACb,QAAQ,EAAE,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,EAAE,yBAAyB,CAAC,CAAC;KACnF,CAAC;CACH;AA6BD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAItE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,uBAAuB,EAChC,EAAE,aAAa,EAAE,EAAE,4BAA4B,GAC9C,MAAM,IAAI,CAoDZ"}

package/dist/session/first-exec-capture.js

@@ -0,0 +1,91 @@
+import { WORKSPACE_TOOLS_PREFIX } from "@mastra/core/workspace";
+//#region src/session/first-exec-capture.ts
+/**
+* Tool names that count as "meaningful exec" independent of the workspace
+* prefix. The workspace tools get remapped from `mastra_workspace_*` to
+* mastracode-friendly names (see `mastracode/sdk/src/tool-names.ts`), and
+* this listener runs on the emitted tool name after remap, so both spellings
+* need to match.
+*/
+const MEANINGFUL_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"view",
+	"write_file",
+	"string_replace_lsp",
+	"find_files",
+	"delete_file",
+	"file_stat",
+	"mkdir",
+	"search_content",
+	"ast_smart_edit",
+	"lsp_inspect",
+	"execute_command",
+	"get_process_output",
+	"kill_process"
+]);
+function isMeaningfulToolName(name) {
+	if (!name) return false;
+	if (name.startsWith(`${WORKSPACE_TOOLS_PREFIX}_`)) return true;
+	return MEANINGFUL_TOOL_NAMES.has(name);
+}
+/**
+* Record when a session's agent completed its first successful meaningful
+* tool call (the TTFME anchor — "time to first meaningful exec").
+*
+* Meaningful = a workspace tool the agent invoked itself (filesystem,
+* search, code intelligence, sandbox exec, process control). We accept any
+* tool whose name starts with the workspace prefix `mastra_workspace_` or
+* matches the post-remap mastracode tool names. Non-workspace tools (memory,
+* notification inbox, subagent, etc.) and skill-loader / preflight /
+* materializer `sandbox.executeCommand()` calls that never flow through the
+* tool layer are intentionally excluded.
+*
+* Failed tool calls (`isError === true`) don't count. Approval-denied and
+* abort-while-parked tool completions (`denied === true`) also don't count:
+* the run-engine emits `tool_end` with `isError: false` for those paths
+* because the tool didn't fail, but it also never ran, so treating them as
+* "meaningful exec" would re-introduce the same contamination this fix is
+* removing on the message side. The listener stays subscribed until a
+* successful qualifying end, then unsubscribes. The storage write is guarded
+* (`first_meaningful_exec_at IS NULL`), so restarts, re-materialized
+* sessions, and sessions without a source-control row are no-ops.
+*/
+function observeSessionFirstExec(session, { sourceControl }) {
+	let seen = false;
+	const toolNames = /* @__PURE__ */ new Map();
+	const suspended = /* @__PURE__ */ new Set();
+	const unsubscribe = session.subscribe((event) => {
+		if (seen) return;
+		switch (event.type) {
+			case "tool_start":
+				toolNames.set(event.toolCallId, event.toolName);
+				return;
+			case "tool_suspended":
+				suspended.add(event.toolCallId);
+				return;
+			case "tool_suspension_cancelled":
+				toolNames.delete(event.toolCallId);
+				suspended.delete(event.toolCallId);
+				return;
+			case "agent_end":
+				for (const id of toolNames.keys()) if (!suspended.has(id)) toolNames.delete(id);
+				return;
+			case "tool_end": {
+				const toolName = toolNames.get(event.toolCallId);
+				toolNames.delete(event.toolCallId);
+				suspended.delete(event.toolCallId);
+				if (event.isError) return;
+				if (event.denied) return;
+				if (!isMeaningfulToolName(toolName)) return;
+				seen = true;
+				unsubscribe();
+				sourceControl.sessions.markFirstMeaningfulExec({ sessionId: session.identity.getResourceId() }).catch((error) => console.warn("[Factory first-exec capture] Unable to persist first exec time.", error));
+				return;
+			}
+		}
+	});
+	return unsubscribe;
+}
+//#endregion
+export { isMeaningfulToolName, observeSessionFirstExec };
+
+//# sourceMappingURL=first-exec-capture.js.map

package/dist/session/first-exec-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-exec-capture.js","names":[],"sources":["../../src/session/first-exec-capture.ts"],"sourcesContent":["import type { AgentControllerEvent } from '@mastra/core/agent-controller';\nimport { WORKSPACE_TOOLS_PREFIX } from '@mastra/core/workspace';\n\nimport type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';\n\nexport interface FirstExecCaptureSession {\n  readonly identity: { getResourceId(): string };\n  subscribe(listener: (event: AgentControllerEvent) => void): () => void;\n}\n\nexport interface FirstExecCaptureDependencies {\n  sourceControl: {\n    sessions: Pick<SourceControlStorageHandle['sessions'], 'markFirstMeaningfulExec'>;\n  };\n}\n\n/**\n * Tool names that count as \"meaningful exec\" independent of the workspace\n * prefix. The workspace tools get remapped from `mastra_workspace_*` to\n * mastracode-friendly names (see `mastracode/sdk/src/tool-names.ts`), and\n * this listener runs on the emitted tool name after remap, so both spellings\n * need to match.\n */\nconst MEANINGFUL_TOOL_NAMES: ReadonlySet<string> = new Set([\n  // Filesystem (post-remap)\n  'view',\n  'write_file',\n  'string_replace_lsp',\n  'find_files',\n  'delete_file',\n  'file_stat',\n  'mkdir',\n  // Search\n  'search_content',\n  // Code intelligence\n  'ast_smart_edit',\n  'lsp_inspect',\n  // Sandbox\n  'execute_command',\n  'get_process_output',\n  'kill_process',\n]);\n\nexport function isMeaningfulToolName(name: string | undefined): boolean {\n  if (!name) return false;\n  if (name.startsWith(`${WORKSPACE_TOOLS_PREFIX}_`)) return true;\n  return MEANINGFUL_TOOL_NAMES.has(name);\n}\n\n/**\n * Record when a session's agent completed its first successful meaningful\n * tool call (the TTFME anchor — \"time to first meaningful exec\").\n *\n * Meaningful = a workspace tool the agent invoked itself (filesystem,\n * search, code intelligence, sandbox exec, process control). We accept any\n * tool whose name starts with the workspace prefix `mastra_workspace_` or\n * matches the post-remap mastracode tool names. Non-workspace tools (memory,\n * notification inbox, subagent, etc.) and skill-loader / preflight /\n * materializer `sandbox.executeCommand()` calls that never flow through the\n * tool layer are intentionally excluded.\n *\n * Failed tool calls (`isError === true`) don't count. Approval-denied and\n * abort-while-parked tool completions (`denied === true`) also don't count:\n * the run-engine emits `tool_end` with `isError: false` for those paths\n * because the tool didn't fail, but it also never ran, so treating them as\n * \"meaningful exec\" would re-introduce the same contamination this fix is\n * removing on the message side. The listener stays subscribed until a\n * successful qualifying end, then unsubscribes. The storage write is guarded\n * (`first_meaningful_exec_at IS NULL`), so restarts, re-materialized\n * sessions, and sessions without a source-control row are no-ops.\n */\nexport function observeSessionFirstExec(\n  session: FirstExecCaptureSession,\n  { sourceControl }: FirstExecCaptureDependencies,\n): () => void {\n  let seen = false;\n  // toolCallId -> toolName. Populated on `tool_start`, consumed on `tool_end`.\n  // Suspended entries survive `agent_end` so the resumed run can still resolve\n  // its tool name when the eventual `tool_end` arrives.\n  const toolNames = new Map<string, string>();\n  const suspended = new Set<string>();\n  const unsubscribe = session.subscribe(event => {\n    if (seen) return;\n    switch (event.type) {\n      case 'tool_start': {\n        toolNames.set(event.toolCallId, event.toolName);\n        return;\n      }\n      case 'tool_suspended': {\n        suspended.add(event.toolCallId);\n        return;\n      }\n      case 'tool_suspension_cancelled': {\n        toolNames.delete(event.toolCallId);\n        suspended.delete(event.toolCallId);\n        return;\n      }\n      case 'agent_end': {\n        // Drop any in-flight starts that will never see a matching `tool_end`\n        // on this run. Genuinely suspended calls stay so their eventual\n        // resume-time `tool_end` can still map back to a tool name. Without\n        // this, sessions that repeatedly abort or error before a qualifying\n        // completion would accumulate stale entries for the entire lifetime\n        // of the subscription.\n        for (const id of toolNames.keys()) {\n          if (!suspended.has(id)) toolNames.delete(id);\n        }\n        return;\n      }\n      case 'tool_end': {\n        const toolName = toolNames.get(event.toolCallId);\n        toolNames.delete(event.toolCallId);\n        suspended.delete(event.toolCallId);\n        if (event.isError) return;\n        if (event.denied) return;\n        if (!isMeaningfulToolName(toolName)) return;\n        seen = true;\n        unsubscribe();\n        void sourceControl.sessions\n          .markFirstMeaningfulExec({ sessionId: session.identity.getResourceId() })\n          .catch(error => console.warn('[Factory first-exec capture] Unable to persist first exec time.', error));\n        return;\n      }\n    }\n  });\n  return unsubscribe;\n}\n"],"mappings":";;;;;;;;;AAuBA,MAAM,wCAA6C,IAAI,IAAI;CAEzD;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CAEA;CACA;CAEA;CACA;CACA;AACF,CAAC;AAED,SAAgB,qBAAqB,MAAmC;CACtE,IAAI,CAAC,MAAM,OAAO;CAClB,IAAI,KAAK,WAAW,GAAG,uBAAuB,EAAE,GAAG,OAAO;CAC1D,OAAO,sBAAsB,IAAI,IAAI;AACvC;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,wBACd,SACA,EAAE,iBACU;CACZ,IAAI,OAAO;CAIX,MAAM,4BAAY,IAAI,IAAoB;CAC1C,MAAM,4BAAY,IAAI,IAAY;CAClC,MAAM,cAAc,QAAQ,WAAU,UAAS;EAC7C,IAAI,MAAM;EACV,QAAQ,MAAM,MAAd;GACE,KAAK;IACH,UAAU,IAAI,MAAM,YAAY,MAAM,QAAQ;IAC9C;GAEF,KAAK;IACH,UAAU,IAAI,MAAM,UAAU;IAC9B;GAEF,KAAK;IACH,UAAU,OAAO,MAAM,UAAU;IACjC,UAAU,OAAO,MAAM,UAAU;IACjC;GAEF,KAAK;IAOH,KAAK,MAAM,MAAM,UAAU,KAAK,GAC9B,IAAI,CAAC,UAAU,IAAI,EAAE,GAAG,UAAU,OAAO,EAAE;IAE7C;GAEF,KAAK,YAAY;IACf,MAAM,WAAW,UAAU,IAAI,MAAM,UAAU;IAC/C,UAAU,OAAO,MAAM,UAAU;IACjC,UAAU,OAAO,MAAM,UAAU;IACjC,IAAI,MAAM,SAAS;IACnB,IAAI,MAAM,QAAQ;IAClB,IAAI,CAAC,qBAAqB,QAAQ,GAAG;IACrC,OAAO;IACP,YAAY;IACZ,cAAmB,SAChB,wBAAwB,EAAE,WAAW,QAAQ,SAAS,cAAc,EAAE,CAAC,CAAC,CACxE,OAAM,UAAS,QAAQ,KAAK,mEAAmE,KAAK,CAAC;IACxG;GACF;EACF;CACF,CAAC;CACD,OAAO;AACT"}

package/dist/session/first-message-capture.d.ts

@@ -0,0 +1,33 @@
+import type { AgentControllerEvent } from '@mastra/core/agent-controller';
+import type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';
+export interface FirstMessageCaptureSession {
+    readonly identity: {
+        getResourceId(): string;
+    };
+    subscribe(listener: (event: AgentControllerEvent) => void): () => void;
+}
+export interface FirstMessageCaptureDependencies {
+    sourceControl: {
+        sessions: Pick<SourceControlStorageHandle['sessions'], 'markFirstMessage'>;
+    };
+}
+/**
+ * Record when a session's agent first produced an actual conversational
+ * message (the TTFI anchor — "time to first interaction").
+ *
+ * We stamp on the first `message_start` whose role is `user` or `assistant`.
+ * The coordinator writes `role='signal'` rows into the thread (skill loads,
+ * phase markers, memory reminders) before the model is ever invoked; those
+ * signals used to trigger a stamp via `agent_start`, giving every session —
+ * including zero-message model-init failures — a false TTFI of a few seconds.
+ * Gating on real conversational roles keeps the TTFI column honest: sessions
+ * that never produced a user or assistant message stay NULL and drop out of
+ * TTFI percentiles instead of contaminating them.
+ *
+ * The listener unsubscribes after the first qualifying message; the storage
+ * write is guarded (`first_message_at IS NULL`), so restarts, re-materialized
+ * sessions, and sessions without a source-control row (chat-only channels)
+ * are no-ops.
+ */
+export declare function observeSessionFirstMessage(session: FirstMessageCaptureSession, { sourceControl }: FirstMessageCaptureDependencies): () => void;
+//# sourceMappingURL=first-message-capture.d.ts.map

package/dist/session/first-message-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-message-capture.d.ts","sourceRoot":"","sources":["../../src/session/first-message-capture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AAE5F,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE;QAAE,aAAa,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/C,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACxE;AAED,MAAM,WAAW,+BAA+B;IAC9C,aAAa,EAAE;QACb,QAAQ,EAAE,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC,CAAC;KAC5E,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,0BAA0B,EACnC,EAAE,aAAa,EAAE,EAAE,+BAA+B,GACjD,MAAM,IAAI,CAaZ"}

package/dist/session/first-message-capture.js

@@ -0,0 +1,35 @@
+//#region src/session/first-message-capture.ts
+/**
+* Record when a session's agent first produced an actual conversational
+* message (the TTFI anchor — "time to first interaction").
+*
+* We stamp on the first `message_start` whose role is `user` or `assistant`.
+* The coordinator writes `role='signal'` rows into the thread (skill loads,
+* phase markers, memory reminders) before the model is ever invoked; those
+* signals used to trigger a stamp via `agent_start`, giving every session —
+* including zero-message model-init failures — a false TTFI of a few seconds.
+* Gating on real conversational roles keeps the TTFI column honest: sessions
+* that never produced a user or assistant message stay NULL and drop out of
+* TTFI percentiles instead of contaminating them.
+*
+* The listener unsubscribes after the first qualifying message; the storage
+* write is guarded (`first_message_at IS NULL`), so restarts, re-materialized
+* sessions, and sessions without a source-control row (chat-only channels)
+* are no-ops.
+*/
+function observeSessionFirstMessage(session, { sourceControl }) {
+	let seen = false;
+	const unsubscribe = session.subscribe((event) => {
+		if (seen || event.type !== "message_start") return;
+		const role = event.message.role;
+		if (role !== "user" && role !== "assistant") return;
+		seen = true;
+		unsubscribe();
+		sourceControl.sessions.markFirstMessage({ sessionId: session.identity.getResourceId() }).catch((error) => console.warn("[Factory first-message capture] Unable to persist first message time.", error));
+	});
+	return unsubscribe;
+}
+//#endregion
+export { observeSessionFirstMessage };
+
+//# sourceMappingURL=first-message-capture.js.map

package/dist/session/first-message-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-message-capture.js","names":[],"sources":["../../src/session/first-message-capture.ts"],"sourcesContent":["import type { AgentControllerEvent } from '@mastra/core/agent-controller';\n\nimport type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';\n\nexport interface FirstMessageCaptureSession {\n  readonly identity: { getResourceId(): string };\n  subscribe(listener: (event: AgentControllerEvent) => void): () => void;\n}\n\nexport interface FirstMessageCaptureDependencies {\n  sourceControl: {\n    sessions: Pick<SourceControlStorageHandle['sessions'], 'markFirstMessage'>;\n  };\n}\n\n/**\n * Record when a session's agent first produced an actual conversational\n * message (the TTFI anchor — \"time to first interaction\").\n *\n * We stamp on the first `message_start` whose role is `user` or `assistant`.\n * The coordinator writes `role='signal'` rows into the thread (skill loads,\n * phase markers, memory reminders) before the model is ever invoked; those\n * signals used to trigger a stamp via `agent_start`, giving every session —\n * including zero-message model-init failures — a false TTFI of a few seconds.\n * Gating on real conversational roles keeps the TTFI column honest: sessions\n * that never produced a user or assistant message stay NULL and drop out of\n * TTFI percentiles instead of contaminating them.\n *\n * The listener unsubscribes after the first qualifying message; the storage\n * write is guarded (`first_message_at IS NULL`), so restarts, re-materialized\n * sessions, and sessions without a source-control row (chat-only channels)\n * are no-ops.\n */\nexport function observeSessionFirstMessage(\n  session: FirstMessageCaptureSession,\n  { sourceControl }: FirstMessageCaptureDependencies,\n): () => void {\n  let seen = false;\n  const unsubscribe = session.subscribe(event => {\n    if (seen || event.type !== 'message_start') return;\n    const role = event.message.role;\n    if (role !== 'user' && role !== 'assistant') return;\n    seen = true;\n    unsubscribe();\n    void sourceControl.sessions\n      .markFirstMessage({ sessionId: session.identity.getResourceId() })\n      .catch(error => console.warn('[Factory first-message capture] Unable to persist first message time.', error));\n  });\n  return unsubscribe;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,2BACd,SACA,EAAE,iBACU;CACZ,IAAI,OAAO;CACX,MAAM,cAAc,QAAQ,WAAU,UAAS;EAC7C,IAAI,QAAQ,MAAM,SAAS,iBAAiB;EAC5C,MAAM,OAAO,MAAM,QAAQ;EAC3B,IAAI,SAAS,UAAU,SAAS,aAAa;EAC7C,OAAO;EACP,YAAY;EACZ,cAAmB,SAChB,iBAAiB,EAAE,WAAW,QAAQ,SAAS,cAAc,EAAE,CAAC,CAAC,CACjE,OAAM,UAAS,QAAQ,KAAK,yEAAyE,KAAK,CAAC;CAChH,CAAC;CACD,OAAO;AACT"}

package/dist/session/live-sessions.d.ts

@@ -0,0 +1,63 @@
+import type { AgentControllerEvent } from '@mastra/core/agent-controller';
+/** The slice of a live session this registry needs: its id, its run, its parked tools, and who it works for. */
+export interface LiveSession {
+    readonly identity: {
+        getId(): string;
+    };
+    readonly run: {
+        isRunning(): boolean;
+    };
+    readonly state: {
+        get(): Readonly<{
+            factoryOrgId?: string;
+            factoryProjectId?: string;
+        }>;
+    };
+    readonly displayState: {
+        get(): {
+            pendingSuspensions: ReadonlyMap<string, {
+                toolName: string;
+            }>;
+        };
+    };
+    subscribe(listener: (event: AgentControllerEvent) => void): () => void;
+}
+interface SessionNotifier {
+    onSessionCreated(listener: (session: LiveSession) => void): () => void;
+    onSessionDeleted(listener: (session: LiveSession) => void): () => void;
+}
+/** The tool a session has waited on longest, and since when (epoch ms). */
+export interface ParkedRun {
+    toolName: string;
+    suspendedAt: number;
+}
+/**
+ * The sessions this process has materialized, by session id.
+ *
+ * Membership comes from the controller's notifications rather than
+ * `getSessionByResource`, which hands back the pending creation — awaiting it
+ * from a request blocks for as long as the session takes to materialize its
+ * sandbox, minutes on a cold clone. Notifications only fire once a session
+ * exists, so a read never waits.
+ *
+ * Whether a session is *running* or *parked* is read from the session itself,
+ * never tracked here: no missed run event can leave the answer stuck. Only the
+ * moment each suspension arrived is kept, since the session does not date them.
+ */
+export declare class LiveSessions {
+    #private;
+    constructor(controller: SessionNotifier);
+    /** Whether the session has an agent run in flight right now. */
+    isRunning(sessionId: string): boolean;
+    /** The tool the session is parked on, oldest first, or nothing when no answer is owed. */
+    parked(sessionId: string): ParkedRun | undefined;
+    /** Every parked session of a project, so the inbox reads no card when nothing waits. */
+    parkedIn(factoryProjectId: string): Array<{
+        sessionId: string;
+        run: ParkedRun;
+    }>;
+    /** Fires when a session parks, is answered, or finishes a turn: whoever shows parked runs re-reads. */
+    onParkedChanged(listener: (session: LiveSession) => void): () => void;
+}
+export {};
+//# sourceMappingURL=live-sessions.d.ts.map

package/dist/session/live-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-sessions.d.ts","sourceRoot":"","sources":["../../src/session/live-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,gHAAgH;AAChH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE;QAAE,KAAK,IAAI,MAAM,CAAA;KAAE,CAAC;IACvC,QAAQ,CAAC,GAAG,EAAE;QAAE,SAAS,IAAI,OAAO,CAAA;KAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE;QAAE,GAAG,IAAI,QAAQ,CAAC;YAAE,YAAY,CAAC,EAAE,MAAM,CAAC;YAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC;IAC1F,QAAQ,CAAC,YAAY,EAAE;QAAE,GAAG,IAAI;YAAE,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE;gBAAE,QAAQ,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,CAAA;KAAE,CAAC;IACpG,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACxE;AAED,UAAU,eAAe;IACvB,gBAAgB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACvE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACxE;AAED,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AASD;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAY;;gBAMX,UAAU,EAAE,eAAe;IA4BvC,gEAAgE;IAChE,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIrC,0FAA0F;IAC1F,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAWhD,wFAAwF;IACxF,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,SAAS,CAAA;KAAE,CAAC;IAUhF,uGAAuG;IACvG,eAAe,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI;CAItE"}