@zq-silk/yui 0.0.0

package/dist/executor/agentExecutor.js

@@ -0,0 +1,144 @@
+export function createRoleSessionSet(owner, activeAgentId, now) {
+    return {
+        schemaVersion: 1,
+        owner: normalizeOwner(owner),
+        activeAgentId: requireSafeIdentity(activeAgentId, "Active Agent id"),
+        sessions: {},
+        updatedAt: now.toISOString()
+    };
+}
+export function activeRoleAgentSession(set) {
+    if (set === null)
+        return null;
+    validateRoleSessionSet(set);
+    return set.sessions[set.activeAgentId] ?? null;
+}
+export function recordRoleAgentSession(set, input, now) {
+    validateRoleSessionSet(set);
+    const agentId = requireSafeIdentity(input.agentId, "Agent id");
+    const adapterId = requireText(input.adapterId, "Agent adapter id");
+    const nativeSessionId = requireText(input.nativeSessionId, "Native session id");
+    if (!isAgentSessionStatus(input.status)) {
+        throw new Error(`Role Agent session status is invalid: ${input.status}.`);
+    }
+    if (input.policy !== "fixed" && input.policy !== "leader-controlled") {
+        throw new Error(`Role Agent session policy is invalid: ${input.policy}.`);
+    }
+    const existing = set.sessions[agentId];
+    if (existing !== undefined && existing.adapterId !== adapterId) {
+        throw new Error(`Role Agent session adapter cannot change: ${agentId}.`);
+    }
+    const timestamp = now.toISOString();
+    const session = {
+        schemaVersion: 1,
+        agentId,
+        adapterId,
+        nativeSessionId,
+        policy: input.policy,
+        status: input.status,
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp
+    };
+    validateRoleAgentSession(session, agentId);
+    const updated = {
+        ...set,
+        sessions: { ...set.sessions, [agentId]: session },
+        updatedAt: timestamp
+    };
+    validateRoleSessionSet(updated);
+    return updated;
+}
+export function createRoleAgentSession(input, now) {
+    const agentId = requireSafeIdentity(input.agentId, "Agent id");
+    const set = createRoleSessionSet({ scope: "global", roleName: "session-factory" }, agentId, now);
+    return recordRoleAgentSession(set, input, now).sessions[agentId];
+}
+export function updateRoleAgentSessionStatus(set, agentId, status, now) {
+    validateRoleSessionSet(set);
+    const normalizedAgentId = requireSafeIdentity(agentId, "Agent id");
+    if (!isAgentSessionStatus(status)) {
+        throw new Error(`Role Agent session status is invalid: ${status}.`);
+    }
+    const existing = set.sessions[normalizedAgentId];
+    if (existing === undefined) {
+        throw new Error(`No Role session is recorded for Agent: ${normalizedAgentId}.`);
+    }
+    const timestamp = now.toISOString();
+    const updated = {
+        ...set,
+        sessions: {
+            ...set.sessions,
+            [normalizedAgentId]: { ...existing, status, updatedAt: timestamp }
+        },
+        updatedAt: timestamp
+    };
+    validateRoleSessionSet(updated);
+    return updated;
+}
+export function roleAgentSessionResumeMode(set, agentId) {
+    if (set === null)
+        return "new";
+    validateRoleSessionSet(set);
+    const session = set.sessions[requireSafeIdentity(agentId, "Agent id")];
+    return session === undefined ? "new" : "resume";
+}
+export function validateRoleSessionSet(set) {
+    if (set.schemaVersion !== 1)
+        throw new Error("Role session set schema version is invalid.");
+    normalizeOwner(set.owner);
+    requireSafeIdentity(set.activeAgentId, "Active Agent id");
+    for (const [agentId, session] of Object.entries(set.sessions)) {
+        validateRoleAgentSession(session, agentId);
+    }
+    requireText(set.updatedAt, "Role session set update timestamp");
+    return set;
+}
+export function validateRoleAgentSession(session, expectedAgentId = session.agentId) {
+    if (session.schemaVersion !== 1) {
+        throw new Error(`Role Agent session schema version is invalid: ${expectedAgentId}.`);
+    }
+    const agentId = requireSafeIdentity(session.agentId, "Agent id");
+    if (agentId !== expectedAgentId) {
+        throw new Error(`Role Agent session identity is inconsistent: ${expectedAgentId}.`);
+    }
+    requireText(session.adapterId, "Agent adapter id");
+    requireText(session.nativeSessionId, "Native session id");
+    if (session.policy !== "fixed" && session.policy !== "leader-controlled") {
+        throw new Error(`Role Agent session policy is invalid: ${agentId}.`);
+    }
+    if (!isAgentSessionStatus(session.status)) {
+        throw new Error(`Role Agent session status is invalid: ${agentId}.`);
+    }
+    requireText(session.createdAt, "Role Agent session creation timestamp");
+    requireText(session.updatedAt, "Role Agent session update timestamp");
+    return session;
+}
+function normalizeOwner(owner) {
+    const roleName = requireSafeIdentity(owner.roleName, "Role name");
+    return owner.scope === "global"
+        ? { scope: "global", roleName }
+        : {
+            scope: "task",
+            taskId: requireSafeIdentity(owner.taskId, "Task id"),
+            roleName
+        };
+}
+function isAgentSessionStatus(value) {
+    return ["reserved", "ready", "running", "stopped", "broken"].includes(value);
+}
+function requireSafeIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
+        || /[\/\\\0]/.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}

