@zq-silk/yui 0.11.3 → 0.12.1

package/dist/context/sessionContextBudget.js

@@ -1,71 +0,0 @@
-import { resolveContextBudget } from "../config/yuiConfig.js";
-import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-export function evaluateSessionContextBudget(events, session, configured) {
-    const budget = resolveContextBudget(configured);
-    const peak = observedPeakInputTokens(events, session);
-    const state = peak >= budget.hardTokens
-        ? "hard"
-        : peak >= budget.softTokens
-            ? "soft"
-            : "within";
-    return Object.freeze({ state, peakTokens: peak, budget });
-}
-/**
- * Largest per-request input peak observed for one Session generation. Usage
- * observations carry cumulative session totals; consecutive deltas bound the
- * per-request input of the window between them. The first observation for a
- * generation is treated as one full request so a long-lived resumed Session
- * that was only sampled late still counts its inherited context.
- */
-export function observedPeakInputTokens(events, session) {
-    let previous = 0;
-    let peak = 0;
-    for (const event of events) {
-        const observation = runtimeObservationFromTaskEvent(event);
-        if (observation === null)
-            continue;
-        if (!matchesSession(observation.fence, session))
-            continue;
-        const usage = usageTotal(observation.payload.usage);
-        if (usage === null)
-            continue;
-        const delta = Math.max(0, usage - previous);
-        if (delta > peak)
-            peak = delta;
-        previous = usage;
-    }
-    return peak;
-}
-function matchesSession(fence, session) {
-    if (fence.taskId !== undefined && fence.taskId !== session.taskId)
-        return false;
-    if (fence.roleName !== session.roleName)
-        return false;
-    if (session.nativeSessionId !== undefined
-        && fence.nativeSessionId !== undefined
-        && fence.nativeSessionId !== session.nativeSessionId) {
-        return false;
-    }
-    if (session.launchId !== undefined
-        && fence.launchId !== undefined
-        && fence.launchId !== session.launchId) {
-        return false;
-    }
-    return true;
-}
-function usageTotal(usage) {
-    if (typeof usage !== "object" || usage === null || Array.isArray(usage))
-        return null;
-    const record = usage;
-    const inputTokens = integer(record.inputTokens);
-    if (inputTokens === null)
-        return null;
-    // RuntimeUsageSnapshot.inputTokens is the normalized processed input total.
-    // cachedInputTokens is an informational breakdown of that total, matching
-    // runtimeProjection and the Driver documentation; adding it again would
-    // fabricate context pressure and trigger premature Session rollover.
-    return inputTokens;
-}
-function integer(value) {
-    return Number.isSafeInteger(value) && value >= 0 ? value : null;
-}

package/dist/lifecycle/contextBudgetRollover.js

@@ -1,81 +0,0 @@
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
-import { validateRoleSessionSet } from "../executor/agentExecutor.js";
-import { createTaskEvent } from "../event/taskEvent.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-/**
- * Issue 04 (context token budget): retires one native Session generation that
- * crossed the hard context budget so the next Leader wake starts a fresh
- * generation. This is a controlled rollover, not a failure: the durable Task
- * records are the checkpoint, the bounded context snapshot re-establishes
- * working context for the new generation, and the retired Session is kept in
- * history as `stopped` with an auditable event. The Controller separately
- * owns verified process cleanup through the runtime cleanup lane.
- */
-export const CONTEXT_BUDGET_ROLLOVER_REASON = "context-budget-hard-limit";
-export function rolloverTaskRoleSessionForContextBudget(store, taskId, roleName, evidence, now) {
-    const task = store.getTask(taskId);
-    if (task === null)
-        throw new Error(`Task not found: ${taskId}.`);
-    if (task.status !== "active") {
-        throw new Error(`Task is not active: ${task.id}/${task.status}.`);
-    }
-    const role = store.getRole(task.id, roleName);
-    if (role === null)
-        throw new Error(`Role not found: ${task.id}/${roleName}.`);
-    const set = store.getTaskRoleSessionSet(task.id, role.name);
-    const current = set?.sessions[set.activeAgentId];
-    if (set === null || set === undefined || current === undefined) {
-        // No live generation to retire; the caller can launch fresh directly.
-        return null;
-    }
-    const timestamp = now.toISOString();
-    const reason = `${CONTEXT_BUDGET_ROLLOVER_REASON} (peak ${evidence.peakTokens} >= hard ${evidence.hardTokens} tokens)`;
-    enqueueWork(store, runtimeLifecycleTarget({ scope: "task", taskId: task.id, roleName: role.name }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: task.id }]);
-    const retired = retireStoppedTaskRoleSession(set, timestamp);
-    store.saveTaskRoleSessionSet(retired);
-    const eventId = store.nextEventId(task.id);
-    store.saveEvent(task.id, createTaskEvent(eventId, task.id, "runtime.role-session-reset", {
-        roleName: role.name,
-        reason,
-        peakTokens: String(evidence.peakTokens),
-        hardTokens: String(evidence.hardTokens),
-        ...(current.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: current.nativeSessionId }),
-        ...(current.launchId === undefined ? {} : { launchId: current.launchId })
-    }, now));
-    return Object.freeze({
-        taskId: task.id,
-        roleName: role.name,
-        eventId,
-        ...(current.nativeSessionId === undefined
-            ? {}
-            : { retiredNativeSessionId: current.nativeSessionId }),
-        ...(current.launchId === undefined ? {} : { retiredLaunchId: current.launchId })
-    });
-}
-/**
- * Retires the current generation to history as `stopped` (not `broken`:
- * a budget rollover is not a Session failure) and clears the Turn fence so
- * the next launch is a fresh generation.
- */
-function retireStoppedTaskRoleSession(set, timestamp) {
-    validateRoleSessionSet(set);
-    const current = set.sessions[set.activeAgentId];
-    const sessions = { ...set.sessions };
-    delete sessions[set.activeAgentId];
-    const history = current === undefined
-        ? set.history
-        : [
-            ...(set.history ?? []),
-            { ...current, status: "stopped", updatedAt: timestamp }
-        ];
-    return validateRoleSessionSet({
-        ...set,
-        sessions,
-        ...(history === undefined ? {} : { history }),
-        inFlight: null,
-        providerBinding: null,
-        updatedAt: timestamp
-    });
-}

