@zq-silk/yui 0.13.9 → 0.14.0

package/dist/integration/integrationQueueService.js

@@ -191,7 +191,7 @@ export async function enqueueIntegrationQueueEntry(input) {
     if (project === null)
         throw new Error(`Project not found: ${input.projectId}.`);
     const targetRef = input.targetRef
-        ?? changeSet.manifest?.targetRef
+        ?? changeSet.manifest.targetRef
         ?? taskMainBranch(input.store, task.id, input.projectId);
     if (targetRef === undefined) {
         throw new Error(`Task main worktree is not ready; reconcile the Task first: ${task.id}.`);
@@ -276,7 +276,7 @@ export async function enqueueIntegrationQueueEntry(input) {
                 changeSetId: input.changeSetId,
                 targetRef: canonicalTargetRef,
                 checkCommands: requestedChecks,
-                evidenceRefs: changeSet.manifest?.evidenceRefs ?? []
+                evidenceRefs: changeSet.manifest.evidenceRefs
             }, now());
             // Durable positive exact-SHA evidence on an unchanged target, at the lane
             // head, validates the entry so processing skips its checks.  The process-
@@ -341,7 +341,7 @@ export async function enqueueIntegrationQueueEntry(input) {
                 changeSetId: input.changeSetId,
                 targetRef: canonicalTargetRef,
                 checkCommands: requestedChecks,
-                evidenceRefs: changeSet.manifest?.evidenceRefs ?? []
+                evidenceRefs: changeSet.manifest.evidenceRefs
             }, now());
             tx.saveIntegrationQueueEntry(task.id, queuedEntry);
             return { entry: queuedEntry, outcome: "queued" };
