@zq-silk/yui 0.0.0

package/dist/context/dispatchContext.js

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataError } from "../errors/cliError.js";
+/** Compatibility entry point used by the restored Task workflow. */
+export function compileDispatchInput(_store, taskId, role, input) {
+    const configuredSkillBodies = readConfiguredSkills(role.skills ?? []);
+    return buildRoleContext({ taskId, role, input, configuredSkillBodies });
+}
+export function buildRoleContext(context) {
+    return context.role.name === "leader"
+        ? buildLeaderContext(context)
+        : buildWorkerContext(context);
+}
+export function buildLeaderContext(context) {
+    return renderDispatchContext("leader", context);
+}
+export function buildWorkerContext(context) {
+    return renderDispatchContext("worker", context);
+}
+function renderDispatchContext(kind, context) {
+    const profile = context.role;
+    const profileLines = [
+        `Task: ${context.taskId}`,
+        `Role: ${profile.name}`,
+        `Active Agent: ${profile.activeAgentId}`,
+        profile.description === undefined ? null : `Description: ${profile.description}`,
+        ...(profile.responsibilities ?? []).map((item) => `Responsibility: ${item}`),
+        ...(profile.constraints ?? []).map((item) => `Constraint: ${item}`),
+        profile.expectedOutput === undefined ? null : `Expected output: ${profile.expectedOutput}`,
+        profile.systemPrompt === undefined ? null : `Role instruction: ${profile.systemPrompt}`,
+        profile.skills === undefined || profile.skills.length === 0
+            ? null
+            : `Configured role skills: ${profile.skills.join(", ")}`
+    ].filter((line) => line !== null);
+    return [
+        readSystemSkill(kind),
+        profileLines.join("\n"),
+        ...(context.configuredSkillBodies ?? []).map((body) => body.trim()).filter(Boolean),
+        "Yui dispatch:",
+        requireText(context.input, "dispatch input")
+    ].filter(Boolean).join("\n\n");
+}
+function readConfiguredSkills(skills) {
+    const yuiHome = process.env.YUI_HOME;
+    if (skills.length === 0)
+        return [];
+    if (yuiHome === undefined) {
+        throw dataError("YUI_HOME is required to load configured Role skills.");
+    }
+    return skills.map((skill) => {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(skill)) {
+            throw dataError(`Invalid configured Skill id: ${skill}`);
+        }
+        try {
+            return readFileSync(join(yuiHome, "skills", skill, "SKILL.md"), "utf8").trim();
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                throw dataError(`Configured Skill not found: ${skill}`);
+            }
+            throw error;
+        }
+    });
+}
+function readSystemSkill(kind) {
+    return readFileSync(new URL(`../../skills/yui-${kind}/SKILL.md`, import.meta.url), "utf8").trim();
+}
+function requireText(value, label) {
+    const normalized = value.trim();
+    if (normalized.length === 0 || normalized.includes("\0")) {
+        throw new Error(`${label} is required.`);
+    }
+    return normalized;
+}

package/dist/controller/clientRuntime.js

