@zq-silk/yui 0.15.7 → 0.15.9

package/dist/scheduler/taskObservabilityProjection.js

@@ -8,9 +8,9 @@ export function buildTaskObservabilityProjection(input) {
     const dag = projectDag(input.workItems);
     const workItems = input.workItems.map((item) => {
         const groups = item.executionGroups;
-        const itemCost = projectWorkItemCost(groups, input.turns, now);
-        const itemContext = projectContext(groups, input.turns, input.contextSnapshots);
-        const producerObservability = projectWorkItemProducerObservability(item, input.turns);
+        const itemCost = projectWorkItemCost(groups, input.runs, now);
+        const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
+        const producerObservability = projectWorkItemProducerObservability(item, input.runs);
         return Object.freeze({
             workItemId: item.id,
             title: item.title,
@@ -21,8 +21,8 @@ export function buildTaskObservabilityProjection(input) {
             resultCount: producerObservability?.resultCount ?? null
         });
     });
-    const cost = projectCost(input.executionGroups, input.turns, input.events, now);
-    const context = projectContext(input.executionGroups, input.turns, input.contextSnapshots);
+    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
+    const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
     return Object.freeze({
         dag,
         workItems,
@@ -31,21 +31,21 @@ export function buildTaskObservabilityProjection(input) {
         sessionTokens: Object.freeze([...(input.sessionTokens ?? [])])
     });
 }
-function projectWorkItemProducerObservability(item, turns) {
+function projectWorkItemProducerObservability(item, runs) {
     const successfulLanes = item.executionGroups.flatMap((group) => group.lanes.flatMap((lane) => (lane.disposition === "succeeded" ? [{ group, lane }] : [])));
     let resultCount = 0;
     for (const { group, lane } of successfulLanes) {
-        const turn = lane.successfulTurnId === undefined
+        const run = lane.successfulRunId === undefined
             ? undefined
-            : turns.find(({ id }) => id === lane.successfulTurnId);
-        if (turn === undefined
-            || turn.result === undefined
-            || turn.status !== "completed"
-            || turn.taskId !== item.taskId
-            || turn.workItemId !== item.id
-            || turn.executionGroupId !== group.id
-            || turn.executionLaneId !== lane.id
-            || turn.roleName !== lane.roleName)
+            : runs.find(({ id }) => id === lane.successfulRunId);
+        if (run === undefined
+            || run.result === undefined
+            || run.status !== "completed"
+            || run.taskId !== item.taskId
+            || run.workItemId !== item.id
+            || run.executionGroupId !== group.id
+            || run.executionLaneId !== lane.id
+            || run.roleName !== lane.roleName)
             return null;
         resultCount += 1;
     }
@@ -69,7 +69,7 @@ function projectDag(workItems) {
         const unresolved = item.dependsOn.filter((dependency) => {
             return !dependencySatisfied(dependency, byId);
         });
-        const projectedStatus = item.status === "pending"
+        const projectedStatus = item.status === "open"
             ? unresolved.length === 0 ? "ready" : "blocked"
             : item.status;
         return Object.freeze({
@@ -110,13 +110,13 @@ function rootCauses(id, byId) {
         }
         const unresolved = item.dependsOn.filter((dependency) => !dependencySatisfied(dependency, byId));
         if (unresolved.length === 0) {
-            if (item.status === "failed" || item.status === "awaiting_acceptance")
+            if (item.status === "open" && item.currentCandidateId !== undefined)
                 result.push(item.id);
             return;
         }
         for (const dependency of unresolved) {
             const target = byId.get(dependency);
-            if (target?.status === "failed" || target?.status === "awaiting_acceptance")
+            if (target?.status === "open" && target.currentCandidateId !== undefined)
                 result.push(target.id);
             else
                 visit(dependency);
@@ -126,7 +126,7 @@ function rootCauses(id, byId) {
     return [...new Set(result)];
 }
 function dependencySatisfied(id, byId) {
-    return byId.get(id)?.status === "completed";
+    return byId.get(id)?.status === "accepted";
 }
 function dependencyEdgeStatus(id, byId) {
     const target = byId.get(id);
@@ -136,14 +136,14 @@ function dependencyEdgeStatus(id, byId) {
         return "satisfied";
     if (target.status === "retired")
         return "dead";
-    if (target.status === "failed" || target.status === "awaiting_acceptance")
-        return "failed-open";
+    if (target.status === "open" && target.currentCandidateId !== undefined)
+        return "active";
     return "active";
 }
-function projectCost(groups, turns, _events, now) {
+function projectCost(groups, runs, _events, now) {
     const uniqueGroups = [...new Map(groups.map((group) => [group.id, group])).values()];
     const groupIds = new Set(uniqueGroups.map(({ id }) => id));
-    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
     return Object.freeze({
         tokens: 0,
@@ -158,9 +158,9 @@ function projectCost(groups, turns, _events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectWorkItemCost(groups, turns, now) {
+function projectWorkItemCost(groups, runs, now) {
     const groupIds = new Set(groups.map(({ id }) => id));
-    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const wallClockSeconds = groups.reduce((total, group) => {
         const started = Date.parse(group.createdAt);
         const ended = group.lanes.some(({ disposition }) => disposition === "open")
@@ -184,15 +184,15 @@ function projectWorkItemCost(groups, turns, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectContext(groups, turns, snapshots) {
+function projectContext(groups, runs, snapshots) {
     const refs = new Map();
     for (const group of groups) {
         const ref = group.assignment.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }
-    for (const turn of turns) {
-        const ref = turn.inputs[0].input.contextSnapshotRef;
+    for (const run of runs) {
+        const ref = run.inputs[0].input.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }

package/dist/scheduler/taskWake.js

@@ -1,5 +1,6 @@
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
+import { copyRef } from "../coordination/workMailbox.js";
 export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 1;
 export function createTaskWake(input) {
     const wake = {
@@ -8,16 +9,22 @@ export function createTaskWake(input) {
         taskId: requireIdentity(input.taskId, "Task id"),
         seq: wakeSequence(input.id),
         reasons: Object.freeze(input.reasons.map((reason) => requireText(reason, "Wake reason"))),
+        ...(input.refs === undefined ? {} : { refs: Object.freeze(input.refs.map(copyRef)) }),
         fromCursor: requireTimestamp(input.fromCursor, "Wake fromCursor"),
         toCursor: requireTimestamp(input.toCursor, "Wake toCursor"),
         status: "dispatched",
-        turnId: requireIdentity(input.turnId, "Wake Turn id"),
+        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Wake AgentRun id") }),
         createdAt: input.now.toISOString()
     };
     validateTaskWake(wake);
     return wake;
 }
 export function validateTaskWake(wake) {
+    if (wake.refs !== undefined) {
+        if (!Array.isArray(wake.refs))
+            throw new Error("Wake references must be an array.");
+        wake.refs.forEach(copyRef);
+    }
     if (wake.schemaVersion !== CURRENT_TASK_WAKE_SCHEMA_VERSION) {
         throw new Error(`Task wake ${wake.id} must use schemaVersion ${CURRENT_TASK_WAKE_SCHEMA_VERSION}.`);
     }
@@ -55,12 +62,12 @@ export function latestTaskWake(wakes) {
     return latest;
 }
 /**
- * The delta lower bound for a Task's first wake: the last Leader Turn's
+ * The delta lower bound for a Task's first wake: the last Leader AgentRun's
  * creation time, preserving the pre-ledger watermark semantics. When no
- * Leader Turn exists, the Task's own creation time bounds the window.
+ * Leader AgentRun exists, the Task's own creation time bounds the window.
  */
 export function fallbackWakeCursor(input) {
-    return input.leaderTurnCreatedAt ?? input.taskCreatedAt;
+    return input.leaderRunCreatedAt ?? input.taskCreatedAt;
 }
 function wakeSequence(id) {
     const prefix = `${TASK_RECORD_ID_PREFIXES.taskWake}-`;

package/dist/scheduler/wakeReason.js

@@ -8,7 +8,7 @@
  * queue — the wake layer owns the meaning of its tags.
  *
  * Tag wire format: `<kind>` or `<kind>:<ref>`. The ref is an exact record
- * identifier (InputRequest id, Turn id, ...) or, for `force-wake`, the
+ * identifier (InputRequest id, AgentRun id, ...) or, for `force-wake`, the
  * operator-supplied text. Unknown kinds parse losslessly so a newer producer
  * can never wedge an older reader.
  */
@@ -17,6 +17,7 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "input-timeout",
     "role-turn-stalled",
     "agent-error",
+    "activation-failed",
     "agent-session-recovery",
     "review-failed",
     "task-reopened",
@@ -27,6 +28,13 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "force-wake"
 ]);
 const IMMEDIATE_KINDS = new Set([
+    "operator-input",
+    "user-message",
+    "task-created",
+    "execution-started",
+    "session-replaced",
+    "force-wake",
+    "activation-failed",
     "task-reopened",
     "leader-turn-failed",
     "role-turn-failed"

package/dist/setup/setupCommand.js

@@ -53,14 +53,10 @@ export async function runSetupCommand(args, env, executor, io = {}) {
         return `${[
             "Yui setup complete.",
             `Yui home: ${home}.`,
-            `Operator Agent: ${agent.id}.`,
-            `Leader Agent: ${roleStatus.leaderAgentId}.`,
+            `Operator: ${agent.id} (${roleStatus.operator}).`,
+            `Leader: ${roleStatus.leaderAgentId} (${roleStatus.leader}).`,
             `Default workspace: ${workspace}.`,
-            `Operator configuration: ${roleStatus.operator}.`,
-            `Leader configuration: ${roleStatus.leader}.`,
-            `Tmux: ${tmuxBin}.`,
-            "Setup did not configure Review, Worker, Profiles, or shell completion.",
-            "Run `yui operator enter` to continue, or `yui config show` to inspect configuration."
+            "Run `yui config show` to inspect configuration, or `yui operator enter` to start an Operator session for configuration changes or development tasks."
         ].join("\n")}\n`;
     }
     finally {

package/dist/storage/migrations/agentRunContract.js

@@ -0,0 +1,159 @@
+import { createContextSnapshot, contextContentDigest } from "../../context/contextSnapshot.js";
+/** Storage 12 -> 13 only. Text, native identities and opaque record/receipt ids
+ * are never renamed. Ordinary runtime stores do not interpret old payloads.
+ * v13 also introduces optional Message recipient/continuation/handovers.
+ * Existing messages have no recipient and remain informational/Leader wakes;
+ * migration never guesses an owner or causes historical messages to execute.
+ */
+export function migrateAgentRunContract(db) {
+    // T08 already stored real planning executions. Use that frozen evidence,
+    // never the Task's current status, to classify their shared Session snapshots.
+    const planningLaunches = new Set();
+    for (const row of db.prepare("SELECT task_id, payload FROM turns").all()) {
+        const run = JSON.parse(row.payload);
+        if (run.purpose === "planning") {
+            planningLaunches.add(`${row.task_id}:${contextContentDigest(run.effective)}`);
+        }
+    }
+    const snapshotDigests = new Map();
+    const renameKey = (key) => {
+        if (key === "turn")
+            return "run";
+        if (key === "turns")
+            return "runs";
+        if (key === "turnId")
+            return "runId";
+        if (key === "turnIds")
+            return "runIds";
+        if (/NativeTurn|ProviderTurn|CompletedTurn|nativeTurn|providerTurn/.test(key))
+            return key;
+        return key.replaceAll("Turn", "Run").replace(/^turn(?=[A-Z])/, "run")
+            .replaceAll("TURN_", "RUN_").replaceAll("_TURN", "_RUN");
+    };
+    const untouched = new Set(["advanced", "metadata", "environment", "raw", "output", "body",
+        "description", "summary", "directive", "config"]);
+    const migrate = (value, taskId, purpose) => {
+        if (Array.isArray(value))
+            return value.map((entry) => migrate(entry, taskId, purpose));
+        if (value === null || typeof value !== "object")
+            return value;
+        const input = value;
+        const ownerTaskId = typeof input.taskId === "string" ? input.taskId : taskId;
+        const executionPurpose = typeof input.purpose === "string" ? input.purpose : purpose;
+        const result = {};
+        for (const [key, child] of Object.entries(input)) {
+            let next = untouched.has(key) ? child : migrate(child, ownerTaskId, executionPurpose);
+            if ((key === "type" || key === "recordKind" || key === "store") && child === "turn")
+                next = "run";
+            if (key === "type" && typeof child === "string" && child.startsWith("turn.")
+                && typeof input.id === "string" && input.id.startsWith("event-") && input.createdAt !== undefined) {
+                next = child.replace(/^turn\./, "run.");
+            }
+            if (key === "store" && child === "source-turn")
+                next = "source-run";
+            // Runtime envelopes are structured evidence encoded inside Task Events,
+            // not free-form Provider output.
+            if (key === "observation" && typeof child === "string") {
+                const parsed = JSON.parse(child);
+                next = JSON.stringify(migrate(parsed, ownerTaskId));
+            }
+            result[renameKey(key)] = next;
+        }
+        if (typeof input.digest === "string" && typeof input.id === "string"
+            && input.id.startsWith("context-snapshot-") && typeof input.sequence === "number") {
+            result.digest = snapshotDigests.get(input.digest) ?? input.digest;
+        }
+        // A Run has its own authoritative purpose. Session copies are classified
+        // by the exact planning launch they retain; activation never upgrades them.
+        if (input.schemaVersion === 3 && typeof input.agentId === "string"
+            && typeof input.sourceDesiredRevision === "number" && input.workspace !== undefined
+            && input.context !== undefined && input.permission !== undefined) {
+            result.executionAuthority = executionPurpose === "planning"
+                || (ownerTaskId !== undefined && planningLaunches.has(`${ownerTaskId}:${contextContentDigest(input)}`))
+                ? "planning" : "delivery";
+        }
+        return result;
+    };
+    const snapshots = db.prepare("SELECT rowid, payload FROM context_snapshots")
+        .all();
+    const originals = new Map(snapshots.map((row) => {
+        const snapshot = JSON.parse(row.payload);
+        return [`${snapshot.taskId}/${snapshot.id}`, { ...row, snapshot }];
+    }));
+    const visiting = new Set();
+    const completed = new Set();
+    const migrateSnapshot = (key) => {
+        if (completed.has(key))
+            return;
+        const row = originals.get(key);
+        if (row === undefined)
+            return; // Preserve unresolved historical references as references.
+        if (visiting.has(key))
+            throw new Error("Context Snapshot references contain a cycle.");
+        visiting.add(key);
+        const original = row.snapshot;
+        // Dependency order, not wall-clock order: async callers can freeze with
+        // an earlier pass timestamp while referencing an already committed parent.
+        const visitReferences = (value) => {
+            if (value === null || typeof value !== "object")
+                return;
+            if (Array.isArray(value)) {
+                value.forEach(visitReferences);
+                return;
+            }
+            const ref = value;
+            if (typeof ref.id === "string" && ref.id.startsWith("context-snapshot-")
+                && typeof ref.taskId === "string" && typeof ref.digest === "string"
+                && typeof ref.sequence === "number")
+                migrateSnapshot(`${ref.taskId}/${ref.id}`);
+            for (const [field, child] of Object.entries(ref)) {
+                if (!untouched.has(field))
+                    visitReferences(child);
+            }
+        };
+        visitReferences(original.parentRef);
+        visitReferences(original.resources);
+        const current = migrate(original);
+        const resources = current.resources.map((entry) => ({
+            ...entry, ref: { ...entry.ref, digest: contextContentDigest(entry.value) }
+        }));
+        const refs = current.refs.map((ref) => resources.find((entry) => entry.ref.layer === ref.layer && entry.ref.store === ref.store && entry.ref.refId === ref.refId)?.ref ?? ref);
+        const snapshot = createContextSnapshot({ ...current, resources, refs, frozenAt: new Date(current.frozenAt) });
+        snapshotDigests.set(original.digest, snapshot.digest);
+        db.prepare("UPDATE context_snapshots SET payload = ?, digest = ? WHERE rowid = ?")
+            .run(JSON.stringify(snapshot), snapshot.digest, row.rowid);
+        visiting.delete(key);
+        completed.add(key);
+    };
+    for (const key of originals.keys())
+        migrateSnapshot(key);
+    const tables = [
+        "config", "agent_profiles", "global_roles", "global_role_session_sets",
+        "task_records", "task_roles", "role_session_sets", "work_items", "work_item_candidates",
+        "turns", "active_turns", "review_rounds", "change_sets", "integration_attempts",
+        "messages", "input_requests", "decisions", "milestones", "events", "task_projections",
+        "durable_jobs", "integration_queue", "task_wakes", "telemetry", "telemetry_aggregate"
+    ];
+    const rewriteColumn = (table, column) => {
+        const columns = db.prepare(`PRAGMA table_info("${table}")`).all();
+        if (!columns.some((entry) => entry.name === column))
+            return;
+        const keys = columns.filter((entry) => entry.pk > 0).sort((a, b) => a.pk - b.pk).map((entry) => entry.name);
+        if (!keys.length)
+            throw new Error(`Migration requires the primary key of ${table}.`);
+        const quote = (value) => `"${value.replaceAll('"', '""')}"`;
+        const rows = db.prepare(`SELECT * FROM ${quote(table)} WHERE ${quote(column)} IS NOT NULL`)
+            .all();
+        const update = db.prepare(`UPDATE ${quote(table)} SET ${quote(column)} = ? WHERE ${keys.map((key) => `${quote(key)} = ?`).join(" AND ")}`);
+        for (const row of rows) {
+            update.run(JSON.stringify(migrate(JSON.parse(row[column]), typeof row.task_id === "string" ? row.task_id : undefined)), ...keys.map((key) => row[key]));
+        }
+    };
+    for (const table of tables) {
+        rewriteColumn(table, "payload");
+    }
+    for (const column of ["pending", "processing"]) {
+        rewriteColumn("mailboxes", column);
+    }
+    db.prepare("UPDATE id_sequences SET kind = 'run' WHERE kind = 'turn'").run();
+}