package/dist/executor/executorRegistry.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+/**
+ * Scheduler-to-tmux adapter. It retains only in-process prepared launch data;
+ * durable session identity remains owned by FileTaskStore.
+ */
+export class ExecutorRegistry {
+    planner;
+    tmux;
+    readiness;
+    #prepared = new Map();
+    constructor(planner, tmux, readiness = agentComposerReadinessProbe) {
+        this.planner = planner;
+        this.tmux = tmux;
+        this.readiness = readiness;
+    }
+    async prepareRoleSession(input) {
+        if (input.mode === "resume" && !hasText(input.nativeSessionId)) {
+            throw new Error("Role session resume requires a native session id.");
+        }
+        const planned = this.planner.plan(input);
+        this.tmux.ensureRoleWindow(input.taskId, planned.role, planned.launch);
+        const delivery = {
+            deliveryId: preparedDeliveryId(input),
+            taskId: input.taskId,
+            roleName: input.roleName,
+            agentId: input.agentId,
+            adapterId: input.adapterId,
+            mode: input.mode
+        };
+        this.#prepared.set(delivery.deliveryId, planned);
+        return delivery;
+    }
+    async waitUntilReady(delivery) {
+        const planned = this.requirePrepared(delivery);
+        this.tmux.waitUntilReady(delivery.taskId, delivery.roleName, this.readiness(delivery.adapterId));
+        return { prepared: delivery, session: planned.session };
+    }
+    async sendOnce(input) {
+        this.requirePrepared(input.delivery.prepared);
+        return this.tmux.sendRoleInputOnce(input.delivery.prepared.taskId, input.delivery.prepared.roleName, input.receiptId, input.text, this.readiness(input.delivery.prepared.adapterId));
+    }
+    async notifyOperatorInputOnce(input) {
+        if (this.tmux.probeRoleStatus("operator", input.roleName) !== "running") {
+            return "unavailable";
+        }
+        return this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, this.readiness(input.adapterId));
+    }
+    async inspectRole(input) {
+        return this.tmux.probeRoleStatus(input.taskId, input.roleName) === "running"
+            ? "present"
+            : "absent";
+    }
+    async findExistingReceipt(input) {
+        const planned = this.requirePrepared(input.delivery);
+        return this.tmux.hasDeliveryReceipt(input.delivery.taskId, input.delivery.roleName, input.receiptId) ? { prepared: input.delivery, session: planned.session } : null;
+    }
+    async stopTask(taskId) {
+        return this.tmux.stopTask(taskId);
+    }
+    requirePrepared(delivery) {
+        const planned = this.#prepared.get(delivery.deliveryId);
+        if (planned === undefined) {
+            throw new Error(`Role delivery is not prepared: ${delivery.deliveryId}.`);
+        }
+        return planned;
+    }
+}
+export function agentComposerReadinessProbe(adapterId) {
+    switch (adapterId) {
+        case "codex":
+            return (pane) => {
+                const content = pane.content.replace(/\r/g, "");
+                return livePane(pane)
+                    && !/Press enter to continue|select.*update|update selector/i.test(content)
+                    && content.includes("OpenAI Codex")
+                    && content.includes("/model to change")
+                    && /(?:^|\n)\s*›\s*(?:$|\S)/u.test(content);
+            };
+        case "claude":
+            return (pane) => livePane(pane)
+                && /(?:^|\n)\s*❯\s*(?:$|\S)/u.test(pane.content.replace(/\r/g, ""));
+        default:
+            throw new Error(`No tmux readiness probe is registered for Agent adapter: ${adapterId}.`);
+    }
+}
+function livePane(pane) {
+    return !pane.dead && pane.pid !== undefined && pane.currentCommand.trim().length > 0;
+}
+function preparedDeliveryId(input) {
+    return createHash("sha256").update(JSON.stringify([
+        input.taskId,
+        input.roleName,
+        input.agentId,
+        input.adapterId,
+        input.mode,
+        input.nativeSessionId ?? null
+    ])).digest("hex");
+}
+function hasText(value) {
+    return value !== undefined && value.trim().length > 0;
+}

