@zq-silk/yui 0.6.5 → 0.6.7

package/dist/cli/commandCatalog.js

@@ -849,7 +849,7 @@ export const ROOT_COMMAND = buildNode({
             sections: [{
                     id: "lifecycle",
                     title: "Commands",
-                    entries: ["status", "cleanup", "identity", "stop", "restart"]
+                    entries: ["status", "cleanup", "identity", "live-identity", "stop", "restart"]
                 }],
             children: [
                 {
@@ -869,6 +869,11 @@ export const ROOT_COMMAND = buildNode({
                     summary: "Read the stable runtime identity receipt (build, backend, worker).",
                     hidden: true
                 },
+                {
+                    name: "live-identity",
+                    summary: "Read the authenticated live Controller launch identity.",
+                    hidden: true
+                },
                 { name: "stop", summary: "Stop the Controller." },
                 { name: "restart", summary: "Restart internal services without stopping tmux sessions." }
             ]

package/dist/cli/invocationRouter.js

@@ -33,7 +33,8 @@ function resolveExecutionPath(args) {
         const internalExecutable = child !== undefined && ((node === ROOT_COMMAND && child.name === "internal")
             || (node.path.join(" ") === "yui completion" && child.name === "candidates")
             || (node.path.join(" ") === "yui task run" && child.name === "checkpoint")
-            || (node.path.join(" ") === "yui controller" && child.name === "identity"));
+            || (node.path.join(" ") === "yui controller"
+                && (child.name === "identity" || child.name === "live-identity")));
         if (child === undefined || (child.hidden && !internalExecutable)) {
             if (node.kind === "hybrid" && node.acceptsArguments)
                 break;

package/dist/cli/updatePorts.js

@@ -261,10 +261,12 @@ export function createUpdatePorts(environment, spawn = spawnSync, stagingRoot =
             }
         },
         // `runUpdate` is intentionally synchronous because the npm/staged-binary
-        // ports use spawnSync. Keep Controller ownership in this same owner by
-        // using the CLI's structured lifecycle commands; tests can replace these
-        // seams with deterministic fakes without touching a real Controller.
+        // ports use spawnSync. A short-lived child owns the async, exactly fenced
+        // reconciliation first; lifecycle capture then uses structured live
+        // Controller commands. Tests can replace these seams with deterministic
+        // fakes without touching a real Controller.
         controllerStatus(home) {
+            reconcileControllerResourcesForUpdate(home, environment, spawn);
             return readControllerLifecycle(home, environment, spawn);
         },
         stopController(home, expectedPid) {
@@ -285,6 +287,7 @@ export function createUpdatePorts(environment, spawn = spawnSync, stagingRoot =
 }
 const UPDATE_CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
 const UPDATE_CLIENT_RUNTIME_PATH = fileURLToPath(new URL("../controller/clientRuntime.js", import.meta.url));
+const UPDATE_CONTROLLER_RECONCILIATION_PATH = fileURLToPath(new URL("../controller/updateReconciliation.js", import.meta.url));
 /**
  * Capture running state plus an authenticated exact process identity before
  * stopping. Public `controller status` is an inventory and intentionally
@@ -330,18 +333,18 @@ function readControllerLifecycle(home, environment, spawn, cliBinary) {
         if (current !== undefined) {
             throw new Error("Controller inventory is current but has no process proof; treating ownership as unknown-active.");
         }
-        return proveControllerAbsent(home, environment, spawn);
+        return proveControllerAbsent(home, environment, spawn, cliBinary);
     }
-    const identity = parseControllerIdentity(runControllerCommand(home, environment, spawn, "identity", cliBinary));
+    const identity = parseControllerIdentity(runControllerCommand(home, environment, spawn, "live-identity", cliBinary));
     return {
         running: true,
         ...(isPositivePid(processInfo.pid) ? { pid: processInfo.pid } : {}),
         identity
     };
 }
-function proveControllerAbsent(home, environment, spawn) {
+function proveControllerAbsent(home, environment, spawn, cliBinary) {
     try {
-        runControllerCommand(home, environment, spawn, "identity");
+        runControllerCommand(home, environment, spawn, "live-identity", cliBinary);
     }
     catch (error) {
         if (controllerErrorCode(error) === "CONTROLLER_NOT_RUNNING") {
@@ -349,7 +352,7 @@ function proveControllerAbsent(home, environment, spawn) {
         }
         throw new Error(`Controller absence could not be authenticated: ${messageOf(error)}`, { cause: error });
     }
-    throw new Error("Controller identity is reachable but inventory is currentless; treating ownership as unknown-active.");
+    throw new Error("A live Controller identity is reachable but inventory is currentless; treating ownership as unknown-active.");
 }
 function stopControllerForUpdate(home, expectedPid, environment, spawn) {
     // Parent update owns this lifecycle boundary. Invoke the runtime client
@@ -464,7 +467,7 @@ function restartControllerForUpdate(home, environment, spawn, activatedBinary, a
     const replacementPid = parseReplacementPid(restart.data);
     let identityFailure;
     try {
-        const identity = parseControllerIdentity(runControllerCommand(home, environment, spawn, "identity", activatedBinary));
+        const identity = parseControllerIdentity(runControllerCommand(home, environment, spawn, "live-identity", activatedBinary));
         assertActivatedControllerIdentity(identity, activatedBinary, activatedVersion);
     }
     catch (error) {
@@ -586,6 +589,57 @@ function runControllerCommand(home, environment, spawn, method, cliBinary) {
     }
     return parsed.data;
 }
+function reconcileControllerResourcesForUpdate(home, environment, spawn) {
+    const helper = [
+        "const values = process.argv.slice(1);",
+        "const home = values.pop();",
+        "const reconciliationModule = values.pop();",
+        "(async () => {",
+        "  const { reconcileControllerResourcesForUpdate } = await import(reconciliationModule);",
+        "  const data = await reconcileControllerResourcesForUpdate(home, process.env);",
+        "  process.stdout.write(JSON.stringify({ ok: true, data }));",
+        "})().catch((error) => {",
+        "  const message = error instanceof Error ? error.message : String(error);",
+        "  process.stderr.write(JSON.stringify({ ok: false, code: 'RUNTIME_ERROR', message }));",
+        "  process.exitCode = 5;",
+        "});"
+    ].join(" ");
+    const result = spawn(process.execPath, ["-e", helper, UPDATE_CONTROLLER_RECONCILIATION_PATH, home], { cwd: process.cwd(), env: { ...environment, YUI_HOME: home }, shell: false });
+    if (result.error !== undefined || result.status !== 0) {
+        const detail = structuredErrorMessage(result) ?? result.stderr.toString("utf8").trim();
+        throw new Error(`Controller reconciliation failed (exit ${result.status ?? "null"})${detail.length === 0 ? "." : `: ${detail}`}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout.toString("utf8"));
+    }
+    catch (error) {
+        throw new Error("Controller reconciliation returned an invalid structured result.", {
+            cause: error
+        });
+    }
+    if (!isRecord(parsed)
+        || parsed.ok !== true
+        || !isRecord(parsed.data)
+        || !Array.isArray(parsed.data.cleaned)
+        || parsed.data.cleaned.some((id) => typeof id !== "string")) {
+        throw new Error("Controller reconciliation returned an invalid structured result.");
+    }
+}
+function structuredErrorMessage(result) {
+    for (const buffer of [result.stderr, result.stdout]) {
+        try {
+            const value = JSON.parse(buffer.toString("utf8"));
+            if (isRecord(value) && typeof value.message === "string" && value.message.length > 0) {
+                return value.message;
+            }
+        }
+        catch {
+            // Fall back to the child's raw stderr below.
+        }
+    }
+    return undefined;
+}
 function parseControllerIdentity(value) {
     if (typeof value.executablePath !== "string"
         || value.executablePath.length === 0

package/dist/cli.js

@@ -301,6 +301,29 @@ export async function main() {
     }
     if (args[0] === "controller") {
         const method = args[1];
+        if (method === "live-identity" && args.length === 2) {
+            try {
+                const identity = await callController(home, "controller.identity", {});
+                emit("", false, identity);
+            }
+            catch (error) {
+                if (!(error instanceof ControllerClientError))
+                    throw error;
+                if (jsonOutput) {
+                    process.stderr.write(`${JSON.stringify({
+                        ok: false,
+                        code: error.code,
+                        message: error.message,
+                        details: {}
+                    })}\n`);
+                }
+                else {
+                    process.stderr.write(`RUNTIME_ERROR: ${error.message}\n`);
+                }
+                process.exitCode = 5;
+            }
+            return;
+        }
         if (method === "identity" && args.length === 2) {
             // Issue 02: the stable, read-only runtime identity receipt. It survives
             // a Controller stop and answers build ID, package digest, backend, and

package/dist/controller/agentRuntimeObserver.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+const DEFAULT_MAX_CONCURRENT_SAMPLES = 8;
+const MAX_CONCURRENT_SAMPLES = 64;
 /**
  * Controller-owned, provider-independent sampler. Drivers own source parsing;
  * this component owns active-Run discovery, cursor lifetime, canonical event
@@ -11,11 +13,13 @@ export class AgentRuntimeObserver {
     inbox;
     drivers;
     #states = new Map();
+    #maxConcurrentSamples;
     #sequence = 0;
-    constructor(store, inbox, drivers = builtinAgentDriverRegistry()) {
+    constructor(store, inbox, drivers = builtinAgentDriverRegistry(), options = {}) {
         this.store = store;
         this.inbox = inbox;
         this.drivers = drivers;
+        this.#maxConcurrentSamples = sampleConcurrency(options.maxConcurrentSamples);
     }
     async sample(now = new Date()) {
         const active = this.activeSources();
@@ -25,7 +29,9 @@ export class AgentRuntimeObserver {
                 this.#states.delete(key);
         }
         const dirty = new Set();
-        await Promise.all(active.map(async ({ key, fence, source, freshSession, persistedState }) => {
+        const sequenceBase = this.#sequence;
+        this.#sequence += active.length;
+        await forEachConcurrent(active, this.#maxConcurrentSamples, async ({ key, fence, source, freshSession, persistedState }, index) => {
             const existingState = this.#states.get(key);
             // Cursor state is intentionally process-local, but the latest canonical
             // usage/activity baseline is durable. Rehydrate it after Controller
@@ -49,7 +55,10 @@ export class AgentRuntimeObserver {
             }
             state.cursor = sample.cursor;
             const at = now.toISOString();
-            const sequence = this.#sequence++;
+            // Reserve sequence numbers in source-key order before sampling. Provider
+            // latency can change completion order without changing observation
+            // identity or the canonical sequence assigned to a source.
+            const sequence = sequenceBase + index;
             if (existingState === undefined && freshSession && state.usage === undefined) {
                 const zero = Object.freeze({ inputTokens: 0, outputTokens: 0 });
                 this.inbox.enqueueObservation(createRuntimeObservation({
@@ -114,28 +123,52 @@ export class AgentRuntimeObserver {
             if (sample.activityId !== undefined)
                 state.activityId = sample.activityId;
             this.#states.set(key, state);
-        }));
-        return Object.freeze([...dirty].sort());
+        });
+        return Object.freeze([...dirty].sort(numericCompare));
     }
     activeSources() {
         const result = [];
-        for (const task of this.store.listTasks()) {
-            if (task.status !== "active")
-                continue;
-            const observations = this.store.listEvents(task.id)
-                .map(runtimeObservationFromTaskEvent)
-                .filter((value) => value !== null);
+        const indexedTaskIds = this.store.listActiveTaskIds?.();
+        // FileTaskStore remains a development/compatibility fallback. The normal
+        // Controller store is SQLite and must discover only its indexed hot set.
+        const activeTasks = indexedTaskIds === undefined
+            ? this.store.listTasks().filter((task) => task.status === "active")
+            : [...new Set(indexedTaskIds)]
+                .sort(numericCompare)
+                .map((taskId) => this.store.getTask(taskId))
+                .filter((task) => (task !== null && task.status === "active"));
+        for (const task of activeTasks) {
+            // A Task still incurs one O(E) event projection. Group those observations
+            // by Run and sort each group once so every active Run can reuse the same
+            // ordered slice instead of repeatedly filtering/sorting all E events.
+            const observationsByRunId = new Map();
+            for (const event of this.store.listEvents(task.id)) {
+                const observation = runtimeObservationFromTaskEvent(event);
+                const runId = observation?.fence.runId;
+                if (observation === null || runId === undefined)
+                    continue;
+                const grouped = observationsByRunId.get(runId);
+                if (grouped === undefined) {
+                    observationsByRunId.set(runId, [observation]);
+                }
+                else {
+                    grouped.push(observation);
+                }
+            }
+            for (const observations of observationsByRunId.values()) {
+                observations.sort(compareObservations);
+            }
             for (const run of this.store.listAgentRuns(task.id)) {
                 if (run.status !== "active"
                     || this.store.getActiveAgentRun(task.id, run.roleName)?.id !== run.id)
                     continue;
+                const observations = observationsByRunId.get(run.id) ?? [];
                 const accepted = observations
                     .filter((observation) => observation.kind === "turn.accepted"
                     && observation.fence.runId === run.id
                     && observation.fence.roleName === run.roleName
                     && observation.fence.agentId === run.effective.agentId
                     && observation.payload.observerSource !== undefined)
-                    .sort(compareObservations)
                     .at(-1);
                 const source = accepted?.payload.observerSource;
                 if (accepted === undefined || source === undefined
@@ -150,19 +183,23 @@ export class AgentRuntimeObserver {
                 }
                 const fence = accepted.fence;
                 const exact = observations
-                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence))
-                    .sort(compareObservations);
+                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence));
                 const persistedUsage = exact.filter((observation) => (observation.kind === "activity.observed"
                     && observation.payload.usage !== undefined)).at(-1);
                 const persistedHealth = exact.filter((observation) => (observation.kind === "observer.health"
                     && observation.payload.sourceId === source.sourceId)).at(-1);
                 result.push(Object.freeze({
                     key: JSON.stringify([
+                        fence.taskId,
+                        fence.roleName,
+                        fence.runId,
+                        fence.agentId,
                         fence.driverId,
+                        fence.launchId,
                         fence.sessionGenerationId,
                         fence.nativeSessionId,
                         fence.nativeTurnId,
-                        fence.runId,
+                        fence.receiptId,
                         source.sourceId
                     ]),
                     fence,
@@ -187,8 +224,31 @@ export class AgentRuntimeObserver {
                 }));
             }
         }
-        return result;
+        return Object.freeze(result.sort((left, right) => numericCompare(left.key, right.key)));
+    }
+}
+async function forEachConcurrent(values, limit, visit) {
+    let nextIndex = 0;
+    const workers = Math.min(limit, values.length);
+    await Promise.all(Array.from({ length: workers }, async () => {
+        while (nextIndex < values.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            await visit(values[index], index);
+        }
+    }));
+}
+function sampleConcurrency(value) {
+    const resolved = value ?? DEFAULT_MAX_CONCURRENT_SAMPLES;
+    if (!Number.isSafeInteger(resolved)
+        || resolved < 1
+        || resolved > MAX_CONCURRENT_SAMPLES) {
+        throw new Error(`Agent runtime observer maxConcurrentSamples must be between 1 and ${MAX_CONCURRENT_SAMPLES}.`);
     }
+    return resolved;
+}
+function numericCompare(left, right) {
+    return left.localeCompare(right, undefined, { numeric: true });
 }
 function compareObservations(left, right) {
     return left.receivedAt.localeCompare(right.receivedAt)