package/dist/lifecycle/taskRoleSessionReset.js

@@ -1,126 +0,0 @@
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
-import { resetTaskRoleSession } from "../executor/agentExecutor.js";
-import { createTaskEvent } from "../event/taskEvent.js";
-import { createTaskMessage } from "../message/message.js";
-import { updateRoleStatus } from "../role/role.js";
-import { createLeaderRecoveryNotification } from "../scheduler/operatorNotification.js";
-import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { updateWorkItemStatus, workItemOwnsUnresolvedExecutionLane } from "../workItem/workItem.js";
-import { terminalizeExactTaskRun } from "./exactRunTerminalization.js";
-/**
- * Resets the current native generation using Yui's own persisted identities.
- * The caller supplies intent only; the Controller verifies process cleanup.
- */
-export function resetTaskRoleSessionGeneration(store, taskId, roleName, reason, now) {
-    const task = store.getTask(requiredIdentity(taskId, "Task id"));
-    if (task === null)
-        throw new Error(`Task not found: ${taskId}.`);
-    if (task.status !== "active")
-        throw new Error(`Task is not active: ${task.id}/${task.status}.`);
-    const normalizedRole = requiredIdentity(roleName, "Role name");
-    const role = store.getRole(task.id, normalizedRole);
-    if (role === null)
-        throw new Error(`Role not found: ${task.id}/${normalizedRole}.`);
-    const summary = `Reset native Session: ${requiredText(reason, "Reset reason")}`;
-    let sessions = store.getTaskRoleSessionSet(task.id, role.name);
-    const current = sessions?.sessions[sessions.activeAgentId];
-    const activeRun = store.getActiveAgentRun(task.id, role.name);
-    if (activeRun !== null) {
-        const receiptId = sessions?.inFlight?.runId === activeRun.id
-            ? sessions.inFlight.receiptId
-            : formatAgentRunReceiptId(task.id, activeRun.id);
-        const terminal = terminalizeExactTaskRun(store, {
-            taskId: task.id,
-            roleName: role.name,
-            agentId: activeRun.effective.agentId,
-            runId: activeRun.id,
-            receiptId,
-            ...(current === undefined ? {} : {
-                nativeSessionId: current.nativeSessionId,
-                ...(current.launchId === undefined ? {} : { launchId: current.launchId })
-            }),
-            outcome: { status: "failed", summary }
-        }, now);
-        if (terminal.disposition !== "applied" || terminal.run === null) {
-            throw new Error(`Task Role reset lost its exact Run fence: ${terminal.reason ?? "obsolete"}.`);
-        }
-        if (activeRun.purpose === "execution" && activeRun.workItemId !== undefined) {
-            const item = store.getWorkItem(task.id, activeRun.workItemId);
-            if (item !== null
-                && !["completed", "failed", "retired"].includes(item.status)
-                && !workItemOwnsUnresolvedExecutionLane(item, activeRun.executionGroupId, activeRun.executionLaneId)) {
-                store.saveWorkItem(task.id, updateWorkItemStatus(item, "failed", now, summary));
-            }
-        }
-    }
-    enqueueWork(store, runtimeLifecycleTarget({
-        scope: "task",
-        taskId: task.id,
-        roleName: role.name
-    }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: task.id }]);
-    sessions = store.getTaskRoleSessionSet(task.id, role.name);
-    if (sessions !== null)
-        store.saveTaskRoleSessionSet(resetTaskRoleSession(sessions, now));
-    const updatedRole = store.getRole(task.id, role.name);
-    store.saveRole(task.id, updateRoleStatus(updatedRole, role.name === "leader" ? "failed" : "idle", now));
-    const message = createTaskMessage(store.nextMessageId(task.id), task.id, summary, "system", { type: "system" }, now, activeRun === null ? {} : {
-        runId: activeRun.id,
-        ...(activeRun.workItemId === undefined ? {} : { workItemId: activeRun.workItemId })
-    });
-    store.saveMessage(task.id, message);
-    store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, "runtime.role-session-reset", {
-        roleName: role.name,
-        reason: summary,
-        ...(activeRun === null ? {} : { runId: activeRun.id }),
-        ...(current?.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: current.nativeSessionId })
-    }, now));
-    if (role.name === "leader") {
-        const nativeSessionId = current?.nativeSessionId ?? `reset-${task.id}`;
-        store.saveLeaderFailure(recordLeaderFailure(task.id, nativeSessionId, summary, now, store.getLeaderFailure(task.id)));
-        store.saveOperatorNotification(createLeaderRecoveryNotification(task.id, summary, now, store.getOperatorNotification(task.id)));
-        enqueueWork(store, { kind: "operator" }, "leader-run-failed", now, [
-            { type: "task", id: task.id },
-            { type: "message", taskId: task.id, id: message.id },
-            ...(activeRun === null ? [] : [{
-                    type: "run",
-                    taskId: task.id,
-                    id: activeRun.id
-                }])
-        ]);
-    }
-    else {
-        enqueueWork(store, { kind: "role", taskId: task.id, roleName: "leader" }, "role-run-failed", now, [
-            { type: "message", taskId: task.id, id: message.id },
-            ...(activeRun === null ? [] : [{
-                    type: "run",
-                    taskId: task.id,
-                    id: activeRun.id
-                }])
-        ]);
-    }
-    return {
-        taskId: task.id,
-        roleName: role.name,
-        run: activeRun === null ? null : store.getAgentRun(task.id, activeRun.id),
-        ...(current === undefined ? {} : { nativeSessionId: current.nativeSessionId })
-    };
-}
-function requiredIdentity(value, label) {
-    const normalized = requiredText(value, label);
-    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
-        || /[\/\\\0]/u.test(normalized))
-        throw new Error(`${label} is invalid.`);
-    return normalized;
-}
-function requiredText(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/scheduler/operatorNotification.js

@@ -1,59 +0,0 @@
-export const CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION = 1;
-export function createLeaderRecoveryNotification(taskId, message, now, existing) {
-    const timestamp = now.toISOString();
-    return {
-        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
-        taskId: requiredText(taskId, "Task id"),
-        type: "leader-recovery-failed",
-        message: requiredText(message, "Operator notification message"),
-        createdAt: existing?.type === "leader-recovery-failed"
-            ? existing.createdAt
-            : timestamp,
-        updatedAt: timestamp
-    };
-}
-export function createTaskTerminalNotification(taskId, status, by, summary, now) {
-    const timestamp = now.toISOString();
-    return {
-        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
-        taskId: requiredText(taskId, "Task id"),
-        type: "task-terminal",
-        status,
-        by,
-        summary: requiredText(summary, "Task terminal summary"),
-        createdAt: timestamp,
-        updatedAt: timestamp
-    };
-}
-export function createLeaderStallNotification(taskId, runId, progressAt, evidenceKey, now, existing) {
-    const timestamp = now.toISOString();
-    const previous = existing?.type === "leader-stalled"
-        && existing.runId === runId
-        && existing.progressAt === progressAt
-        ? existing
-        : undefined;
-    return {
-        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
-        taskId: requiredText(taskId, "Task id"),
-        type: "leader-stalled",
-        message: requiredText([
-            `Leader Run ${runId} is truly stalled for Task ${taskId}.`,
-            `lastProgressAt=${progressAt}`,
-            `classification=truly-stalled`,
-            `evidence=${evidenceKey}`,
-            "Inspect the Task context and decide whether to continue, reset, retry, change Agent, or request user input; Controller performed no automatic action."
-        ].join(" "), "Operator notification message"),
-        runId: requiredText(runId, "Leader Run id"),
-        progressAt: requiredText(progressAt, "Leader progress timestamp"),
-        classification: "truly-stalled",
-        evidenceKey: requiredText(evidenceKey, "Leader stall evidence"),
-        createdAt: previous?.createdAt ?? timestamp,
-        updatedAt: timestamp
-    };
-}
-function requiredText(value, label) {
-    const normalized = value.trim();
-    if (normalized.length === 0)
-        throw new Error(`${label} is required.`);
-    return normalized;
-}