package/dist/executor/fileRoleLaunchPlanner.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
+import { activeRoleAgentBinding } from "../role/role.js";
+import { resolveAgentAdapter } from "./agentAdapter.js";
+/** Builds managed native Agent launches from the authoritative Task records. */
+export class FileRoleLaunchPlanner {
+    home;
+    store;
+    #environment;
+    #createNativeSessionId;
+    #cliPath;
+    constructor(home, store, options = {}) {
+        this.home = home;
+        this.store = store;
+        this.#environment = options.environment ?? process.env;
+        this.#createNativeSessionId = options.createNativeSessionId ?? randomUUID;
+        this.#cliPath = options.cliPath
+            ?? fileURLToPath(new URL("../cli.js", import.meta.url));
+    }
+    plan(input) {
+        const task = this.store.getTask(input.taskId);
+        if (task === null)
+            throw new Error(`Task not found: ${input.taskId}.`);
+        if (task.status !== "active")
+            throw new Error(`Task is not active: ${input.taskId}.`);
+        const role = this.store.getRole(input.taskId, input.roleName);
+        if (role === null)
+            throw new Error(`Role not found: ${input.taskId}/${input.roleName}.`);
+        if (task.repositoryId !== undefined) {
+            const workspace = this.store.getRoleWorkspace(task.id, role.name);
+            if (task.cwd === undefined
+                || workspace === null
+                || workspace.repositoryId !== task.repositoryId
+                || workspace.path !== role.workspace) {
+                throw new Error(`Role workspace is not ready: ${input.taskId}/${input.roleName}.`);
+            }
+        }
+        return this.#compile(role, input, { scope: "task", taskId: task.id }, this.store.getRoleSession(task.id, role.name)?.nativeSessionId);
+    }
+    planGlobalRole(input) {
+        const role = this.store.getGlobalRole(input.roleName);
+        if (role === null)
+            throw new Error(`Global Role not found: ${input.roleName}.`);
+        return this.#compile(role, input, { scope: "global" }, this.store.getGlobalRoleSessionSet(role.name)?.sessions[role.activeAgentId]?.nativeSessionId);
+    }
+    #compile(role, input, owner, knownNativeSessionId) {
+        const binding = activeRoleAgentBinding(role);
+        if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
+            throw new Error(`Role launch identity changed: ${role.name}.`);
+        }
+        const configured = this.store.getConfiguredAgent(input.agentId);
+        if (configured === null)
+            throw new Error(`Configured Agent not found: ${input.agentId}.`);
+        if (configured.adapterId !== binding.adapterId) {
+            throw new Error(`Configured Agent adapter changed: ${input.agentId}.`);
+        }
+        const agent = configuredAgentToDefinition(configured);
+        const adapter = resolveAgentAdapter(binding.adapterId);
+        const compileInput = {
+            agent,
+            config: binding.config,
+            workspace: role.workspace,
+            systemPrompt: role.systemPrompt
+        };
+        if (input.mode === "resume"
+            && knownNativeSessionId !== undefined
+            && input.nativeSessionId !== knownNativeSessionId) {
+            throw new Error(`Role resume changed the fixed native session id: ${role.name}.`);
+        }
+        // A previous attempt may have persisted a preallocated/discovered ID
+        // before its receipt was committed. Reuse that fixed session rather than
+        // allocating a second native session for the same durable AgentRun.
+        const resumeNativeSessionId = input.mode === "resume"
+            ? requireText(input.nativeSessionId, "Native session id")
+            : knownNativeSessionId;
+        const launchMode = resumeNativeSessionId === undefined
+            ? "new"
+            : "resume";
+        const compiled = launchMode === "resume"
+            ? adapter.compileResume({
+                ...compileInput,
+                nativeSessionId: resumeNativeSessionId
+            })
+            : adapter.compileNew(compileInput);
+        let args = [...compiled.argv];
+        let session;
+        if (binding.adapterId === "codex") {
+            args = addCodexSessionNotify(args, launchMode, this.#cliPath);
+            session = launchMode === "resume"
+                ? readySession(input.agentId, binding.adapterId, resumeNativeSessionId)
+                : null;
+        }
+        else if (launchMode === "new") {
+            const nativeSessionId = requireText(this.#createNativeSessionId(), "Native session id");
+            args.push("--session-id", nativeSessionId);
+            session = readySession(input.agentId, binding.adapterId, nativeSessionId);
+        }
+        else {
+            session = readySession(input.agentId, binding.adapterId, resumeNativeSessionId);
+        }
+        return {
+            role: {
+                name: role.name,
+                workspace: role.workspace,
+                ...(owner.scope === "task" ? { status: role.status } : {})
+            },
+            launch: {
+                command: configured.command,
+                args,
+                env: {
+                    ...resolveAgentEnvironment(agent, this.#environment),
+                    YUI_HOME: resolve(this.home),
+                    YUI_SESSION_SCOPE: owner.scope,
+                    ...(owner.scope === "task" ? { YUI_TASK_ID: owner.taskId } : {}),
+                    YUI_ROLE: role.name,
+                    YUI_AGENT_ID: configured.id,
+                    YUI_ADAPTER_ID: configured.adapterId,
+                    YUI_WORKSPACE: role.workspace
+                }
+            },
+            session
+        };
+    }
+}
+/**
+ * Codex invokes this argv after each completed turn and appends one JSON
+ * payload. JSON arrays are valid TOML arrays for the managed config override.
+ */
+export function codexSessionNotifyConfig(cliPath) {
+    return `notify=${JSON.stringify([process.execPath, cliPath, "internal", "session-notify"])}`;
+}
+function addCodexSessionNotify(args, mode, cliPath) {
+    const managed = ["--config", codexSessionNotifyConfig(cliPath)];
+    if (mode === "new")
+        return [...args, ...managed];
+    if (args.length < 2 || args.at(-2) !== "resume") {
+        throw new Error("Codex resume launch shape is invalid.");
+    }
+    return [...args.slice(0, -2), ...managed, ...args.slice(-2)];
+}
+function readySession(agentId, adapterId, nativeSessionId) {
+    return {
+        agentId,
+        adapterId,
+        nativeSessionId: requireText(nativeSessionId, "Native session id"),
+        status: "ready"
+    };
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} is required.`);
+    }
+    return value.trim();
+}

package/dist/executor/launchPlan.js

@@ -0,0 +1,16 @@
+export function withYuiRunEnvironment(launch, yuiHome, role, run, nativeSessionId, nativeSessionRoot) {
+    return {
+        ...launch,
+        env: {
+            ...launch.env,
+            YUI_HOME: yuiHome,
+            YUI_TASK_ID: run.taskId,
+            YUI_ROLE: role.name,
+            YUI_AGENT_ID: role.activeAgentId ?? role.agent ?? "",
+            YUI_RUN_ID: run.id,
+            YUI_WORKSPACE: role.workspace,
+            ...(nativeSessionRoot === undefined ? {} : { YUI_NATIVE_SESSION_ROOT: nativeSessionRoot }),
+            ...(nativeSessionId === undefined ? {} : { YUI_NATIVE_SESSION_ID: nativeSessionId })
+        }
+    };
+}