letagents 0.12.12 → 0.12.14

package/dist/mcp/git-remote.js

@@ -82,13 +82,13 @@ function githubRepositoryFullNameFromRoom(repoRoom) {
 function isLikelyDefaultBranchName(branchName) {
     return branchName === "main" || branchName === "master" || branchName === "trunk";
 }
-export function buildGitRefRoomIdentity(input) {
+export function buildGitRefRoomLocator(input) {
     const repositoryFullName = githubRepositoryFullNameFromRoom(input.repoRoom);
     const refName = input.refName.trim();
     if (!repositoryFullName || !refName) {
         return null;
     }
-    return `git-room:github.com:${repositoryFullName.toLowerCase()}:${input.refType}:${encodeRefForRoomId(refName)}`;
+    return `github.com/${repositoryFullName.toLowerCase()}/focus/git:${input.refType}:${encodeRefForRoomId(refName)}`;
 }
 export function getGitCurrentBranch(cwd) {
     return execGit(["branch", "--show-current"], cwd);
@@ -107,8 +107,8 @@ export function buildActiveGitRoomContext(input) {
         && (defaultBranch
             ? currentBranch !== defaultBranch
             : !isLikelyDefaultBranchName(currentBranch)));
-    const activeRefRoom = input.repoRoom && currentBranch && shouldUseBranchRoom
-        ? buildGitRefRoomIdentity({
+    const activeRefRoomLocator = input.repoRoom && currentBranch && shouldUseBranchRoom
+        ? buildGitRefRoomLocator({
             repoRoom: input.repoRoom,
             refType: "branch",
             refName: currentBranch,
@@ -118,9 +118,9 @@ export function buildActiveGitRoomContext(input) {
         repoRoom: input.repoRoom,
         currentBranch,
         defaultBranch,
-        activeRefRoom,
-        activeRoom: activeRefRoom ?? input.repoRoom,
-        activeRoomKind: activeRefRoom ? "branch" : input.repoRoom ? "repo" : null,
+        activeRefRoomLocator,
+        activeRoomLocator: activeRefRoomLocator ?? input.repoRoom,
+        activeRoomKind: activeRefRoomLocator ? "branch" : input.repoRoom ? "repo" : null,
     };
 }
 export function getGitRoomContext(cwd) {

package/dist/mcp/local-state/agent-sessions.js

@@ -1,4 +1,4 @@
-import { readLocalState, updateLocalState } from "./storage.js";
+import { readLocalState, readLocalStateSnapshot, updateLocalState } from "./storage.js";
 export function getStoredAgentSession(sessionId) {
     if (!sessionId) {
         return null;
@@ -7,15 +7,22 @@ export function getStoredAgentSession(sessionId) {
     return state.agent_sessions?.[sessionId] ?? null;
 }
 export function getCurrentAgentSession(roomId) {
-    const state = readLocalState();
+    return getCurrentAgentSessionSnapshot(roomId).session;
+}
+export function getCurrentAgentSessionSnapshot(roomId) {
+    const snapshot = readLocalStateSnapshot();
+    const state = snapshot.state;
     const sessionIds = state.current_agent_session_ids;
     if (!sessionIds) {
-        return null;
+        return { session: null, complete: snapshot.complete };
     }
     if (roomId) {
         const sessionId = sessionIds[roomId];
         const session = sessionId ? (state.agent_sessions?.[sessionId] ?? null) : null;
-        return session && !session.ended_at ? session : null;
+        return {
+            session: session && !session.ended_at ? session : null,
+            complete: snapshot.complete,
+        };
     }
     let best = null;
     for (const id of Object.values(sessionIds)) {
@@ -24,7 +31,7 @@ export function getCurrentAgentSession(roomId) {
             best = session;
         }
     }
-    return best;
+    return { session: best, complete: snapshot.complete };
 }
 /**
  * Every stored session (active or ended) this identity had in the room,
@@ -41,6 +48,27 @@ export function getStoredAgentSessionsForRoomIdentity(roomId, agentKey) {
         .filter((session) => session.room_id === roomId && session.agent_key === agentKey)
         .sort((left, right) => right.updated_at.localeCompare(left.updated_at));
 }
+/** Complete active local worker population for global routing ambiguity. */
+export function getStoredActiveAgentSessionsForRoom(roomId) {
+    return getStoredAgentRoutingStateSnapshot(roomId).sessions;
+}
+export function getStoredAgentRoutingStateSnapshot(roomId) {
+    if (!roomId)
+        return { sessions: [], complete: true, accountReaderKey: null };
+    const snapshot = readLocalStateSnapshot();
+    const sessions = Object.values(snapshot.state.agent_sessions ?? {})
+        .filter((session) => session.room_id === roomId
+        && session.session_kind === "worker"
+        && !session.ended_at)
+        .sort((left, right) => left.created_at.localeCompare(right.created_at)
+        || left.session_id.localeCompare(right.session_id));
+    const accountId = snapshot.state.auth?.account?.id?.trim() || "";
+    return {
+        sessions,
+        complete: snapshot.complete,
+        accountReaderKey: accountId ? `account:${accountId}` : null,
+    };
+}
 export function saveAgentSession(session, makeCurrent = true) {
     updateLocalState((state) => {
         state.agent_sessions = state.agent_sessions ?? {};
@@ -53,6 +81,36 @@ export function saveAgentSession(session, makeCurrent = true) {
     });
     return session;
 }
+/**
+ * Local MCP rooms have one process-owned generation per durable worker key.
+ * Replace it atomically so a crashed/restarted process cannot remain the
+ * permanent oldest routing representative.
+ */
+export function replaceLocalWorkerAgentSession(session) {
+    updateLocalState((state) => {
+        const endedAt = session.created_at;
+        state.agent_sessions = state.agent_sessions ?? {};
+        for (const [sessionId, existing] of Object.entries(state.agent_sessions)) {
+            if (sessionId !== session.session_id
+                && existing.room_id === session.room_id
+                && existing.session_kind === "worker"
+                && existing.agent_key === session.agent_key
+                && !existing.ended_at) {
+                state.agent_sessions[sessionId] = {
+                    ...existing,
+                    ended_at: endedAt,
+                    updated_at: endedAt,
+                    last_seen_at: endedAt,
+                };
+            }
+        }
+        state.agent_sessions[session.session_id] = session;
+        state.current_agent_session_ids = state.current_agent_session_ids ?? {};
+        state.current_agent_session_ids[session.room_id] = session.session_id;
+        return state;
+    });
+    return session;
+}
 export function endStoredAgentSession(sessionId, endedAt = new Date().toISOString()) {
     let endedSession = null;
     updateLocalState((state) => {

package/dist/mcp/local-state/local-chat.js

@@ -2,12 +2,27 @@ import { createRequire } from "node:module";
 import { mkdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { ensureLocalThreadRoutingProjectionSchemaAsync, getLocalThreadRoutingAgentKeysForRoots, projectLocalThreadRoutingMessage, runLocalSqliteWriteTransactionAsync, scheduleLocalThreadRoutingBackfill, } from "../../../shared/sqlite-thread-routing.mjs";
+import { MESSAGE_SENDER_MAX_CODE_POINTS, MESSAGE_SENDER_MAX_UTF8_BYTES, POSTGRES_INTEGER_MAX, isMessageSenderWithinBounds, parseAccountAgentRoutingEnvelope, parsePositivePgIntegerScopedId, } from "../../../shared/message-contracts.mjs";
+const localImportedRoutingAuthority = Symbol("localImportedRoutingAuthority");
+export function getLocalImportedRoutingAuthority(message) {
+    if (!message || typeof message !== "object")
+        return null;
+    return message[localImportedRoutingAuthority] ?? null;
+}
 const require = createRequire(import.meta.url);
 const chatStorageSettingsPath = process.env.LETAGENTS_CHAT_STORAGE_SETTINGS_PATH?.trim() ||
     join(homedir(), ".letagents", "chat-storage.json");
 const localChatDatabasePath = process.env.LETAGENTS_LOCAL_CHAT_DB?.trim() ||
     join(homedir(), ".letagents", "local-chat.sqlite");
 let db = null;
+let dbInitialization = null;
+let databaseInitializationObserverForTest = null;
+let schemaInitializationObserverForTest = null;
+export function setLocalChatInitializationObserversForTest(observers) {
+    databaseInitializationObserverForTest = observers?.database ?? null;
+    schemaInitializationObserverForTest = observers?.schema ?? null;
+}
 const validLocalTaskTransitions = {
     proposed: ["accepted", "cancelled"],
     accepted: ["assigned", "cancelled"],
@@ -23,13 +38,7 @@ function formatMessageId(number) {
     return `msg_${number}`;
 }
 function parseMessageNumber(messageId) {
-    if (!messageId)
-        return null;
-    const match = /^msg_(\d+)$/.exec(messageId.trim());
-    if (!match)
-        return null;
-    const parsed = Number(match[1]);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+    return parsePositivePgIntegerScopedId(messageId, "msg");
 }
 function clampLimit(limit) {
     if (!Number.isFinite(limit))
@@ -50,6 +59,20 @@ function mapRow(row) {
         text: String(row.text || ""),
         agent_prompt_kind: typeof row.agent_prompt_kind === "string" ? row.agent_prompt_kind : null,
         source: typeof row.source === "string" ? row.source : null,
+        publisher_agent_key: typeof row.publisher_agent_key === "string" ? row.publisher_agent_key : null,
+        publisher_agent_session_id: typeof row.publisher_agent_session_id === "string"
+            ? row.publisher_agent_session_id
+            : null,
+        account_agent_routing_json: typeof row.account_agent_routing_json === "string"
+            ? row.account_agent_routing_json
+            : null,
+        account_agent_routing_reader_key: typeof row.account_agent_routing_reader_key === "string"
+            ? row.account_agent_routing_reader_key
+            : null,
+        control_authorized: row.control_authorized === null || row.control_authorized === undefined
+            ? null
+            : Number(row.control_authorized),
+        synced_cloud_id: typeof row.synced_cloud_id === "string" ? row.synced_cloud_id : null,
         timestamp: String(row.timestamp || ""),
         sync_key: typeof row.sync_key === "string" ? row.sync_key : null,
         sync_started_at: typeof row.sync_started_at === "string" ? row.sync_started_at : null,
@@ -80,9 +103,19 @@ function visibleMessageClause(includePromptOnly) {
         ? "1 = 1"
         : "(agent_prompt_kind IS NULL OR agent_prompt_kind <> 'auto' OR TRIM(text) <> '')";
 }
+export async function ensureLocalThreadRoutingProjection(database) {
+    await ensureLocalThreadRoutingProjectionSchemaAsync(database);
+}
 function toMessage(row, replyTo, attachments = []) {
-    return {
+    const message = {
         id: formatMessageId(row.number),
+        agent_identity: row.publisher_agent_key
+            ? {
+                actor_label: row.sender,
+                agent_key: row.publisher_agent_key,
+                agent_session_id: row.publisher_agent_session_id,
+            }
+            : null,
         sender: row.sender,
         text: row.text,
         agent_prompt_kind: row.agent_prompt_kind,
@@ -110,17 +143,39 @@ function toMessage(row, replyTo, attachments = []) {
             }
             : null,
     };
+    const importedCloudProvenance = Boolean(row.synced_cloud_id && !row.sync_key);
+    if (row.account_agent_routing_json || importedCloudProvenance) {
+        let routing = { version: 1, authority: "invalid" };
+        if (row.account_agent_routing_json) {
+            try {
+                routing = parseAccountAgentRoutingEnvelope(JSON.parse(row.account_agent_routing_json)) ?? { version: 1, authority: "invalid" };
+            }
+            catch {
+                // Present malformed imported authority is explicit invalid authority.
+            }
+        }
+        Object.defineProperty(message, localImportedRoutingAuthority, {
+            value: {
+                routing,
+                readerKey: row.account_agent_routing_reader_key,
+            },
+            enumerable: false,
+        });
+    }
+    return message;
 }
-async function getDb() {
-    if (db)
-        return db;
+async function initializeDb() {
     await mkdir(dirname(localChatDatabasePath), { recursive: true });
     const { DatabaseSync } = require("node:sqlite");
-    db = new DatabaseSync(localChatDatabasePath);
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
-    db.exec("PRAGMA busy_timeout = 5000");
-    db.exec(`
+    databaseInitializationObserverForTest?.();
+    const database = new DatabaseSync(localChatDatabasePath);
+    try {
+        schemaInitializationObserverForTest?.();
+        database.exec("PRAGMA journal_mode = WAL");
+        database.exec("PRAGMA foreign_keys = ON");
+        database.exec("PRAGMA busy_timeout = 5000");
+        await runLocalSqliteWriteTransactionAsync(database, () => {
+            database.exec(`
     CREATE TABLE IF NOT EXISTS local_chat_room_sequences (
       room_id TEXT PRIMARY KEY,
       next_number INTEGER NOT NULL
@@ -134,6 +189,11 @@ async function getDb() {
       text TEXT NOT NULL,
       agent_prompt_kind TEXT,
       source TEXT,
+      publisher_agent_key TEXT,
+      publisher_agent_session_id TEXT,
+      account_agent_routing_json TEXT,
+      account_agent_routing_reader_key TEXT,
+      control_authorized INTEGER,
       timestamp TEXT NOT NULL,
       synced_cloud_id TEXT,
       synced_at TEXT,
@@ -203,23 +263,28 @@ async function getDb() {
       PRIMARY KEY (room_id, task_id)
     );
   `);
-    addColumnIfMissing(db, "local_chat_messages", "sync_key", "TEXT");
-    addColumnIfMissing(db, "local_chat_messages", "sync_started_at", "TEXT");
-    addColumnIfMissing(db, "local_chat_messages", "thread_root_number", "INTEGER");
-    addColumnIfMissing(db, "local_rooms", "pinned_at", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "assignee_agent_key", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "assignee_agent_instance_id", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "assignee_agent_session_id", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "workflow_artifacts_json", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "workflow_refs_json", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "sync_started_at", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "sync_dirty", "INTEGER NOT NULL DEFAULT 0");
-    addColumnIfMissing(db, "local_tasks", "review_lease_id", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "review_holder_label", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "review_agent_key", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "review_agent_session_id", "TEXT");
-    addColumnIfMissing(db, "local_tasks", "review_updated_at", "TEXT");
-    db.exec(`
+            addColumnIfMissing(database, "local_chat_messages", "sync_key", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "sync_started_at", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "thread_root_number", "INTEGER");
+            addColumnIfMissing(database, "local_chat_messages", "publisher_agent_key", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "publisher_agent_session_id", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "account_agent_routing_json", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "account_agent_routing_reader_key", "TEXT");
+            addColumnIfMissing(database, "local_chat_messages", "control_authorized", "INTEGER");
+            addColumnIfMissing(database, "local_rooms", "pinned_at", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "assignee_agent_key", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "assignee_agent_instance_id", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "assignee_agent_session_id", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "workflow_artifacts_json", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "workflow_refs_json", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "sync_started_at", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "sync_dirty", "INTEGER NOT NULL DEFAULT 0");
+            addColumnIfMissing(database, "local_tasks", "review_lease_id", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "review_holder_label", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "review_agent_key", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "review_agent_session_id", "TEXT");
+            addColumnIfMissing(database, "local_tasks", "review_updated_at", "TEXT");
+            database.exec(`
     CREATE UNIQUE INDEX IF NOT EXISTS local_chat_messages_sync_key_idx
       ON local_chat_messages (room_id, sync_key)
       WHERE sync_key IS NOT NULL;
@@ -227,8 +292,29 @@ async function getDb() {
       ON local_chat_messages (room_id, sync_started_at);
     CREATE INDEX IF NOT EXISTS local_chat_messages_thread_root_idx
       ON local_chat_messages (room_id, thread_root_number);
-  `);
-    return db;
+      `);
+        });
+        await ensureLocalThreadRoutingProjection(database);
+        scheduleLocalThreadRoutingBackfill(database);
+        return database;
+    }
+    catch (error) {
+        database.close?.();
+        throw error;
+    }
+}
+async function getDb() {
+    if (db)
+        return db;
+    dbInitialization ??= initializeDb();
+    try {
+        const initialized = await dbInitialization;
+        db = initialized;
+        return initialized;
+    }
+    finally {
+        dbInitialization = null;
+    }
 }
 function addColumnIfMissing(database, tableName, columnName, definition) {
     try {
@@ -306,7 +392,7 @@ function allocateLocalMessageNumber(database, roomId) {
         .prepare("SELECT next_number FROM local_chat_room_sequences WHERE room_id = ?")
         .get(roomId);
     const number = Number(row?.next_number || 0);
-    if (!Number.isInteger(number) || number <= 0) {
+    if (!Number.isInteger(number) || number <= 0 || number > POSTGRES_INTEGER_MAX) {
         throw new Error("Local chat message sequence could not be allocated.");
     }
     database
@@ -418,6 +504,9 @@ export async function addLocalChatMessage(roomId, input) {
         throw new Error("No room is available for this request.");
     if (!sender)
         throw new Error("Message sender is required.");
+    if (!isMessageSenderWithinBounds(sender)) {
+        throw new Error(`Message sender must not exceed ${MESSAGE_SENDER_MAX_CODE_POINTS} characters or ${MESSAGE_SENDER_MAX_UTF8_BYTES} UTF-8 bytes.`);
+    }
     const database = await getDb();
     const replyToNumber = parseMessageNumber(input.reply_to);
     const explicitThreadRootNumber = parseMessageNumber(input.thread_root_id);
@@ -448,11 +537,9 @@ export async function addLocalChatMessage(roomId, input) {
         }
     }
     const timestamp = new Date().toISOString();
-    let row;
-    beginImmediate(database);
-    try {
+    const row = await runLocalSqliteWriteTransactionAsync(database, () => {
         const number = allocateLocalMessageNumber(database, trimmedRoomId);
-        row = {
+        const insertedRow = {
             room_id: trimmedRoomId,
             number,
             reply_to_number: replyToNumber,
@@ -461,6 +548,12 @@ export async function addLocalChatMessage(roomId, input) {
             text: input.text,
             agent_prompt_kind: input.agent_prompt_kind || null,
             source: input.source || null,
+            publisher_agent_key: input.publisher_agent_key?.trim() || null,
+            publisher_agent_session_id: input.publisher_agent_session_id?.trim() || null,
+            account_agent_routing_json: null,
+            account_agent_routing_reader_key: null,
+            control_authorized: null,
+            synced_cloud_id: null,
             timestamp,
             sync_key: null,
             sync_started_at: null,
@@ -469,22 +562,32 @@ export async function addLocalChatMessage(roomId, input) {
             .prepare(`
         INSERT INTO local_chat_messages (
           room_id, number, reply_to_number, thread_root_number, sender, text, agent_prompt_kind, source,
+          publisher_agent_key, publisher_agent_session_id,
           timestamp, synced_cloud_id, synced_at, sync_key, sync_started_at
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL)
       `)
-            .run(row.room_id, row.number, row.reply_to_number, row.thread_root_number, row.sender, row.text, row.agent_prompt_kind, row.source, row.timestamp);
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollback(database);
-        throw error;
-    }
+            .run(insertedRow.room_id, insertedRow.number, insertedRow.reply_to_number, insertedRow.thread_root_number, insertedRow.sender, insertedRow.text, insertedRow.agent_prompt_kind, insertedRow.source, insertedRow.publisher_agent_key, insertedRow.publisher_agent_session_id, insertedRow.timestamp);
+        projectLocalThreadRoutingMessage(database, insertedRow);
+        return insertedRow;
+    });
     return {
         room_id: trimmedRoomId,
         ...toMessage(row, replyTarget),
     };
 }
+export async function getLocalChatThreadRoutingMembership(roomId, rootMessageIds, identity, activeIdentities = [identity]) {
+    const rootNumbers = Array.from(new Set(rootMessageIds
+        .map((rootId) => parseMessageNumber(rootId))
+        .filter((value) => value !== null)));
+    if (rootNumbers.length === 0)
+        return new Set();
+    const database = await getDb();
+    const keysByRoot = await getLocalThreadRoutingAgentKeysForRoots(database, roomId, rootNumbers, activeIdentities);
+    return new Set([...keysByRoot]
+        .filter(([, keys]) => keys.has(identity.agent_key))
+        .map(([rootNumber]) => formatMessageId(rootNumber)));
+}
 export async function getLocalChatMessages(roomId, options) {
     const limit = clampLimit(options?.limit);
     const afterNumber = parseMessageNumber(options?.after);
@@ -675,6 +778,44 @@ export async function listLocalTasks(roomId, options = {}) {
         .map(mapTaskRow);
     return { tasks, has_more: false };
 }
+export async function listLocalActiveTaskOwnerLeases(roomId) {
+    const database = await getDb();
+    const rows = database
+        .prepare(`
+      SELECT
+        MIN(COALESCE(NULLIF(TRIM(assignee), ''), assignee_agent_key)) AS actor_label,
+        assignee_agent_key,
+        assignee_agent_instance_id,
+        assignee_agent_session_id
+      FROM local_tasks
+      WHERE room_id = ?
+        AND status IN ('assigned', 'in_progress', 'blocked', 'in_review')
+        AND assignee_agent_key IS NOT NULL
+        AND TRIM(assignee_agent_key) <> ''
+      GROUP BY CASE
+        WHEN NULLIF(TRIM(assignee_agent_session_id), '') IS NOT NULL
+          THEN 'session:' || TRIM(assignee_agent_session_id)
+        WHEN NULLIF(TRIM(assignee_agent_instance_id), '') IS NOT NULL
+          THEN 'instance:' || TRIM(assignee_agent_key) || ':' || TRIM(assignee_agent_instance_id)
+        ELSE 'agent:' || TRIM(assignee_agent_key)
+      END
+      ORDER BY MIN(created_at) ASC
+      LIMIT 2
+    `)
+        .all(roomId);
+    return rows.map((row) => ({
+        kind: "work",
+        status: "active",
+        actor_label: String(row.actor_label || row.assignee_agent_key || ""),
+        agent_key: String(row.assignee_agent_key || ""),
+        agent_instance_id: typeof row.assignee_agent_instance_id === "string"
+            ? row.assignee_agent_instance_id
+            : null,
+        agent_session_id: typeof row.assignee_agent_session_id === "string"
+            ? row.assignee_agent_session_id
+            : null,
+    }));
+}
 export async function getLocalTask(roomId, taskId) {
     const database = await getDb();
     const row = database

package/dist/mcp/local-state/storage.js

@@ -1,4 +1,4 @@
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
 import { randomBytes } from "crypto";
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -10,21 +10,28 @@ const STATE_LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 export function getLocalStatePath() {
     return process.env.LETAGENTS_STATE_PATH || DEFAULT_STATE_PATH;
 }
-function readLocalStateFromPath(statePath) {
-    if (!existsSync(statePath)) {
-        return {};
-    }
+function readLocalStateSnapshotFromPath(statePath) {
     try {
         const raw = readFileSync(statePath, "utf-8");
         const parsed = JSON.parse(raw);
-        return typeof parsed === "object" && parsed ? parsed : {};
+        return typeof parsed === "object" && parsed && !Array.isArray(parsed)
+            ? { state: parsed, complete: true }
+            : { state: {}, complete: false };
     }
-    catch {
-        return {};
+    catch (error) {
+        return error?.code === "ENOENT"
+            ? { state: {}, complete: true }
+            : { state: {}, complete: false };
     }
 }
+function readLocalStateFromPath(statePath) {
+    return readLocalStateSnapshotFromPath(statePath).state;
+}
+export function readLocalStateSnapshot() {
+    return readLocalStateSnapshotFromPath(getLocalStatePath());
+}
 export function readLocalState() {
-    return readLocalStateFromPath(getLocalStatePath());
+    return readLocalStateSnapshot().state;
 }
 function sleepSync(ms) {
     if (ms > 0) {

package/dist/mcp/server/daemon-tool-executor.js

@@ -0,0 +1,92 @@
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { registerTools } from "./register-tools.js";
+import { runWithDaemonToolExecutionContext, } from "./runtime/daemon-tool-context.js";
+import { runWithSupervisedRoomAuthority } from "./runtime/supervised-room-authority.js";
+import { durableCompletionResult, supervisedToolIsMutation } from "./supervised-tool-facade.js";
+const handlersByProvider = new Map();
+const SUPERVISED_PROVIDERS = new Set(["claude-code", "cursor", "codex", "open-model"]);
+const WORKSPACE_SCOPED_TOOLS = new Set(["check_repo", "check_repo_visibility", "initialize_repo"]);
+function handlersForProvider(provider) {
+    const normalizedProvider = provider.trim().toLowerCase();
+    const existing = handlersByProvider.get(normalizedProvider);
+    if (existing)
+        return existing;
+    const handlers = new Map();
+    const recorder = {
+        tool(name, ...registration) {
+            const callback = registration.at(-1);
+            if (typeof callback !== "function")
+                throw new Error(`Tool ${name} has no callback.`);
+            const schemaCandidate = registration.at(-2);
+            const inputSchema = schemaCandidate && typeof schemaCandidate === "object" && !Array.isArray(schemaCandidate)
+                ? schemaCandidate
+                : null;
+            handlers.set(name, { callback: callback, inputSchema });
+            return {};
+        },
+    };
+    registerTools(recorder, "supervised_room_turn", normalizedProvider || null, { executionOwner: "daemon" });
+    handlersByProvider.set(normalizedProvider, handlers);
+    return handlers;
+}
+function validateExecutionContext(input) {
+    const provider = input.provider.trim().toLowerCase();
+    const roomId = input.roomId.trim();
+    const toolName = input.toolName.trim();
+    const requestId = input.requestId.trim();
+    if (!SUPERVISED_PROVIDERS.has(provider))
+        throw new Error(`Unsupported supervised provider: ${input.provider}`);
+    if (!roomId || roomId.length > 1_024 || /[\u0000-\u001f\u007f]/.test(roomId)) {
+        throw new Error("Daemon tool room authority is malformed.");
+    }
+    if (input.agentSession.room_id !== roomId || input.agentSession.session_kind !== "worker"
+        || input.agentSession.runtime.trim().toLowerCase() !== provider || input.agentSession.ended_at) {
+        throw new Error("Daemon tool worker session does not match its active room authority.");
+    }
+    if (!input.bearer.trim())
+        throw new Error("Daemon tool worker bearer is required.");
+    if (!isAbsolute(input.cwd))
+        throw new Error("Daemon tool workspace must be an absolute path.");
+    if (!toolName || !requestId)
+        throw new Error("Daemon tool name and request id are required.");
+    let apiUrl;
+    try {
+        apiUrl = new URL(input.apiUrl);
+    }
+    catch {
+        throw new Error("Daemon tool API URL is malformed.");
+    }
+    const loopbackHosts = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+    if (apiUrl.username || apiUrl.password
+        || (apiUrl.protocol !== "https:"
+            && !(apiUrl.protocol === "http:" && loopbackHosts.has(apiUrl.hostname.toLowerCase())))) {
+        throw new Error("Daemon tool API URL must use HTTPS or an exact HTTP loopback host.");
+    }
+    return { ...input, provider, roomId, toolName, requestId, apiUrl: apiUrl.origin };
+}
+/**
+ * Execute one already-authorized supervised tool inside daemon-owned,
+ * request-scoped authority. The daemon owns journaling around this call; this
+ * module only supplies the exact public MCP implementation from the pinned
+ * runtime, without recursively crossing the supervisor bridge.
+ */
+export async function executeDaemonTool(input) {
+    const context = validateExecutionContext(input);
+    const tool = handlersForProvider(context.provider).get(context.toolName);
+    if (!tool)
+        throw new Error(`Unsupported supervised tool: ${context.toolName}`);
+    const parsedInput = tool.inputSchema
+        ? await z.object(tool.inputSchema).parseAsync(context.input)
+        : context.input;
+    const authorizedInput = WORKSPACE_SCOPED_TOOLS.has(context.toolName)
+        && parsedInput && typeof parsedInput === "object" && !Array.isArray(parsedInput)
+        ? { ...parsedInput, cwd: context.cwd }
+        : parsedInput;
+    const liveResult = await runWithDaemonToolExecutionContext(context, () => runWithSupervisedRoomAuthority(context.roomId, () => tool.callback(authorizedInput, { requestId: context.requestId })));
+    return {
+        liveResult,
+        durableResult: durableCompletionResult(liveResult, supervisedToolIsMutation(context.toolName)),
+    };
+}
+export { supervisedToolIsMutation };

package/dist/mcp/server/register-tools.js

@@ -7,8 +7,10 @@ import { registerTaskTools } from "./tools/tasks.js";
 import { registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
 import { toolSurfaceForExecutionProfile } from "./runtime/tool-surface-policy.js";
 import { profileAwareToolServer } from "./supervised-tool-facade.js";
-export function registerTools(server, profile = "autonomous_mcp_worker", supervisedProvider = process.env.LETAGENTS_SUPERVISOR_PROVIDER?.trim() || null) {
-    const tools = profileAwareToolServer(server, profile, undefined, supervisedProvider);
+export function registerTools(server, profile = "autonomous_mcp_worker", supervisedProvider = process.env.LETAGENTS_SUPERVISOR_PROVIDER?.trim() || null, options = {}) {
+    const tools = options.executionOwner === "daemon"
+        ? server
+        : profileAwareToolServer(server, profile, undefined, supervisedProvider);
     const surface = toolSurfaceForExecutionProfile(profile);
     registerRoomJoinTools(tools);
     if (surface.agentSessionLifecycle)