@@ -657,7 +657,7 @@ async function evidenceTargetAdvanced(git, repositoryPath, entry, currentTargetH
         return true;
     const ownPaths = new Set([
         ...changeSet.changedPaths,
-        ...(changeSet.manifest?.deletedPaths ?? [])
+        ...changeSet.manifest.deletedPaths
     ]);
     if (delta.some((path) => ownPaths.has(path)))
         return true;
@@ -917,25 +917,9 @@ async function findEquivalentCommit(git, repositoryPath, sourceCommit, historyHe
 async function findContainedChangeSet(git, repositoryPath, changeSet, targetHead) {
     if (git.treesAgreeOnPaths === undefined)
         return null;
-    // A migrated v2 ChangeSet without a manifest has no deletedPaths.  Recover
-    // the actual deletions from git so the containment proof verifies both
-    // sides of a rename: without this, a rename whose destination already
-    // exists on the target would converge even though the source still lives
-    // there.  A ChangeSet with a manifest trusts its declared deletedPaths.
-    let extraDeleted = [];
-    if (changeSet.manifest === undefined) {
-        if (git.deletedFilesBetween === undefined)
-            return null;
-        extraDeleted = await git.deletedFilesBetween({
-            repositoryPath,
-            fromCommit: changeSet.baseCommit,
-            toCommit: changeSet.headCommit
-        });
-    }
     const paths = [...new Set([
             ...changeSet.changedPaths,
-            ...(changeSet.manifest?.deletedPaths ?? []),
-            ...extraDeleted
+            ...changeSet.manifest.deletedPaths
         ])];
     if (paths.length === 0)
         return null;

package/dist/integration/overlapDiagnostics.js

@@ -25,8 +25,8 @@ export function overlapSubjectFromChangeSet(changeSet) {
         baseCommit: changeSet.baseCommit,
         headCommit: changeSet.headCommit,
         changedPaths: changeSet.changedPaths,
-        manifestTags: changeSet.manifest?.tags ?? [],
-        deletedPaths: changeSet.manifest?.deletedPaths ?? []
+        manifestTags: changeSet.manifest.tags,
+        deletedPaths: changeSet.manifest.deletedPaths
     };
 }
 /**

package/dist/interaction/operatorPresentation.js

@@ -34,7 +34,7 @@ function eventLabel(event) {
         case "task.completed": return "Task completed";
         case "task.retired": return "Task retired";
         case "leader.attention-required": return "Task Leader needs attention";
-        case "run.stalled": return "Task Leader stalled";
+        case "turn.stalled": return "Task Leader stalled";
         default: return `Task event ${event.type}`;
     }
 }

package/dist/job/jobRunner.js

@@ -2,7 +2,7 @@
  * Standalone durable-job runner.
  *
  * Receives exactly one argument: the absolute path to a `spec.json` written
- * atomically by the Controller. The runner MUST NOT open state.json or any
+ * atomically by the Controller. The runner MUST NOT open yui.db or any
  * other control-plane file; its entire contract is the spec + the artifact
  * directory. The Controller supervises the runner through the artifact files
  * (heartbeat, checkpoint.json, exit.json) and the process identity.

package/dist/lifecycle/canonicalLifecycleEvent.js

@@ -9,17 +9,17 @@ export class CanonicalLifecycleError extends Error {
         this.name = "CanonicalLifecycleError";
     }
 }
-const RUN_SCOPED_PHASES = new Set([
+const TURN_SCOPED_PHASES = new Set([
     "prompt-pushed",
     "provider-accepted",
     "turn-progress",
     "turn-terminal"
 ]);
 /**
- * Phases that assert durable provider truth about a Run. Every one must carry
- * the complete run-scoped identity — runId AND the generation fences
+ * Phases that assert durable provider truth about a Turn. Every one must carry
+ * the complete turn-scoped identity — turnId AND the generation fences
  * (nativeSessionId + launchId) AND, where the transport owns it, the receiptId —
- * because a missing or wrong fence must fail closed rather than advance a Run or
+ * because a missing or wrong fence must fail closed rather than advance a Turn or
  * its successor.
  */
 const PROVIDER_TRUTH_PHASES = new Set([
@@ -34,7 +34,7 @@ const PROVIDER_TRUTH_PHASES = new Set([
  * (acceptance/progress/terminal), so neither a transport/liveness signal nor a
  * shape-only `adapter-mapped` observation can ever forge or terminalize a turn.
  * `adapter-mapped` remains permissible only for the pre-acceptance
- * session-started/ready phases, whose fold never advances Run truth.
+ * session-started/ready phases, whose fold never advances Turn truth.
  */
 const PHASE_EVIDENCE_MATRIX = {
     "host-process-created": { sources: ["controller"], evidence: ["controller"] },
@@ -77,11 +77,11 @@ export function createCanonicalLifecycleEvent(input) {
         throw new CanonicalLifecycleError(`Phase ${input.phase} rejects evidence ${input.evidence}; only ${rule.evidence.join("/")} may prove it.`);
     }
     const fence = normalizeFence(input.fence);
-    if (RUN_SCOPED_PHASES.has(input.phase) && fence.runId === undefined) {
-        throw new CanonicalLifecycleError(`Phase ${input.phase} requires a runId fence.`);
+    if (TURN_SCOPED_PHASES.has(input.phase) && fence.turnId === undefined) {
+        throw new CanonicalLifecycleError(`Phase ${input.phase} requires a turnId fence.`);
     }
     // Provider-truth phases must carry the complete generation fence so a stale or
-    // wrong generation can never advance the Run.
+    // wrong generation can never advance the Turn.
     if (PROVIDER_TRUTH_PHASES.has(input.phase)) {
         if (fence.nativeSessionId === undefined) {
             throw new CanonicalLifecycleError(`Phase ${input.phase} requires a nativeSessionId fence.`);
@@ -176,7 +176,7 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
                 return { outcome: "obsolete", reason: "push-after-terminal" };
             if (expectation.accepted)
                 return { outcome: "obsolete", reason: "push-after-accepted" };
-            // Exactly one push: a repeat for an already-pushed Run is a no-op, never a
+            // Exactly one push: a repeat for an already-pushed Turn is a no-op, never a
             // second Enter.
             if (expectation.pushed)
                 return { outcome: "idempotent", reason: "already-pushed" };
@@ -209,7 +209,7 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
                 return { outcome: "idempotent", reason: "already-terminal" };
             if (expectation.accepted)
                 return { outcome: "advance-terminal" };
-            // A terminal for a pushed-but-unaccepted Run must NOT promote acceptance;
+            // A terminal for a pushed-but-unaccepted Turn must NOT promote acceptance;
             // hold the immutable fact until (or unless) acceptance folds first.
             if (expectation.pushed)
                 return { outcome: "deferred", reason: "terminal-before-accept" };
@@ -219,13 +219,13 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
     }
 }
 /**
- * Returns null when the event belongs to the expected generation/Run, or a
- * mismatch reason otherwise. Owner/adapter and run-scoped runId are always
+ * Returns null when the event belongs to the expected generation/Turn, or a
+ * mismatch reason otherwise. Owner/adapter and turn-scoped turnId are always
  * compared. Provider-truth phases (acceptance/progress/terminal) require the
  * COMPLETE generation fence — nativeSessionId, launchId, and (for acceptance)
  * receiptId must be present and equal, so a missing or wrong generation/receipt
- * fails closed rather than advancing a Run or its successor. Where a native id
- * is already bound, every run-scoped fact must match it.
+ * fails closed rather than advancing a Turn or its successor. Where a native id
+ * is already bound, every turn-scoped fact must match it.
  */
 function matchesFence(expectation, event) {
     const expected = expectation.fence;
@@ -239,17 +239,17 @@ function matchesFence(expectation, event) {
         return "fence-mismatch:agentId";
     if (expected.adapterId !== actual.adapterId)
         return "fence-mismatch:adapterId";
-    // Run-scoped phases must name the exact expected Run.
-    if (RUN_SCOPED_PHASES.has(phase)) {
-        if (expected.runId === undefined)
-            return "fence-mismatch:expected-run-missing";
-        if (actual.runId !== expected.runId)
-            return "fence-mismatch:runId";
+    // Turn-scoped phases must name the exact expected Turn.
+    if (TURN_SCOPED_PHASES.has(phase)) {
+        if (expected.turnId === undefined)
+            return "fence-mismatch:expected-turn-missing";
+        if (actual.turnId !== expected.turnId)
+            return "fence-mismatch:turnId";
     }
-    else if (actual.runId !== undefined
-        && expected.runId !== undefined
-        && actual.runId !== expected.runId) {
-        return "fence-mismatch:runId";
+    else if (actual.turnId !== undefined
+        && expected.turnId !== undefined
+        && actual.turnId !== expected.turnId) {
+        return "fence-mismatch:turnId";
     }
     // Provider-truth phases require the complete, equal generation fence. A
     // provider-accepted event additionally must carry the exact receipt it accepts.
@@ -315,7 +315,7 @@ function normalizeFence(fence) {
         roleName,
         agentId,
         adapterId: fence.adapterId,
-        ...(fence.runId === undefined ? {} : { runId: requireFenceText(fence.runId, "runId") }),
+        ...(fence.turnId === undefined ? {} : { turnId: requireFenceText(fence.turnId, "turnId") }),
         ...(fence.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireFenceText(fence.nativeSessionId, "nativeSessionId") }),