@@ -0,0 +1,215 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { callController } from "../core/controllerClient.js";
+const STARTUP_TIMEOUT_MS = 5_000;
+const POLL_INTERVAL_MS = 50;
+/** Starts the per-home FileTask Controller on demand and waits until callable. */
+export async function ensureFileTaskController(home, options = {}) {
+    const call = options.call ?? callController;
+    try {
+        return await call(home, "controller.status", {});
+    }
+    catch (error) {
+        if (!isUnavailable(error))
+            throw error;
+    }
+    const timeoutMs = positive(options.startupTimeoutMs, STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+    const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
+    const spawnController = options.spawnController ?? spawnDetachedFileTaskController;
+    spawnController(home, { ...process.env, ...options.environment, YUI_HOME: home });
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            return await call(home, "controller.status", {});
+        }
+        catch (error) {
+            if (!isUnavailable(error))
+                throw error;
+            if (Date.now() >= deadline) {
+                throw new Error(`Controller did not become ready within ${timeoutMs} ms.`, { cause: error });
+            }
+            await delay(pollMs);
+        }
+    }
+}
+function spawnDetachedFileTaskController(home, environment) {
+    const child = spawn(process.execPath, [fileURLToPath(new URL("./controllerMain.js", import.meta.url))], {
+        env: environment,
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+}
+/** Restarts only the per-home Controller process; managed tmux sessions remain untouched. */
+export async function restartFileTaskController(home, options = {}) {
+    const call = options.call ?? callController;
+    const timeoutMs = positive(options.startupTimeoutMs, STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+    const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
+    const current = await readOptionalControllerStatus(home, call);
+    const previousPid = controllerPid(current);
+    if (controllerRunning(current)) {
+        await callFileTaskController(home, "controller.stop", {}, options);
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const status = await readOptionalControllerStatus(home, call);
+            if (!controllerRunning(status))
+                break;
+            if (Date.now() >= deadline) {
+                throw new Error(`Controller did not stop within ${timeoutMs} ms.`);
+            }
+            await delay(pollMs);
+        }
+    }
+    const started = await ensureFileTaskController(home, options);
+    const pid = controllerPid(started);
+    return {
+        restarted: true,
+        ...(previousPid === undefined ? {} : { previousPid }),
+        ...(pid === undefined ? {} : { pid })
+    };
+}
+export async function callFileTaskController(home, method, params = {}, options = {}) {
+    const call = options.call ?? callController;
+    if (method === "controller.status" || method === "controller.stop") {
+        try {
+            return await call(home, method, params);
+        }
+        catch (error) {
+            if (!isUnavailable(error))
+                throw error;
+            return method === "controller.status"
+                ? { running: false }
+                : { stopped: false, alreadyStopped: true };
+        }
+    }
+    await ensureFileTaskController(home, options);
+    return call(home, method, params);
+}
+/** Foreground command bridge. It never reads or writes Agent terminal bytes. */
+export class FileTaskWorkflowRuntime {
+    home;
+    store;
+    schedulerStore;
+    planner;
+    tmux;
+    workspacePreparer;
+    clientOptions;
+    constructor(home, store, schedulerStore, planner, tmux, workspacePreparer, clientOptions = {}) {
+        this.home = home;
+        this.store = store;
+        this.schedulerStore = schedulerStore;
+        this.planner = planner;
+        this.tmux = tmux;
+        this.workspacePreparer = workspacePreparer;
+        this.clientOptions = clientOptions;
+    }
+    notifyStateChanged(taskId) {
+        void this.#prepareAndScan(taskId).catch(this.clientOptions.onError ?? (() => { }));
+    }
+    reconcileTask(taskId) {
+        void this.#prepareAndScan(taskId).catch(this.clientOptions.onError ?? (() => { }));
+    }
+    prepareTaskRoleEnter(input) {
+        const role = this.store.getRole(input.taskId, input.roleName);
+        if (role === null)
+            throw new Error(`Role not found: ${input.taskId}/${input.roleName}.`);
+        const session = this.store.getRoleSession(input.taskId, input.roleName);
+        const mode = session?.nativeSessionId === undefined ? "new" : "resume";
+        const planned = this.planner.plan({
+            taskId: input.taskId,
+            roleName: input.roleName,
+            agentId: role.activeAgentId,
+            adapterId: role.agentBindings[role.activeAgentId].adapterId,
+            mode,
+            ...(mode === "resume" ? { nativeSessionId: session.nativeSessionId } : {})
+        });
+        this.tmux.ensureRoleWindow(input.taskId, planned.role, planned.launch);
+        if (planned.session?.nativeSessionId !== undefined) {
+            this.schedulerStore.recordRuntimeNativeSession({
+                taskId: input.taskId,
+                roleName: input.roleName,
+                agentId: planned.session.agentId,
+                adapterId: planned.session.adapterId,
+                nativeSessionId: planned.session.nativeSessionId
+            });
+        }
+    }
+    inspectTaskRolePanes(taskId) {
+        return this.tmux.inspectTaskRolePanes(taskId);
+    }
+    prepareGlobalRoleEnter(roleName, tmuxTaskId = "operator") {
+        const role = this.store.getGlobalRole(roleName);
+        if (role === null)
+            throw new Error(`Global Role not found: ${roleName}.`);
+        const sessionSet = this.store.getGlobalRoleSessionSet(roleName);
+        const session = sessionSet?.sessions[role.activeAgentId];
+        const binding = role.agentBindings[role.activeAgentId];
+        const mode = session?.nativeSessionId === undefined ? "new" : "resume";
+        const planned = this.planner.planGlobalRole({
+            roleName,
+            agentId: role.activeAgentId,
+            adapterId: binding.adapterId,
+            mode,
+            ...(mode === "resume" ? { nativeSessionId: session.nativeSessionId } : {})
+        });
+        this.tmux.ensureRoleWindow(tmuxTaskId, planned.role, planned.launch);
+        if (planned.session?.nativeSessionId !== undefined) {
+            this.schedulerStore.recordGlobalRuntimeNativeSession({
+                roleName,
+                agentId: planned.session.agentId,
+                adapterId: planned.session.adapterId,
+                nativeSessionId: planned.session.nativeSessionId
+            });
+        }
+    }
+    async #prepareAndScan(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task?.repositoryId !== undefined
+            && task.status === "active"
+            && this.workspacePreparer !== undefined) {
+            await this.workspacePreparer.prepareTaskWorkspace(taskId);
+        }
+        await callFileTaskController(this.home, "scheduler.scan", {}, this.clientOptions);
+    }
+}
+function isUnavailable(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    const code = error.code;
+    return code === "CONTROLLER_UNAVAILABLE"
+        || code === "CONTROLLER_DISCOVERY_INVALID"
+        || code === "INVALID_RESPONSE";
+}
+async function readOptionalControllerStatus(home, call) {
+    try {
+        return await call(home, "controller.status", {});
+    }
+    catch (error) {
+        if (isUnavailable(error))
+            return null;
+        throw error;
+    }
+}
+function controllerRunning(value) {
+    return isJsonRecord(value) && value.running === true;
+}
+function controllerPid(value) {
+    if (!isJsonRecord(value))
+        return undefined;
+    return Number.isSafeInteger(value.pid) && value.pid > 0
+        ? value.pid
+        : undefined;
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function positive(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError(`${label} must be a positive integer.`);
+    }
+    return resolved;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/controller/controller.js

@@ -0,0 +1,158 @@
+import { reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
+import { processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
+import { processActiveRoleRunDeliveries } from "../scheduler/activeRoleRunDelivery.js";
+import { stopArchivedTaskRuntimes } from "../scheduler/archivedTaskRuntime.js";
+import { reconcileExitedRoleRuns } from "../scheduler/roleRunLiveness.js";
+import { processOperatorInputNotifications } from "../scheduler/operatorInputNotificationProcessor.js";
+import { startControllerServer } from "../core/controllerServer.js";
+const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
+/**
+ * Runs one lean scheduler pass. Liveness always precedes wakeup processing so
+ * an exited busy Leader is cleared and reconsidered in the same pass.
+ */
+export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer) {
+    await workspacePreparer?.prepareActiveTaskWorkspaces();
+    const stoppedArchivedTaskIds = await stopArchivedTaskRuntimes(store, delivery, now);
+    await workspacePreparer?.cleanupArchivedTaskWorkspaces();
+    const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now);
+    const failedRunIds = await reconcileExitedRoleRuns(store, delivery, now);
+    const autoResolvedInputs = store.resolveExpiredInputRecommendations(now);
+    const wakeups = await processLeaderWakeups(store, delivery, now);
+    const inputNotifications = await processOperatorInputNotifications(store, delivery);
+    return {
+        stoppedArchivedTaskIds,
+        activeRunDeliveries,
+        failedRunIds,
+        wakeups,
+        inputNotifications,
+        autoResolvedInputs
+    };
+}
+/**
+ * Single-owner periodic runtime for FileTaskStore-backed scheduling. Concurrent
+ * pump requests coalesce into one follow-up pass; scheduler effects never
+ * overlap. There are deliberately no filesystem watchers or derived indexes.
+ */
+export class FileTaskController {
+    store;
+    delivery;
+    #intervalMs;
+    #now;
+    #onError;
+    #workspacePreparer;
+    #timer;
+    #current;
+    #rerunRequested = false;
+    #stopped = false;
+    constructor(store, delivery, options = {}) {
+        this.store = store;
+        this.delivery = delivery;
+        this.#intervalMs = positiveInteger(options.intervalMs, DEFAULT_RECONCILIATION_INTERVAL_MS, "Controller reconciliation interval");
+        this.#now = options.now ?? (() => new Date());
+        this.#onError = options.onError ?? (() => { });
+        this.#workspacePreparer = options.workspacePreparer;
+    }
+    get reconciliationIntervalMs() {
+        return this.#intervalMs;
+    }
+    start() {
+        if (this.#timer !== undefined)
+            return;
+        this.#stopped = false;
+        void this.pump().catch(this.#onError);
+        this.#timer = setInterval(() => {
+            void this.pump().catch(this.#onError);
+        }, this.#intervalMs);
+        this.#timer.unref();
+    }
+    stop() {
+        this.#stopped = true;
+        if (this.#timer !== undefined) {
+            clearInterval(this.#timer);
+            this.#timer = undefined;
+        }
+    }
+    pump() {
+        if (this.#stopped) {
+            return Promise.reject(new Error("Controller runtime is stopped."));
+        }
+        if (this.#current !== undefined) {
+            this.#rerunRequested = true;
+            return this.#current;
+        }
+        const running = this.#runCoalesced();
+        this.#current = running;
+        void running.finally(() => {
+            if (this.#current === running)
+                this.#current = undefined;
+        }).catch(() => { });
+        return running;
+    }
+    async #runCoalesced() {
+        let result = {
+            stoppedArchivedTaskIds: [],
+            activeRunDeliveries: [],
+            failedRunIds: [],
+            wakeups: [],
+            inputNotifications: [],
+            autoResolvedInputs: []
+        };
+        do {
+            this.#rerunRequested = false;
+            result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer);
+        } while (this.#rerunRequested && !this.#stopped);
+        return result;
+    }
+}
+/**
+ * Starts the single private Unix-socket Controller for one YUI_HOME. The
+ * shared server owns status/stop and rejects a second live instance; this
+ * layer adds only scheduler.scan plus an optional command dispatcher.
+ */
+export async function startFileTaskController(home, store, delivery, dispatcher, options = {}) {
+    const runtime = new FileTaskController(store, delivery, options);
+    const server = await startControllerServer(home, async (method, params) => {
+        if (method === "scheduler.scan") {
+            if (!isEmptyJsonObject(params)) {
+                throw controllerApplicationError("INVALID_PARAMS", "scheduler.scan params are invalid.");
+            }
+            return schedulerResultJson(await runtime.pump());
+        }
+        if (dispatcher === undefined) {
+            throw controllerApplicationError("METHOD_NOT_FOUND", "Controller method was not found.");
+        }
+        return dispatcher(method, params);
+    });
+    runtime.start();
+    const closed = server.closed.finally(() => runtime.stop());
+    return {
+        runtime,
+        server,
+        closed,
+        close: async () => {
+            runtime.stop();
+            await server.close();
+        }
+    };
+}
+function positiveInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError(`${label} must be a positive integer`);
+    }
+    return resolved;
+}
+function schedulerResultJson(result) {
+    return JSON.parse(JSON.stringify(result));
+}
+function isEmptyJsonObject(value) {
+    return typeof value === "object"
+        && value !== null
+        && !Array.isArray(value)
+        && Object.keys(value).length === 0;
+}
+function controllerApplicationError(code, message) {
+    const error = Object.assign(new Error(message), { code });
+    error.name = "CoreApplicationError";
+    return error;
+}

package/dist/controller/controllerMain.js

@@ -0,0 +1,37 @@
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveYuiHome } from "../storage/taskStore.js";
+import { startFileTaskControllerRuntime } from "./runtime.js";
+export async function runFileTaskControllerProcess(environment = process.env) {
+    const home = resolveYuiHome(environment);
+    const controller = await startFileTaskControllerRuntime(home, {
+        environment,
+        onError: (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`Controller scheduler error: ${message}\n`);
+        }
+    });
+    const stop = () => {
+        void controller.close().catch(() => undefined);
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        await controller.closed;
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+    }
+}
+function isEntrypoint() {
+    return process.argv[1] !== undefined
+        && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+if (isEntrypoint()) {
+    void runFileTaskControllerProcess().catch((error) => {
+        const message = error instanceof Error ? error.message : "Controller failed to start.";
+        process.stderr.write(`Error: ${message}\n`);
+        process.exitCode = 1;
+    });
+}