office-core 0.1.0

package/.runtime-dist/scripts/home-agent-host.js

@@ -0,0 +1,1403 @@
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, readdir, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn, spawnSync } from "node:child_process";
+import { probeRunnerAvailability, resolveRunnerCommand, } from "./lib/local-runner.js";
+import { loadHostConfig, loadPersistedHostSessions, upsertHostConfig, savePersistedHostSessions, } from "./lib/host-config.js";
+export const sessions = new Map();
+let tickInFlight = false;
+export const hooks = {
+    onRoomMessage: null,
+    onSessionChange: null,
+};
+export async function buildRuntimeConfig(argOverrides) {
+    const args = argOverrides ?? parseArgs(process.argv.slice(2));
+    const hostConfig = await loadHostConfig();
+    const baseUrl = (args.baseUrl ?? hostConfig?.base_url ?? "http://127.0.0.1:8787").replace(/\/$/, "");
+    const projectId = args.project ?? hostConfig?.project_id ?? "prj_local";
+    const hostId = args.hostId ?? hostConfig?.host_id ?? sanitizeId(`${os.hostname()}-${process.pid}`);
+    const displayName = args.displayName ?? hostConfig?.display_name ?? `${os.hostname()} host`;
+    const defaultWorkdir = path.resolve(args.workdir ?? hostConfig?.workdir ?? process.cwd());
+    const pollMs = normalizePollMs(args.pollMs ?? hostConfig?.poll_ms ?? 900);
+    const token = await ensureHostToken({
+        baseUrl,
+        projectId,
+        hostId,
+        displayName,
+        token: args.token ?? process.env.LOCAL_HOST_TOKEN ?? hostConfig?.token ?? "office-host-local-token",
+        workdir: defaultWorkdir,
+        pollMs,
+    });
+    const roomCursorSeq = args.project && args.project !== hostConfig?.project_id
+        ? 0
+        : Number(args.roomCursorSeq ?? hostConfig?.room_cursor_seq ?? 0);
+    return { baseUrl, projectId, hostId, displayName, defaultWorkdir, pollMs, token, roomCursorSeq };
+}
+let _daemonInterval = null;
+export async function startDaemonLoop(runtime) {
+    await restoreSessions(runtime);
+    await safeTick(runtime);
+    _daemonInterval = setInterval(() => {
+        if (tickInFlight) {
+            return;
+        }
+        void safeTick(runtime);
+    }, runtime.pollMs);
+}
+export function stopDaemonLoop() {
+    if (_daemonInterval) {
+        clearInterval(_daemonInterval);
+        _daemonInterval = null;
+    }
+}
+const _isDirectRun = process.argv[1]?.replace(/\\/g, "/").includes("home-agent-host");
+if (_isDirectRun) {
+    void (async () => {
+        const runtime = await buildRuntimeConfig();
+        console.log(`office host online: ${runtime.hostId}`);
+        console.log(`control plane: ${runtime.baseUrl}`);
+        console.log(`project: ${runtime.projectId}`);
+        console.log(`default workdir: ${runtime.defaultWorkdir}`);
+        const hostConfig = await loadHostConfig();
+        if (hostConfig)
+            console.log("host config: loaded from persisted machine config");
+        await startDaemonLoop(runtime);
+    })().catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    });
+}
+async function ensureHostToken(input) {
+    if (String(input.token || "").startsWith("hostsession.")) {
+        return input.token;
+    }
+    return registerHostToken(input);
+}
+async function registerHostToken(input) {
+    const enrollSecret = process.env.OFFICE_HOST_ENROLL_SECRET ??
+        process.env.DOUBLE_PENETRATION_ENROLL_SECRET ??
+        process.env.LOCAL_HOST_ENROLL_SECRET ??
+        "office-host-enroll-secret";
+    const response = await fetch(`${input.baseUrl}/api/projects/${input.projectId}/local-host/register`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-enroll-secret": enrollSecret,
+        },
+        body: JSON.stringify({
+            requested_host_id: input.hostId,
+            display_name: input.displayName,
+            machine_name: os.hostname(),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Host registration failed: ${response.status} ${await response.text()}`);
+    }
+    const registration = await response.json();
+    await upsertHostConfig({
+        host_id: registration.host_id,
+        display_name: input.displayName,
+        base_url: input.baseUrl,
+        project_id: registration.project_id,
+        workdir: input.workdir,
+        token: registration.host_token,
+        poll_ms: input.pollMs,
+    });
+    return registration.host_token;
+}
+async function safeTick(runtime) {
+    try {
+        await tick(runtime);
+    }
+    catch (error) {
+        console.error("[host-loop]", error instanceof Error ? error.message : String(error));
+    }
+}
+async function tick(runtime) {
+    tickInFlight = true;
+    try {
+        await refreshSessions(runtime);
+        await processSessionReplies(runtime);
+        await heartbeat(runtime);
+        await processRoomMessages(runtime);
+        const commands = await pullCommands(runtime);
+        for (const command of commands) {
+            await handleCommand(runtime, command);
+        }
+    }
+    finally {
+        tickInFlight = false;
+    }
+}
+let cachedRunners = null;
+let cachedEnvironment = null;
+const PROBE_CACHE_TTL_MS = 30_000;
+const ENV_CACHE_TTL_MS = 10_000;
+async function heartbeat(runtime) {
+    const now = Date.now();
+    if (!cachedRunners || now - cachedRunners.ts > PROBE_CACHE_TTL_MS) {
+        const codex = probeRunnerAvailability("codex", process.env.CODEX_CMD);
+        const claude = probeRunnerAvailability("claude", process.env.CLAUDE_CMD);
+        cachedRunners = { codex: codex.available, claude: claude.available, ts: now };
+    }
+    const activeWorkdir = resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId);
+    await mkdir(activeWorkdir, { recursive: true });
+    if (!cachedEnvironment || now - cachedEnvironment.ts > ENV_CACHE_TTL_MS) {
+        cachedEnvironment = { value: collectEnvironment(activeWorkdir), ts: now };
+    }
+    const environment = cachedEnvironment.value;
+    await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/heartbeat`, {
+        host_id: runtime.hostId,
+        display_name: runtime.displayName,
+        hostname: os.hostname(),
+        platform: `${process.platform}/${process.arch}`,
+        status: "online",
+        default_workdir: activeWorkdir,
+        last_seen_at: new Date().toISOString(),
+        available_runners: {
+            codex: cachedRunners.codex,
+            claude: cachedRunners.claude,
+        },
+        environment,
+        sessions: Array.from(sessions.values())
+            .sort((left, right) => right.launched_at.localeCompare(left.launched_at))
+            .slice(0, 20),
+    });
+}
+async function processRoomMessages(runtime) {
+    const result = await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/room/pull`, {
+        host_id: runtime.hostId,
+        cursor_seq: runtime.roomCursorSeq,
+    }).catch(() => null);
+    const messages = Array.isArray(result?.messages) ? result.messages : [];
+    const settings = (result?.settings ?? { all_agents_listening: true, conductor_name: "You" });
+    const latestSeq = Number(result?.latest_seq ?? runtime.roomCursorSeq);
+    if (messages.length === 0) {
+        if (latestSeq > runtime.roomCursorSeq) {
+            runtime.roomCursorSeq = latestSeq;
+            await persistRoomCursor(runtime);
+        }
+        return;
+    }
+    const runnableSessions = Array.from(sessions.values()).filter((session) => session.status === "running");
+    const project = await getJson(runtime, `/api/projects/${runtime.projectId}`).catch(() => null);
+    for (const message of messages) {
+        hooks.onRoomMessage?.(message, runtime);
+        if (message.author_type === "system") {
+            runtime.roomCursorSeq = Math.max(runtime.roomCursorSeq, message.seq);
+            continue;
+        }
+        const targetSessions = runnableSessions.filter((session) => shouldSessionReceiveMessage(runtime, session, message, settings));
+        if (targetSessions.length === 0) {
+            console.log(`[room] seq=${message.seq} no sessions matched (runnable=${runnableSessions.length}), skipping`);
+            runtime.roomCursorSeq = Math.max(runtime.roomCursorSeq, message.seq);
+            await persistRoomCursor(runtime);
+            continue;
+        }
+        console.log(`[room] seq=${message.seq} queueing for ${targetSessions.map((s) => s.agent_id).join(", ")}`);
+        for (const session of targetSessions) {
+            await refreshSessionSummary(runtime, session, project).catch(() => undefined);
+            await enqueueRoomPrompt(runtime, session, message, messages, settings);
+        }
+        runtime.roomCursorSeq = Math.max(runtime.roomCursorSeq, message.seq);
+        await persistRoomCursor(runtime);
+    }
+}
+async function pullCommands(runtime) {
+    const result = await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/commands/pull`, {
+        host_id: runtime.hostId,
+    });
+    return Array.isArray(result?.commands) ? result.commands : [];
+}
+async function handleCommand(runtime, command) {
+    try {
+        if (command.command_type === "switch_project") {
+            const previousRuntime = { ...runtime };
+            await switchProject(runtime, command);
+            await postJson(previousRuntime, `/api/projects/${previousRuntime.projectId}/local-host/commands/complete`, {
+                host_id: previousRuntime.hostId,
+                command_id: command.command_id,
+                status: "completed",
+                note: `Switched to ${runtime.projectId}.`,
+            });
+            return;
+        }
+        if (command.command_type === "remove") {
+            const sessionId = String(command.session_id ?? "").trim();
+            if (!sessionId) {
+                throw new Error("Missing session_id for remove command");
+            }
+            const removed = await stopSession(runtime, sessionId);
+            await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/commands/complete`, {
+                host_id: runtime.hostId,
+                command_id: command.command_id,
+                status: "completed",
+                session_id: removed?.session_id ?? sessionId,
+                note: removed ? `Removed ${removed.agent_id}.` : "Session already gone.",
+            });
+            return;
+        }
+        const context = await buildSpawnContext(runtime, command);
+        const session = await spawnInteractiveSession(runtime, command, context);
+        sessions.set(session.session_id, session);
+        await persistSessions();
+        await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/commands/complete`, {
+            host_id: runtime.hostId,
+            command_id: command.command_id,
+            status: "completed",
+            session_id: session.session_id,
+            note: `Launched ${command.runner} with office task context.`,
+        });
+    }
+    catch (error) {
+        await postJson(runtime, `/api/projects/${runtime.projectId}/local-host/commands/complete`, {
+            host_id: runtime.hostId,
+            command_id: command.command_id,
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function switchProject(runtime, command) {
+    const targetProjectId = String(command.target_project_id ?? "").trim();
+    if (!targetProjectId) {
+        throw new Error("Missing target project for switch");
+    }
+    if (targetProjectId === runtime.projectId) {
+        return;
+    }
+    const previousRuntime = { ...runtime };
+    const stoppedSessions = Array.from(sessions.keys());
+    for (const sessionId of stoppedSessions) {
+        await stopSession(runtime, sessionId);
+    }
+    sessions.clear();
+    await persistSessions();
+    const previousWorkdir = resolveProjectWorkdir(previousRuntime.defaultWorkdir, previousRuntime.projectId);
+    await mkdir(previousWorkdir, { recursive: true }).catch(() => undefined);
+    await postJson(previousRuntime, `/api/projects/${previousRuntime.projectId}/local-host/heartbeat`, {
+        host_id: previousRuntime.hostId,
+        display_name: previousRuntime.displayName,
+        hostname: os.hostname(),
+        platform: `${process.platform}/${process.arch}`,
+        status: "offline",
+        default_workdir: previousWorkdir,
+        last_seen_at: new Date().toISOString(),
+        available_runners: {
+            codex: probeRunnerAvailability("codex", process.env.CODEX_CMD).available,
+            claude: probeRunnerAvailability("claude", process.env.CLAUDE_CMD).available,
+        },
+        environment: collectEnvironment(previousWorkdir),
+        sessions: [],
+    }).catch(() => undefined);
+    runtime.projectId = targetProjectId;
+    runtime.roomCursorSeq = 0;
+    runtime.token = await registerHostToken({
+        baseUrl: runtime.baseUrl,
+        projectId: runtime.projectId,
+        hostId: runtime.hostId,
+        displayName: runtime.displayName,
+        workdir: runtime.defaultWorkdir,
+        pollMs: runtime.pollMs,
+    });
+    const activeWorkdir = resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId);
+    await mkdir(activeWorkdir, { recursive: true });
+    await upsertHostConfig({
+        host_id: runtime.hostId,
+        display_name: runtime.displayName,
+        base_url: runtime.baseUrl,
+        project_id: runtime.projectId,
+        workdir: runtime.defaultWorkdir,
+        token: runtime.token,
+        room_cursor_seq: runtime.roomCursorSeq,
+        poll_ms: runtime.pollMs,
+    });
+    await heartbeat(runtime);
+}
+function shouldSessionReceiveMessage(runtime, session, message, settings) {
+    const explicitlyTargeted = Boolean(message.target_host_ids?.length || message.target_session_ids?.length || message.target_agent_ids?.length);
+    if (message.author_type !== "user" && !explicitlyTargeted) {
+        return false;
+    }
+    if (message.author_type === "agent" && message.session_id && message.session_id === session.session_id) {
+        return false;
+    }
+    if (message.target_host_ids?.length && !message.target_host_ids.includes(runtime.hostId)) {
+        return false;
+    }
+    if (message.target_session_ids?.length) {
+        return message.target_session_ids.includes(session.session_id);
+    }
+    if (message.target_agent_ids?.length) {
+        return message.target_agent_ids.includes(session.agent_id);
+    }
+    return message.author_type === "user" && settings.all_agents_listening;
+}
+async function enqueueRoomPrompt(runtime, session, message, recentMessages, settings) {
+    if (!session.inbox_dir) {
+        return;
+    }
+    const contextMessages = recentMessages
+        .filter((entry) => entry.seq < message.seq && entry.author_type !== "system")
+        .slice(-8)
+        .map((entry) => ({
+        seq: entry.seq,
+        author_type: entry.author_type,
+        author_label: entry.author_label,
+        text: entry.text,
+    }));
+    const payload = {
+        type: "room_message",
+        message_id: message.message_id,
+        seq: message.seq,
+        author_type: message.author_type,
+        author_label: message.author_label,
+        text: message.text,
+        task_id: message.task_id ?? session.task_id ?? null,
+        reply_to_seq: message.reply_to_seq ?? null,
+        settings: {
+            all_agents_listening: settings.all_agents_listening,
+            conductor_name: settings.conductor_name,
+        },
+        recent_messages: contextMessages,
+    };
+    const inboxFile = path.join(session.inbox_dir, `${String(message.seq).padStart(8, "0")}-${sanitizeId(message.message_id)}.json`);
+    await writeFile(inboxFile, JSON.stringify(payload, null, 2), "utf8");
+}
+async function processSessionReplies(runtime) {
+    for (const session of sessions.values()) {
+        if (session.status !== "running" || !session.outbox_dir) {
+            continue;
+        }
+        let files = [];
+        try {
+            files = (await readdir(session.outbox_dir))
+                .filter((name) => name.toLowerCase().endsWith(".json"))
+                .sort((left, right) => left.localeCompare(right));
+        }
+        catch {
+            continue;
+        }
+        for (const name of files) {
+            const replyPath = path.join(session.outbox_dir, name);
+            console.log(`[outbox] discovered ${replyPath}`);
+            let shouldRemove = false;
+            try {
+                const raw = await readFile(replyPath, "utf8");
+                const reply = JSON.parse(raw.replace(/^\uFEFF/, ""));
+                console.log(`[outbox] parsed ${name}: ${JSON.stringify(reply)}`);
+                await postRoomMessageUpsert(runtime, {
+                    message_id: String(reply.message_id ?? `msg_${crypto.randomUUID()}`),
+                    author_type: reply.author_type === "system" ? "system" : "agent",
+                    author_id: String(reply.author_id ?? session.agent_id),
+                    author_label: String(reply.author_label ?? session.agent_id),
+                    text: String(reply.text ?? "").trim(),
+                    task_id: reply.task_id ? String(reply.task_id) : session.task_id ?? null,
+                    host_id: runtime.hostId,
+                    session_id: session.session_id,
+                    reply_to_seq: Number.isFinite(Number(reply.reply_to_seq)) ? Number(reply.reply_to_seq) : null,
+                });
+                console.log(`[outbox] room upsert success ${name}`);
+                shouldRemove = true;
+            }
+            catch (error) {
+                console.log(`[outbox] room upsert failed ${name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                if (shouldRemove) {
+                    await unlink(replyPath).catch(() => undefined);
+                }
+            }
+        }
+    }
+}
+export async function buildSpawnContext(runtime, command) {
+    const workdir = path.resolve(command.workdir || resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId));
+    await mkdir(workdir, { recursive: true });
+    const environment = collectEnvironment(workdir);
+    const [project, task, bootstrap] = await Promise.all([
+        getJson(runtime, `/api/projects/${runtime.projectId}`).catch(() => null),
+        command.task_id ? getJson(runtime, `/api/tasks/${command.task_id}`).catch(() => null) : Promise.resolve(null),
+        bootstrapAgent(runtime, command).catch(() => null),
+    ]);
+    if (bootstrap && command.task_id && task?.snapshot) {
+        await sendSpawnedAgentStatus(runtime, command, bootstrap, task, "Spawned locally and joining the task workspace.").catch(() => undefined);
+    }
+    const onboardingText = buildOnboardingText();
+    const summaryText = buildSummaryText(runtime, command, environment, project, task, bootstrap);
+    const initialPrompt = buildInteractivePrompt(runtime, command, environment, task);
+    return {
+        environment,
+        project,
+        task,
+        bootstrap,
+        onboardingText,
+        summaryText,
+        initialPrompt,
+    };
+}
+async function bootstrapAgent(runtime, command) {
+    return postJson(runtime, "/api/agents/bootstrap", {
+        agent_id: command.agent_id,
+        display_name: command.agent_id,
+        workspace_id: "ws_local",
+        active_project_id: runtime.projectId,
+        active_task_id: command.task_id ?? null,
+    });
+}
+async function sendSpawnedAgentStatus(runtime, command, bootstrap, task, summary) {
+    if (!command.task_id || !task.snapshot) {
+        return;
+    }
+    const envelope = {
+        protocol_version: "1.0",
+        command_schema_version: 1,
+        command_id: `${command.agent_id}:status.upsert:${crypto.randomUUID()}`,
+        session_id: bootstrap.fence.session_id,
+        session_epoch: bootstrap.fence.session_epoch,
+        agent_id: command.agent_id,
+        task_id: command.task_id,
+        observed_task_version: task.snapshot.task_version,
+        bundle_seq: bootstrap.descriptor.current_manifest_seq ?? task.snapshot.manifest_seq ?? 1,
+        type: "status.upsert",
+        payload: {
+            task_summary: summary,
+            state: "active",
+        },
+        sent_at: new Date().toISOString(),
+    };
+    await postJson(runtime, "/api/agents/events", { commands: [envelope] }, bootstrap.session_token);
+}
+export async function spawnInteractiveSession(runtime, command, context) {
+    if (!command.runner) {
+        throw new Error("Missing runner for spawn command");
+    }
+    const runnerCommand = resolveRunnerCommand(command.runner, command.runner === "codex" ? process.env.CODEX_CMD : process.env.CLAUDE_CMD);
+    const session_id = `localsess_${crypto.randomUUID()}`;
+    const launched_at = new Date().toISOString();
+    const workdir = path.resolve(command.workdir || resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId));
+    const scriptDir = await mkdtemp(path.join(safeScriptTempBase(), "office-host-"));
+    const scriptPath = path.join(scriptDir, `${session_id}.ps1`);
+    const pidPath = path.join(scriptDir, `${session_id}.pid`);
+    const contextRoot = path.join(workdir, ".office-host");
+    const roomDir = path.join(contextRoot, "rooms", sanitizeId(runtime.projectId));
+    const sessionDir = path.join(contextRoot, "sessions", sanitizeId(session_id));
+    const inboxDir = path.join(sessionDir, "inbox");
+    const outboxDir = path.join(sessionDir, "outbox");
+    const onboardingPath = path.join(contextRoot, "onboarding.txt");
+    const summaryPath = path.join(roomDir, "summary.txt");
+    await mkdir(roomDir, { recursive: true });
+    await mkdir(inboxDir, { recursive: true });
+    await mkdir(outboxDir, { recursive: true });
+    await writeFile(onboardingPath, context.onboardingText, "utf8");
+    await writeFile(summaryPath, context.summaryText, "utf8");
+    const scriptBody = buildPowerShellLauncher({
+        runner: command.runner,
+        runnerCommand,
+        agentId: command.agent_id,
+        mode: command.mode ?? "attach",
+        workdir,
+        contextDir: contextRoot,
+        onboardingPath,
+        summaryPath,
+        inboxDir,
+        outboxDir,
+        pidPath,
+        prompt: context.initialPrompt,
+        projectId: runtime.projectId,
+        taskId: command.task_id ?? null,
+        effort: command.effort ?? "high",
+        hostId: runtime.hostId,
+        hostDisplayName: runtime.displayName,
+        sessionId: session_id,
+    });
+    await writeFile(scriptPath, scriptBody, "utf8");
+    const child = spawn("wt.exe", [
+        "-w",
+        "0",
+        "new-tab",
+        "--title",
+        `office :: ${command.agent_id}`,
+        "--",
+        "powershell.exe",
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-NoExit",
+        "-Command",
+        `& '${toPsSingleQuoted(scriptPath)}'`,
+    ], {
+        cwd: workdir,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    const session = {
+        session_id,
+        project_id: runtime.projectId,
+        runner: command.runner,
+        agent_id: command.agent_id,
+        mode: command.mode ?? "attach",
+        workdir,
+        status: "running",
+        launched_at,
+        task_id: command.task_id ?? null,
+        note: context.initialPrompt,
+        effort: command.effort ?? "high",
+        shell_pid: await waitForPid(scriptPath, pidPath),
+        script_dir: scriptDir,
+        context_dir: contextRoot,
+        onboarding_path: onboardingPath,
+        summary_path: summaryPath,
+        inbox_dir: inboxDir,
+        outbox_dir: outboxDir,
+        bootstrap: context.bootstrap && context.task?.snapshot
+            ? {
+                session_id: context.bootstrap.fence.session_id,
+                session_epoch: context.bootstrap.fence.session_epoch,
+                session_token: context.bootstrap.session_token,
+                bundle_seq: context.bootstrap.descriptor.current_manifest_seq ?? context.task.snapshot.manifest_seq ?? 1,
+                task_version: context.task.snapshot.task_version,
+            }
+            : null,
+    };
+    await writeSessionManifest(session);
+    child.on("error", async () => {
+        await rm(scriptDir, { recursive: true, force: true });
+        await rm(path.join(contextRoot, "sessions", sanitizeId(session.session_id), "session.json"), { force: true }).catch(() => undefined);
+        await removeSessionManifest(session.session_id).catch(() => undefined);
+    });
+    child.unref();
+    return session;
+}
+function buildPowerShellLauncher(input) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `$runnerKind = '${toPsSingleQuoted(input.runner)}'`,
+        `$runner = '${toPsSingleQuoted(input.runnerCommand)}'`,
+        `$agentId = '${toPsSingleQuoted(input.agentId)}'`,
+        `$workdir = '${toPsSingleQuoted(input.workdir)}'`,
+        `$contextDir = '${toPsSingleQuoted(input.contextDir)}'`,
+        `$onboardingPath = '${toPsSingleQuoted(input.onboardingPath)}'`,
+        `$summaryPath = '${toPsSingleQuoted(input.summaryPath)}'`,
+        `$inboxDir = '${toPsSingleQuoted(input.inboxDir)}'`,
+        `$outboxDir = '${toPsSingleQuoted(input.outboxDir)}'`,
+        `$sessionDir = Split-Path $inboxDir -Parent`,
+        `$debugLogPath = Join-Path $sessionDir 'worker.log'`,
+        `$pidPath = '${toPsSingleQuoted(input.pidPath)}'`,
+        `$effort = '${toPsSingleQuoted(input.effort)}'`,
+        `$taskId = '${toPsSingleQuoted(input.taskId ?? "")}'`,
+        `$env:OFFICE_PROJECT_ID = '${toPsSingleQuoted(input.projectId)}'`,
+        `$env:OFFICE_TASK_ID = '${toPsSingleQuoted(input.taskId ?? "")}'`,
+        `$env:OFFICE_CONTEXT_DIR = $contextDir`,
+        `$env:OFFICE_ONBOARDING_PATH = $onboardingPath`,
+        `$env:OFFICE_SUMMARY_PATH = $summaryPath`,
+        `$env:OFFICE_LOCAL_SESSION_ID = '${toPsSingleQuoted(input.sessionId)}'`,
+        `$env:OFFICE_HOST_ID = '${toPsSingleQuoted(input.hostId)}'`,
+        `$env:OFFICE_HOST_DISPLAY_NAME = '${toPsSingleQuoted(input.hostDisplayName)}'`,
+        `$env:DOUBLE_PENETRATION_PROJECT_ID = '${toPsSingleQuoted(input.projectId)}'`,
+        `$env:DOUBLE_PENETRATION_TASK_ID = '${toPsSingleQuoted(input.taskId ?? "")}'`,
+        `$env:DOUBLE_PENETRATION_CONTEXT_PATH = $summaryPath`,
+        "$PID | Set-Content -LiteralPath $pidPath",
+        "Set-Location -LiteralPath $workdir",
+        "New-Item -ItemType Directory -Force -Path $inboxDir | Out-Null",
+        "New-Item -ItemType Directory -Force -Path $outboxDir | Out-Null",
+        "function Parse-CodexOutput($lines) {",
+        "  $final = ''",
+        "  foreach ($line in $lines) {",
+        "    try {",
+        "      $payload = $line | ConvertFrom-Json -ErrorAction Stop",
+        "      if ($payload.type -eq 'item.completed' -and $payload.item.type -eq 'agent_message') {",
+        "        $text = [string]$payload.item.text",
+        "        if ($text.Trim()) { $final = $text }",
+        "      }",
+        "    } catch {}",
+        "  }",
+        "  return $final.Trim()",
+        "}",
+        "function Parse-ClaudeOutput($lines) {",
+        "  $final = ''",
+        "  foreach ($line in $lines) {",
+        "    try {",
+        "      $payload = $line | ConvertFrom-Json -ErrorAction Stop",
+        "      if ($payload.type -eq 'assistant' -and $payload.message.content) {",
+        "        $textParts = @()",
+        "        foreach ($entry in $payload.message.content) { if ($entry.type -eq 'text') { $textParts += [string]$entry.text } }",
+        "        $joined = ($textParts -join '')",
+        "        if ($joined.Trim()) { $final = $joined }",
+        "      } elseif ($payload.type -eq 'result' -and $payload.result) {",
+        "        $text = [string]$payload.result",
+        "        if ($text.Trim()) { $final = $text }",
+        "      }",
+        "    } catch {}",
+        "  }",
+        "  return $final.Trim()",
+        "}",
+        "function Normalize-RunnerFailure([string]$Text, [int]$ExitCode) {",
+        "  $flat = ($Text -replace '\\s+', ' ').Trim()",
+        "  if (-not $flat) { return ('Runner exited with code ' + $ExitCode + '.') }",
+        "  if ($flat -match 'usage limit|out of extra usage|out of usage|try again at') { return 'Runner is unavailable on this machine due to usage limits.' }",
+        "  if ($flat -match 'unexpected argument') { return 'Runner rejected the launch arguments.' }",
+        "  if ($flat -match 'not a directory') { return 'Runner rejected the workspace path.' }",
+        "  if ($flat.Length -gt 220) { return ($flat.Substring(0, 220) + '...') }",
+        "  return $flat",
+        "}",
+        "function Convert-ToProcessArgument([string]$Value) {",
+        "  if ($null -eq $Value) { return '\"\"' }",
+        "  if ($Value -notmatch '[\\s\"]') { return $Value }",
+        "  $escaped = $Value -replace '(\\\\*)\"', '$1$1\\\"'",
+        "  $escaped = $escaped -replace '(\\\\+)$', '$1$1'",
+        "  return '\"' + $escaped + '\"'",
+        "}",
+        "function Invoke-AgentPrompt([string]$PromptText) {",
+        "  $lines = New-Object System.Collections.Generic.List[string]",
+        "  $start = Get-Date",
+        "  Add-Content -LiteralPath $debugLogPath -Value ('runner-start ' + $start.ToString('o') + ' exe=' + $runner)",
+        "  $stdoutPath = Join-Path $sessionDir 'runner.stdout.log'",
+        "  $stderrPath = Join-Path $sessionDir 'runner.stderr.log'",
+        "  $inputPath = Join-Path $sessionDir 'runner.prompt.txt'",
+        "  Set-Content -LiteralPath $inputPath -Value $PromptText -Encoding UTF8",
+        "  $psi = New-Object System.Diagnostics.ProcessStartInfo",
+        "  $psi.FileName = $runner",
+        "  $psi.WorkingDirectory = $workdir",
+        "  $psi.UseShellExecute = $false",
+        "  $psi.RedirectStandardOutput = $true",
+        "  $psi.RedirectStandardError = $true",
+        "  $psi.CreateNoWindow = $true",
+        "  $argValues = New-Object System.Collections.Generic.List[string]",
+        "  if ($runnerKind -eq 'codex') {",
+        "    foreach ($arg in @('exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', '-C', $workdir)) {",
+        "      $argValues.Add([string]$arg)",
+        "    }",
+        "    if ($effort) {",
+        "      foreach ($arg in @('-c', ('model_reasoning_effort=\"' + $effort + '\"'))) {",
+        "        $argValues.Add([string]$arg)",
+        "      }",
+        "    }",
+        "    $argValues.Add('-')",
+        "    $psi.RedirectStandardInput = $true",
+        "  } else {",
+        "    foreach ($arg in @('-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions', '--add-dir', $workdir, '--add-dir', $contextDir)) {",
+        "      $argValues.Add([string]$arg)",
+        "    }",
+        "    if ($effort) {",
+        "      foreach ($arg in @('--effort', $effort)) {",
+        "        $argValues.Add([string]$arg)",
+        "      }",
+        "    }",
+        "    $argValues.Add($PromptText)",
+        "  }",
+        "  $arguments = ($argValues | ForEach-Object { Convert-ToProcessArgument ([string]$_) }) -join ' '",
+        "  $psi.Arguments = $arguments",
+        "  Add-Content -LiteralPath $debugLogPath -Value ('runner-args ' + $arguments)",
+        "  $proc = New-Object System.Diagnostics.Process",
+        "  $proc.StartInfo = $psi",
+        "  $null = $proc.Start()",
+        "  if ($psi.RedirectStandardInput) {",
+        "    $proc.StandardInput.Write($PromptText)",
+        "    $proc.StandardInput.Close()",
+        "  }",
+        "  $stdoutTask = $proc.StandardOutput.ReadToEndAsync()",
+        "  $stderrTask = $proc.StandardError.ReadToEndAsync()",
+        "  $proc.WaitForExit()",
+        "  $stdout = $stdoutTask.GetAwaiter().GetResult()",
+        "  $stderr = $stderrTask.GetAwaiter().GetResult()",
+        "  $exitCode = [int]$proc.ExitCode",
+        "  Add-Content -LiteralPath $debugLogPath -Value ('runner-exit ' + (Get-Date).ToString('o') + ' code=' + $exitCode)",
+        "  [System.IO.File]::WriteAllText($stdoutPath, $stdout, [System.Text.UTF8Encoding]::new($false))",
+        "  [System.IO.File]::WriteAllText($stderrPath, $stderr, [System.Text.UTF8Encoding]::new($false))",
+        "  if ($stdout.Trim()) {",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('runner-stdout ' + ($stdout -replace '\\s+', ' '))",
+        "    foreach ($line in $stdout -split '\\r?\\n') { if ($line.Trim()) { $lines.Add([string]$line); Write-Host $line } }",
+        "  }",
+        "  if ($stderr.Trim()) {",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('runner-stderr ' + ($stderr -replace '\\s+', ' '))",
+        "    foreach ($line in $stderr -split '\\r?\\n') { if ($line.Trim()) { $lines.Add([string]$line); Write-Host $line } }",
+        "  }",
+        "  $parsed = if ($runnerKind -eq 'codex') { Parse-CodexOutput $lines } else { Parse-ClaudeOutput $lines }",
+        "  if ($parsed.Trim()) {",
+        "    $normalizedParsed = Normalize-RunnerFailure $parsed.Trim() $exitCode",
+        "    if ($normalizedParsed -ne $parsed.Trim()) {",
+        "      throw $normalizedParsed",
+        "    }",
+        "    return $parsed.Trim()",
+        "  }",
+        "  if ($exitCode -ne 0 -or $stdout.Trim() -or $stderr.Trim()) {",
+        "    throw (Normalize-RunnerFailure (($stderr + [Environment]::NewLine + $stdout).Trim()) $exitCode)",
+        "  }",
+        "  return ''",
+        "}",
+        "function Write-ReplyFile([hashtable]$Payload) {",
+        "  $name = ([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds().ToString() + '-' + [guid]::NewGuid().Guid + '.json')",
+        "  $path = Join-Path $outboxDir $name",
+        "  [System.IO.File]::WriteAllText($path, ($Payload | ConvertTo-Json -Depth 8), [System.Text.UTF8Encoding]::new($false))",
+        "  $exists = Test-Path -LiteralPath $path",
+        "  $size = if ($exists) { (Get-Item -LiteralPath $path).Length } else { 0 }",
+        "  Add-Content -LiteralPath $debugLogPath -Value ('reply-proof ' + (Get-Date).ToString('o') + ' path=' + $path + ' exists=' + $exists + ' size=' + $size)",
+        "  return $path",
+        "}",
+        `$prompt = @'`,
+        input.prompt,
+        "'@",
+        `$Host.UI.RawUI.WindowTitle = 'office :: ${toPsSingleQuoted(input.agentId)}'`,
+        "Write-Host '====================================================' -ForegroundColor DarkYellow",
+        `Write-Host 'office :: ${toPsSingleQuoted(input.agentId)}' -ForegroundColor Yellow`,
+        `Write-Host 'mode=${toPsSingleQuoted(input.mode)} project=${toPsSingleQuoted(input.projectId)} task=${toPsSingleQuoted(input.taskId ?? "none")}' -ForegroundColor DarkYellow`,
+        "Write-Host ('onboarding: ' + $onboardingPath) -ForegroundColor DarkGray",
+        "Write-Host ('summary:    ' + $summaryPath) -ForegroundColor DarkGray",
+        "Write-Host 'This shell is the live room worker. New prompts arrive here from the browser.' -ForegroundColor DarkGray",
+        "Write-Host '====================================================' -ForegroundColor DarkYellow",
+        "Write-Host $prompt -ForegroundColor Gray",
+        "Add-Content -LiteralPath $debugLogPath -Value ('boot ' + (Get-Date).ToString('o') + ' prompt=' + ($prompt -replace '\\s+', ' '))",
+        "while ($true) {",
+        "  $next = Get-ChildItem -LiteralPath $inboxDir -Filter '*.json' -ErrorAction SilentlyContinue | Sort-Object Name | Select-Object -First 1",
+        "  if (-not $next) { Start-Sleep -Milliseconds 450; continue }",
+        "  try {",
+        "    $job = Get-Content -Raw -LiteralPath $next.FullName | ConvertFrom-Json -ErrorAction Stop",
+        "    if ($job.type -eq 'stop') { Remove-Item -LiteralPath $next.FullName -Force -ErrorAction SilentlyContinue; break }",
+        "    Write-Host ''",
+        "    Write-Host ('[' + (Get-Date).ToString('HH:mm:ss') + '] ' + $job.author_label + ' -> ' + $agentId) -ForegroundColor Cyan",
+        "    Write-Host $job.text -ForegroundColor White",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('message ' + (Get-Date).ToString('o') + ' seq=' + $job.seq + ' text=' + ($job.text -replace '\\s+', ' '))",
+        "    $deliveryPrompt = @\"",
+        "Read onboarding.txt at:",
+        "$onboardingPath",
+        "",
+        "Read summary.txt at:",
+        "$summaryPath",
+        "",
+        "New room message from $($job.author_label) (seq $($job.seq)):",
+        "$($job.text)",
+        "",
+        "Respond to the shared room in concise plain text.",
+        "\"@",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('invoke ' + (Get-Date).ToString('o') + ' runner=' + $runnerKind)",
+        "    $replyText = Invoke-AgentPrompt $deliveryPrompt",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('reply-text ' + (Get-Date).ToString('o') + ' text=' + ($replyText -replace '\\s+', ' '))",
+        "    if ($replyText.Trim()) {",
+        "      Add-Content -LiteralPath $debugLogPath -Value ('write-reply ' + (Get-Date).ToString('o'))",
+        "      $replyPath = Write-ReplyFile @{",
+        "        message_id = ('msg_' + [guid]::NewGuid().Guid)",
+        "        author_type = 'agent'",
+        "        author_id = $agentId",
+        "        author_label = $agentId",
+        "        text = $replyText.Trim()",
+        "        task_id = if ($job.task_id) { [string]$job.task_id } elseif ($taskId) { $taskId } else { $null }",
+        "        reply_to_seq = [int]$job.seq",
+        "      }",
+        "      Add-Content -LiteralPath $debugLogPath -Value ('reply-proof-final ' + (Get-Date).ToString('o') + ' path=' + $replyPath + ' exists=' + (Test-Path -LiteralPath $replyPath) + ' size=' + ((Get-Item -LiteralPath $replyPath).Length))",
+        "    }",
+        "  } catch {",
+        "    Add-Content -LiteralPath $debugLogPath -Value ('catch ' + (Get-Date).ToString('o') + ' error=' + $_.Exception.Message)",
+        "    Write-ReplyFile @{",
+        "      message_id = ('msg_' + [guid]::NewGuid().Guid)",
+        "      author_type = 'system'",
+        "      author_id = $env:OFFICE_HOST_ID",
+        "      author_label = $env:OFFICE_HOST_DISPLAY_NAME",
+        "      text = ($agentId + ' failed to answer: ' + $_.Exception.Message)",
+        "      task_id = if ($job.task_id) { [string]$job.task_id } elseif ($taskId) { $taskId } else { $null }",
+        "      reply_to_seq = if ($job.seq) { [int]$job.seq } else { $null }",
+        "    }",
+        "  } finally {",
+        "    Remove-Item -LiteralPath $next.FullName -Force -ErrorAction SilentlyContinue",
+        "  }",
+        "}",
+        "Write-Host ''",
+        "Write-Host 'Agent loop ended.' -ForegroundColor DarkGray",
+    ].join("\r\n");
+}
+function buildInteractivePrompt(runtime, command, environment, task) {
+    const runner = command.runner ?? "codex";
+    const mode = command.mode ?? "attach";
+    const snapshot = task?.snapshot ?? null;
+    const modeInstruction = mode === "brainstorm"
+        ? "Brainstorm and align before editing files."
+        : mode === "review"
+            ? "Inspect and review the task; do not make changes unless clearly required."
+            : mode === "attach"
+                ? "Catch up on the workspace state and be ready for follow-up."
+                : "Execute the current task in the workspace.";
+    const promptParts = [
+        `You are ${command.agent_id}, a ${runner} agent working in the shared office.`,
+        `Project: ${runtime.projectId}.`,
+        snapshot?.title ? `Task: ${snapshot.title}.` : "There may not be an active task yet.",
+        snapshot?.accepted_understanding ? `Shared understanding: ${snapshot.accepted_understanding}` : null,
+        environment.repo_name
+            ? `Workspace repo: ${environment.repo_name}${environment.git_branch ? ` on ${environment.git_branch}` : ""}.`
+            : `Workspace directory: ${path.resolve(command.workdir || resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId))}.`,
+        "Read onboarding.txt at OFFICE_ONBOARDING_PATH, then read summary.txt at OFFICE_SUMMARY_PATH.",
+        "Stay inside this current project room. Do not assume sleeping context from older conversations.",
+        modeInstruction,
+    ].filter(Boolean);
+    return promptParts.join(" ");
+}
+function buildOnboardingText() {
+    return [
+        "office host onboarding",
+        "You are joining one active current-project room.",
+        "Work only inside the current project directory.",
+        "Treat summary.txt as the compacted room state for this conversation.",
+        "Do not assume sleeping agents or hidden history from older chats.",
+        "Use the visible shell for this room and keep responses concise, concrete, and collaborative.",
+        "If you make progress, blockers, or decisions, reflect them clearly in the room.",
+    ].join("\n");
+}
+function buildSummaryText(runtime, command, environment, project, task, bootstrap) {
+    const taskSnapshot = task?.snapshot ?? null;
+    const office = project?.office ?? null;
+    const roomMessages = Array.isArray(office?.room?.recent_messages) ? office.room.recent_messages.slice(-10) : [];
+    const recentDialogue = roomMessages.length
+        ? roomMessages.map((entry) => `- ${entry.author_label ?? entry.author_id}: ${String(entry.text ?? "").slice(0, 360)}`).join("\n")
+        : "No room messages yet.";
+    const activeAgents = Array.isArray(office?.hosts)
+        ? office.hosts.flatMap((host) => host.running_sessions ?? []).map((session) => session.agent_id).filter((name) => Boolean(name))
+        : [];
+    const focusTitle = office?.current_project?.focus_task_title ?? taskSnapshot?.title ?? "No focused task";
+    const focusId = office?.current_project?.focus_task_id ?? taskSnapshot?.task_id ?? "none";
+    const directive = office?.attention?.human_directives?.[0]?.text ?? "No explicit conductor directive captured.";
+    const lastDeliverable = office?.artifacts?.[0]
+        ? `${office.artifacts[0].task_title}: ${office.artifacts[0].summary ?? "completed"}`
+        : "No deliverables yet.";
+    return [
+        "current project summary",
+        `generated_at: ${new Date().toISOString()}`,
+        "",
+        "[project]",
+        `project_id: ${runtime.projectId}`,
+        `project_name: ${project?.name ?? runtime.projectId}`,
+        `workspace_dir: ${path.resolve(command.workdir || resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId))}`,
+        `headline: ${office?.current_project?.headline ?? project?.accepted_understanding ?? "No headline yet."}`,
+        "",
+        "[room]",
+        `conductor: ${office?.room?.settings?.conductor_name ?? "You"}`,
+        `all_agents_listening: ${Boolean(office?.room?.settings?.all_agents_listening ?? true)}`,
+        `focus_task_id: ${focusId}`,
+        `focus_task_title: ${focusTitle}`,
+        `latest_directive: ${directive}`,
+        "",
+        "[active_agents]",
+        activeAgents.length ? activeAgents.map((name) => `- ${name}`).join("\n") : "No active agents in this room.",
+        "",
+        "[workspace]",
+        `repo_root: ${environment.repo_root ?? "none"}`,
+        `repo_name: ${environment.repo_name ?? "none"}`,
+        `git_branch: ${environment.git_branch ?? "none"}`,
+        `git_head: ${environment.git_head ?? "none"}`,
+        `git_dirty: ${environment.git_dirty}`,
+        `repo_status: staged=${environment.staged_files} changed=${environment.changed_files} untracked=${environment.untracked_files}`,
+        "",
+        "[latest_deliverable]",
+        lastDeliverable,
+        "",
+        "[agent_session_bootstrap]",
+        `session_id: ${bootstrap?.fence.session_id ?? "none"}`,
+        `session_epoch: ${bootstrap?.fence.session_epoch ?? "none"}`,
+        `manifest_seq: ${bootstrap?.descriptor.current_manifest_seq ?? "none"}`,
+        "",
+        "[recent_room_messages]",
+        recentDialogue,
+    ].join("\n");
+}
+async function refreshSessionSummary(runtime, session, project) {
+    if (!session.summary_path) {
+        return;
+    }
+    const environment = collectEnvironment(session.workdir);
+    const summaryText = buildSummaryText(runtime, {
+        command_id: "",
+        command_type: "spawn",
+        runner: session.runner,
+        agent_id: session.agent_id,
+        mode: session.mode,
+        effort: session.effort ?? "high",
+        workdir: session.workdir,
+        task_id: session.task_id ?? null,
+        prompt: null,
+    }, environment, project, null, null);
+    await writeFile(session.summary_path, summaryText, "utf8");
+}
+async function waitForPid(scriptPath, pidPath, timeoutMs = 6000) {
+    const startedAt = Date.now();
+    let candidatePid = null;
+    let candidateSince = 0;
+    while (Date.now() - startedAt < timeoutMs) {
+        let nextCandidate = null;
+        try {
+            const text = (await readFile(pidPath, "utf8")).trim();
+            const pid = Number(text);
+            if (Number.isFinite(pid) && pid > 0 && isProcessAlive(pid) && processCommandLineHasScript(pid, scriptPath)) {
+                nextCandidate = pid;
+            }
+        }
+        catch {
+            // Wait for the tab shell to boot and write the pid file.
+        }
+        const fallback = findShellPidByScript(scriptPath);
+        if (fallback) {
+            nextCandidate = Math.max(nextCandidate ?? 0, fallback);
+        }
+        if (nextCandidate && nextCandidate === candidatePid && Date.now() - candidateSince >= 1200) {
+            return nextCandidate;
+        }
+        if (nextCandidate && nextCandidate !== candidatePid) {
+            candidatePid = nextCandidate;
+            candidateSince = Date.now();
+        }
+        await sleep(150);
+    }
+    return candidatePid && isProcessAlive(candidatePid) ? candidatePid : null;
+}
+function processCommandLineHasScript(pid, scriptPath) {
+    const escaped = scriptPath.replace(/\\/g, "\\\\").replace(/'/g, "''");
+    const result = spawnSync("powershell.exe", [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" | Where-Object { $_.CommandLine -like '*${escaped}*' } | Select-Object -First 1 -ExpandProperty ProcessId)`,
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    return result.status === 0 && String(result.stdout ?? "").trim() !== "";
+}
+function findShellPidByScript(scriptPath) {
+    const escaped = scriptPath.replace(/\\/g, "\\\\").replace(/'/g, "''");
+    const result = spawnSync("powershell.exe", [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        `(Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'powershell.exe' -and $_.CommandLine -like '*${escaped}*' } | Select-Object -First 1 -ExpandProperty ProcessId)`,
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const pids = String(result.stdout ?? "")
+        .split(/\r?\n/)
+        .map((line) => Number(line.trim()))
+        .filter((pid) => Number.isFinite(pid) && pid > 0);
+    if (pids.length === 0) {
+        return null;
+    }
+    return Math.max(...pids);
+}
+function findShellPidBySessionId(sessionId) {
+    const escaped = sessionId.replace(/'/g, "''");
+    const result = spawnSync("powershell.exe", [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        `(Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'powershell.exe' -and $_.CommandLine -like '*${escaped}*' } | Select-Object -First 1 -ExpandProperty ProcessId)`,
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const pid = Number(String(result.stdout ?? "").trim());
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+async function refreshSessions(runtime) {
+    let changed = false;
+    for (const [sessionId, session] of sessions.entries()) {
+        if (session.status !== "running") {
+            continue;
+        }
+        const scriptPath = session.script_dir ? path.join(session.script_dir, `${session.session_id}.ps1`) : null;
+        if ((!session.shell_pid || !isProcessAlive(session.shell_pid)) && scriptPath) {
+            const resolved = findShellPidByScript(scriptPath);
+            if (resolved) {
+                session.shell_pid = resolved;
+                session.missed_checks = 0;
+                changed = true;
+                continue;
+            }
+        }
+        if (!session.shell_pid) {
+            continue;
+        }
+        if (!isProcessAlive(session.shell_pid)) {
+            session.missed_checks = (session.missed_checks ?? 0) + 1;
+            const ageMs = Date.now() - new Date(session.launched_at).getTime();
+            if (ageMs < 15000 || session.missed_checks < 3) {
+                continue;
+            }
+            session.status = "completed";
+            if (session.script_dir) {
+                void rm(session.script_dir, { recursive: true, force: true });
+            }
+            sessions.delete(sessionId);
+            void sendStoppedAgentStatus(runtime, session, "Session ended.").catch(() => undefined);
+            changed = true;
+            continue;
+        }
+        session.missed_checks = 0;
+    }
+    if (changed) {
+        await persistSessions();
+    }
+}
+function isProcessAlive(pid) {
+    const result = spawnSync("tasklist.exe", ["/FI", `PID eq ${pid}`], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return false;
+    }
+    return String(result.stdout ?? "").includes(String(pid));
+}
+export async function stopSession(runtime, sessionId) {
+    const session = sessions.get(sessionId) ?? null;
+    if (!session) {
+        const shellPid = findShellPidBySessionId(sessionId);
+        if (shellPid) {
+            spawnSync("taskkill.exe", ["/PID", String(shellPid), "/T", "/F"], {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            return {
+                session_id: sessionId,
+                project_id: runtime.projectId,
+                runner: "codex",
+                agent_id: sessionId,
+                mode: "attach",
+                workdir: resolveProjectWorkdir(runtime.defaultWorkdir, runtime.projectId),
+                status: "completed",
+                launched_at: new Date().toISOString(),
+                task_id: null,
+                shell_pid: shellPid,
+            };
+        }
+        return null;
+    }
+    if (session.shell_pid) {
+        spawnSync("taskkill.exe", ["/PID", String(session.shell_pid), "/T", "/F"], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+    }
+    if (session.script_dir) {
+        await rm(session.script_dir, { recursive: true, force: true }).catch(() => undefined);
+    }
+    session.status = "completed";
+    sessions.delete(sessionId);
+    await persistSessions();
+    await sendStoppedAgentStatus(runtime, session, "Removed from the room.");
+    return session;
+}
+export async function persistSessions() {
+    await Promise.all([
+        savePersistedHostSessions(Array.from(sessions.values())),
+        ...Array.from(sessions.values()).map((session) => writeSessionManifest(session)),
+    ]);
+}
+async function writeSessionManifest(session) {
+    if (!session.context_dir) {
+        return;
+    }
+    const sessionDir = path.join(session.context_dir, "sessions", sanitizeId(session.session_id));
+    await mkdir(sessionDir, { recursive: true });
+    await writeFile(path.join(sessionDir, "session.json"), JSON.stringify(session, null, 2), "utf8");
+}
+async function removeSessionManifest(sessionId) {
+    for (const baseDir of candidateSessionBases(process.cwd())) {
+        const sessionJson = path.join(baseDir, sanitizeId(sessionId), "session.json");
+        await rm(sessionJson, { force: true }).catch(() => undefined);
+    }
+}
+function candidateSessionBases(defaultWorkdir, projectId) {
+    const bases = new Set();
+    bases.add(path.join(path.resolve(defaultWorkdir), ".office-host", "sessions"));
+    if (projectId) {
+        bases.add(path.join(resolveProjectWorkdir(defaultWorkdir, projectId), ".office-host", "sessions"));
+    }
+    bases.add(path.join(process.cwd(), ".office-host", "sessions"));
+    return Array.from(bases);
+}
+async function restoreSessions(runtime) {
+    const persisted = await loadPersistedHostSessions();
+    for (const session of persisted) {
+        if (session.status !== "running") {
+            continue;
+        }
+        if (session.project_id && session.project_id !== runtime.projectId) {
+            continue;
+        }
+        if (session.shell_pid && !isProcessAlive(session.shell_pid)) {
+            continue;
+        }
+        sessions.set(session.session_id, session);
+    }
+    const bases = candidateSessionBases(runtime.defaultWorkdir, runtime.projectId);
+    for (const baseDir of bases) {
+        if (!existsSync(baseDir)) {
+            continue;
+        }
+        let entries = [];
+        try {
+            entries = await readdir(baseDir, { withFileTypes: true }).then((items) => items.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const manifestPath = path.join(baseDir, entry, "session.json");
+            if (!existsSync(manifestPath)) {
+                continue;
+            }
+            try {
+                const session = JSON.parse(await readFile(manifestPath, "utf8"));
+                if (!session?.session_id || session.status !== "running") {
+                    continue;
+                }
+                if (session.project_id && session.project_id !== runtime.projectId) {
+                    continue;
+                }
+                if (session.shell_pid && !isProcessAlive(session.shell_pid)) {
+                    continue;
+                }
+                sessions.set(session.session_id, session);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    if (sessions.size > 0) {
+        await persistSessions().catch(() => undefined);
+    }
+}
+async function sendStoppedAgentStatus(runtime, session, summary) {
+    if (!session.task_id || !session.bootstrap) {
+        return;
+    }
+    const envelope = {
+        protocol_version: "1.0",
+        command_schema_version: 1,
+        command_id: `${session.agent_id}:status.upsert:${crypto.randomUUID()}`,
+        session_id: session.bootstrap.session_id,
+        session_epoch: session.bootstrap.session_epoch,
+        agent_id: session.agent_id,
+        task_id: session.task_id,
+        observed_task_version: session.bootstrap.task_version,
+        bundle_seq: session.bootstrap.bundle_seq,
+        type: "status.upsert",
+        payload: {
+            task_summary: summary,
+            state: "done",
+        },
+        sent_at: new Date().toISOString(),
+    };
+    await postJson(runtime, "/api/agents/events", { commands: [envelope] }, session.bootstrap.session_token);
+}
+function collectEnvironment(workdir) {
+    const resolved = path.resolve(workdir);
+    if (!existsSync(resolved)) {
+        return {
+            workdir_exists: false,
+            repo_root: null,
+            repo_name: null,
+            git_branch: null,
+            git_head: null,
+            git_dirty: false,
+            staged_files: 0,
+            changed_files: 0,
+            untracked_files: 0,
+            node_version: process.version.replace(/^v/, ""),
+        };
+    }
+    const repo_root = runCommand("git", ["rev-parse", "--show-toplevel"], resolved);
+    const git_branch = repo_root ? runCommand("git", ["branch", "--show-current"], resolved) : null;
+    const git_head = repo_root ? runCommand("git", ["rev-parse", "--short", "HEAD"], resolved) : null;
+    const statusOutput = repo_root
+        ? runCommand("git", ["status", "--porcelain", "--untracked-files=all", "--", "."], resolved)
+        : null;
+    let staged_files = 0;
+    let changed_files = 0;
+    let untracked_files = 0;
+    for (const line of (statusOutput ?? "").split(/\r?\n/).filter(Boolean)) {
+        if (line.startsWith("??")) {
+            untracked_files += 1;
+            continue;
+        }
+        const indexStatus = line[0] ?? " ";
+        const worktreeStatus = line[1] ?? " ";
+        if (indexStatus !== " ") {
+            staged_files += 1;
+        }
+        if (worktreeStatus !== " ") {
+            changed_files += 1;
+        }
+    }
+    return {
+        workdir_exists: true,
+        repo_root,
+        repo_name: path.basename(resolved),
+        git_branch,
+        git_head,
+        git_dirty: staged_files + changed_files + untracked_files > 0,
+        staged_files,
+        changed_files,
+        untracked_files,
+        node_version: process.version.replace(/^v/, ""),
+    };
+}
+function runCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const text = String(result.stdout ?? "").trim();
+    return text || null;
+}
+export async function getJson(runtime, pathname, tokenOverride) {
+    return requestJson(runtime, pathname, {
+        method: "GET",
+        tokenOverride,
+    });
+}
+export async function postJson(runtime, pathname, body, tokenOverride) {
+    return requestJson(runtime, pathname, {
+        method: "POST",
+        body,
+        tokenOverride,
+    });
+}
+export async function postRoomMessageUpsert(runtime, body) {
+    return postJson(runtime, `/api/projects/${runtime.projectId}/room/messages/upsert`, body);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const item = argv[i];
+        if (!item.startsWith("--")) {
+            continue;
+        }
+        const key = item.slice(2);
+        const value = argv[i + 1];
+        if (!value || value.startsWith("--")) {
+            result[key] = "true";
+            continue;
+        }
+        result[key] = value;
+        i += 1;
+    }
+    return result;
+}
+export function sanitizeId(value) {
+    return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function normalizePollMs(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return 900;
+    }
+    return Math.max(600, Math.min(parsed, 1500));
+}
+function toPsSingleQuoted(value) {
+    return value.replace(/'/g, "''");
+}
+function safeScriptTempBase() {
+    // Prefer a spaceless system temp so wt.exe can pass the path to PowerShell without quoting issues.
+    const candidates = ["C:\\Temp", "C:\\Windows\\Temp", "C:\\ProgramData\\Temp"];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return os.tmpdir();
+}
+export function resolveProjectWorkdir(baseWorkdir, projectId) {
+    return path.join(path.resolve(baseWorkdir), "projects", sanitizeId(projectId));
+}
+async function persistRoomCursor(runtime) {
+    await upsertHostConfig({
+        host_id: runtime.hostId,
+        display_name: runtime.displayName,
+        base_url: runtime.baseUrl,
+        project_id: runtime.projectId,
+        workdir: runtime.defaultWorkdir,
+        token: runtime.token,
+        room_cursor_seq: runtime.roomCursorSeq,
+        poll_ms: runtime.pollMs,
+    });
+}
+async function refreshHostToken(runtime) {
+    runtime.token = await registerHostToken({
+        baseUrl: runtime.baseUrl,
+        projectId: runtime.projectId,
+        hostId: runtime.hostId,
+        displayName: runtime.displayName,
+        workdir: runtime.defaultWorkdir,
+        pollMs: runtime.pollMs,
+    });
+    await upsertHostConfig({
+        host_id: runtime.hostId,
+        display_name: runtime.displayName,
+        base_url: runtime.baseUrl,
+        project_id: runtime.projectId,
+        workdir: runtime.defaultWorkdir,
+        token: runtime.token,
+        room_cursor_seq: runtime.roomCursorSeq,
+        poll_ms: runtime.pollMs,
+    });
+}
+async function requestJson(runtime, pathname, options) {
+    const attempts = 3;
+    let lastError = null;
+    let refreshedAfter401 = false;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            const response = await fetch(`${runtime.baseUrl}${pathname}`, {
+                method: options.method,
+                headers: {
+                    ...(options.method === "POST" ? { "content-type": "application/json" } : {}),
+                    ...(options.tokenOverride ?? runtime.token ? { authorization: `Bearer ${options.tokenOverride ?? runtime.token}` } : {}),
+                },
+                body: options.method === "POST" ? JSON.stringify(options.body ?? null) : undefined,
+                signal: AbortSignal.timeout(12000),
+            });
+            if (!response.ok) {
+                if (response.status === 401 && !options.tokenOverride && !refreshedAfter401) {
+                    refreshedAfter401 = true;
+                    await refreshHostToken(runtime);
+                    continue;
+                }
+                const text = await response.text();
+                if (attempt < attempts && shouldRetryStatus(response.status)) {
+                    await sleep(350 * attempt);
+                    continue;
+                }
+                throw new Error(`${pathname} failed: ${response.status} ${text}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt >= attempts) {
+                break;
+            }
+            await sleep(350 * attempt);
+        }
+    }
+    throw lastError ?? new Error(`${pathname} failed`);
+}
+function shouldRetryStatus(status) {
+    return status === 408 || status === 425 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}