@zq-silk/yui 0.13.9 → 0.14.0

package/dist/profile/agentProfile.js

@@ -75,7 +75,7 @@ export function builtinAgentProfileInputs() {
         {
             id: "reviewer",
             description: "Review one candidate against the user's core outcome, supported behavior, and direct evidence.",
-            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and the Reviewer Session and physical workspace continue across changed-head Rounds without reusing an earlier verdict. The current Run's frozen candidate remains the only scope even if Task main advances. For Delta Recheck, return equivalent-and-accepted, finding, or requires-full-review with explicit reasoning; never create the next Round. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In the Review workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. Report complete findings, checks actually run, uncertainty, and bounded next actions through the exact Review yield; Yui preserves the full free-form report. Expose evidence and options to the Leader, who decides.",
+            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and the Reviewer Session and physical workspace continue across changed-head Rounds without reusing an earlier verdict. The current Turn's frozen candidate remains the only scope even if Task main advances. For Delta Recheck, return equivalent-and-accepted, finding, or requires-full-review with explicit reasoning; never create the next Round. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In the Review workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. End the Provider turn with complete findings, checks actually run, uncertainty, and bounded next actions; Yui preserves the full free-form report automatically. Expose evidence and options to the Leader, who decides.",
             defaultAccess: "write"
         }
     ];

package/dist/release/cliHomeReleaseFence.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { UNSUPPORTED, collectRuntimeBuildIdentity, createProductionRuntimeIdentityPorts } from "../observability/runtimeIdentity.js";
-import { readCompatibleHomeIdentity } from "../storage/compatibleTaskStore.js";
+import { readCurrentHomeIdentity } from "../storage/currentTaskStore.js";
 import { detectRunningRelease, readActiveReleasePointer, releaseDirectoryName } from "./runtimeRelease.js";
 /**
  * Prevent a checkout or otherwise unverified CLI from entering a Home that is
@@ -47,7 +47,7 @@ export function describeCliHomeInvocation(input) {
                 : "unverified-local";
     let homeId = "unknown";
     try {
-        homeId = readCompatibleHomeIdentity(input.home).homeId;
+        homeId = readCurrentHomeIdentity(input.home).homeId;
     }
     catch {
         // The primary migration error remains authoritative when identity is unreadable.
@@ -102,7 +102,7 @@ function readPackageDistribution(packageRoot) {
 function fenceError(input, active, source, release, collected = collectRuntimeBuildIdentity(createProductionRuntimeIdentityPorts(input.packageRoot, input.entryPath))) {
     let homeId = "unknown";
     try {
-        homeId = readCompatibleHomeIdentity(input.home).homeId;
+        homeId = readCurrentHomeIdentity(input.home).homeId;
     }
     catch {
         // The release fence must still diagnose and reject an unreadable Home.

package/dist/release/releaseWorkflowEngine.js

@@ -30,8 +30,8 @@ const IRREVERSIBILITY_RANK = {
  * Concurrency guard: prevents two runs of the same workflow from submitting
  * duplicate external effects. Each CLI invocation is a fresh Node process with
  * its own module instance, so an in-process map cannot coordinate across
- * processes. When the store is a FileTaskStore (it exposes its root directory),
- * the guard is a file lock under that root; otherwise (in-memory test stores)
+ * processes. When the store exposes its root directory, the guard is a file
+ * lock under that root; otherwise (in-memory test stores)
  * it falls back to an in-process map. The second run waits for the first to
  * finish, then re-reads the (now-updated) workflow state.
  */
@@ -86,8 +86,8 @@ async function acquireWorkflowLock(store, taskId, workflowId) {
  *   crash between the two is healed on resume as described above.
  *
  * Concurrent runs of the same workflow are serialized by a cross-process file
- * lock when the store is a FileTaskStore (each CLI invocation is a fresh
- * process), so a second run cannot submit a duplicate effect.
+ * lock when the store exposes its durable root, so a second CLI process cannot
+ * submit a duplicate effect.
  */
 export async function runReleaseWorkflow(store, taskId, workflowId, ports, options = {}) {
     // Prevent concurrent runs of the same workflow from submitting duplicate
@@ -381,7 +381,7 @@ async function runReleaseWorkflowLocked(store, taskId, workflowId, ports, option
             // For irreversible steps, mark as unknown and stop so the effect is
             // never re-submitted blindly. For reversible steps, mark as failed.
             // The exception is re-thrown so the caller sees the crash; the workflow
-            // state is already persisted for recovery on the next run.
+            // state is already persisted for recovery on the next turn.
             const message = error instanceof Error ? error.message : String(error);
             const crashNow = clock();
             if (effectiveIrreversibility === "irreversible") {
@@ -461,11 +461,7 @@ function attemptReservationKey(workflowId, stepId, attempt) {
  * by starting a second workflow against the same grant.
  */
 function grantUseRecognized(grant, workflowId, stepId, attempt) {
-    const reservations = grant.useReservations;
-    if (Array.isArray(reservations)) {
-        return reservations.includes(attemptReservationKey(workflowId, stepId, attempt));
-    }
-    return false;
+    return grant.useReservations.includes(attemptReservationKey(workflowId, stepId, attempt));
 }
 /**
  * Records one grant use after a successful authorization decision. The engine

package/dist/release/releaseWorkflowPorts.js

@@ -186,7 +186,7 @@ export function createReleaseWorkflowPorts(deps) {
                         logs: [`cli-update: ${result.outcome} (${result.version})`]
                     };
                 }
-                if (result.outcome === "ambiguous" || (result.outcome === "aborted" && !result.recoverable)) {
+                if (result.outcome === "aborted" && !result.recoverable) {
                     // P1-2 (rr20): An aborted activation with recoverable=false means
                     // npm activation began but its outcome is unknowable — the global
                     // install may or may not have landed. Treat it as ambiguous:
@@ -203,7 +203,7 @@ export function createReleaseWorkflowPorts(deps) {
                     // externalIdentity so the engine marks the step as `unknown`
                     // and stops — resume must not continue until the expected
                     // Controller lifecycle/identity handoff is proven complete.
-                    if (result.outcome === "aborted" && result.controllerOwnershipUnknown === true) {
+                    if (result.controllerOwnershipUnknown === true) {
                         return {
                             outcome: "timeout",
                             logs: [`cli-update Controller ownership unknown at phase ${result.phase}: ${result.message}`]

package/dist/release/workflowFileLock.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 /**
  * Cross-process mutual exclusion for one workflow's engine runs. Each CLI
  * invocation is a fresh Node process, so an in-process map cannot coordinate
- * across processes; this lock lives under the FileTaskStore root instead.
+ * across processes; this lock lives under the current Home root instead.
  *
  * The lock is a directory created atomically with mkdir(2): its existence is
  * the lock, so a second acquirer fails with EEXIST while the first holds it.

package/dist/repository/checkoutSwap.js

@@ -25,7 +25,7 @@ export async function healCheckoutSwap(request, ports = realPorts) {
  * leaving the registered path without a valid repository. The previous
  * checkout is moved to the backup path first; if the promotion fails it is
  * restored and the staging clone is removed. A crash between the two renames
- * is healed by {@link healCheckoutSwap} on the next run.
+ * is healed by {@link healCheckoutSwap} on the next turn.
  */
 export async function swapManagedCheckout(request, ports = realPorts) {
     await healCheckoutSwap(request, ports);

package/dist/repository/gitWorkspace.js

@@ -121,19 +121,6 @@ export class NodeGitWorkspace {
         }
         return { addedLines, deletedLines };
     }
-    /**
-     * Files deleted between two commits.  Uses `--diff-filter=D` so a rename
-     * reports its source path here (and its destination in `changedFilesBetween`),
-     * letting the containment proof verify both sides of a rename.
-     */
-    async deletedFilesBetween(input) {
-        const output = await git([
-            "-C", input.repositoryPath,
-            "diff", "--name-only", "--diff-filter=D", "--no-renames",
-            input.fromCommit, input.toCommit
-        ]);
-        return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-    }
     /**
      * Resolve the configured Project branch directly from its remote.  This is
      * deliberately read-only: unlike `refresh`, it never advances the stable

package/dist/repository/project.js

@@ -31,7 +31,7 @@ export function validateProjectName(value) {
 }
 /**
  * Soft-retire a Project: mark it retired and record the audit trail. The
- * catalog record, checkout, and every historical Task/Run/Review/Integration/
+ * catalog record, checkout, and every historical Task/Turn/Review/Integration/
  * Publication reference are retained. Retiring an already-retired Project
  * fails closed; a retired Project must be deleted (or kept) as-is.
  */

package/dist/repository/projectMaintenanceLock.js

@@ -3,8 +3,7 @@ import { join } from "node:path";
 /**
  * Per-Project maintenance fence.
  *
- * `project migrate`, Task workspace rebuild, legacy ref archive, and Task
- * archive cleanup are separate CLI processes that all mutate a Project's
+ * `project migrate` and Task archive cleanup are separate CLI processes that mutate a Project's
  * Git repository. Without coordination they can interleave with each other
  * and with the Controller's worktree preparation. The fence is an exclusive
  * directory under the Home's `locks/` area (O_EXCL via mkdir), so it works

package/dist/repository/taskBaseFreshness.js

@@ -61,10 +61,10 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
     const git = options.git ?? newGitWorkspace();
     const workspace = store.getTaskWorkspace(taskId);
-    // Collect active Run workspace snapshots once so every Project entry can
-    // report whether a live Run is pinned to a different commit.
-    const activeRuns = store.listAgentRuns(taskId)
-        .filter((run) => run.status === "active" && run.workspace !== undefined);
+    // Collect active Turn workspace snapshots once so every Project entry can
+    // report whether a live Turn is pinned to a different commit.
+    const activeTurns = store.listTurns(taskId)
+        .filter((turn) => turn.status === "active" && turn.workspace !== undefined);
     const entries = await Promise.all(task.projectBindings.map(async (binding) => {
         const project = requireProject(store, binding.projectId);
         const entry = workspace === null ? undefined : workspaceProjectEntry(workspace, project.id);
@@ -77,12 +77,12 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
         catch {
             physicalHead = undefined;
         }
-        // Find the first active Run whose workspace snapshot covers this Project.
-        const runSnapshot = activeRuns.find((run) => {
-            if (run.workspace === undefined)
+        // Find the first active Turn whose workspace snapshot covers this Project.
+        const turnSnapshot = activeTurns.find((turn) => {
+            if (turn.workspace === undefined)
                 return false;
-            const runEntry = workspaceProjectEntry(run.workspace, project.id);
-            return runEntry !== undefined;
+            const turnEntry = workspaceProjectEntry(turn.workspace, project.id);
+            return turnEntry !== undefined;
         });
         const provenance = latestBaseProvenance(store.listEvents(taskId), project.id);
         const tracked = await resolveTracked(git, project, workspacePath, options.refresh === true);
@@ -99,11 +99,11 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
             workspacePath,
             workspaceClean,
             ...(physicalHead === undefined ? {} : { physicalHead }),
-            ...(runSnapshot?.workspace === undefined
+            ...(turnSnapshot?.workspace === undefined
                 ? {}
                 : {
-                    runSnapshotCommit: workspaceProjectEntry(runSnapshot.workspace, project.id)?.baseCommit,
-                    runSnapshotRunId: runSnapshot.id
+                    turnSnapshotCommit: workspaceProjectEntry(turnSnapshot.workspace, project.id)?.baseCommit,
+                    turnSnapshotId: turnSnapshot.id
                 }),
             ...(tracked === undefined ? {} : {
                 trackedRef: tracked.ref,
@@ -161,7 +161,7 @@ export function renderTaskBaseFreshnessReport(report) {
         `Task base freshness: ${report.taskId} (source: ${report.refreshed ? "remote refresh" : "local tracking"})`
     ];
     for (const entry of report.entries) {
-        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  Run snapshot: ${entry.runSnapshotCommit ?? "-"}${entry.runSnapshotRunId === undefined ? "" : ` (${entry.runSnapshotRunId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
+        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  Turn snapshot: ${entry.turnSnapshotCommit ?? "-"}${entry.turnSnapshotId === undefined ? "" : ` (${entry.turnSnapshotId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
         if (entry.risk !== undefined)
             lines.push(`  risk: ${entry.risk}`);
         if (entry.error !== undefined)

package/dist/repository/taskWorkspaceCoordinator.js

@@ -23,10 +23,10 @@ export class TaskWorkspaceCoordinator {
         if (item === null)
             throw new Error(`Work item not found: ${taskId}/${workItemId}.`);
         const assignee = this.#workItemIsolationAssignee(item);
-        const activeDevelopRun = this.store.listAgentRuns(item.taskId)
+        const activeDevelopTurn = this.store.listTurns(item.taskId)
             .find((run) => run.status === "active" && run.workItemId === item.id);
-        if (activeDevelopRun !== undefined) {
-            throw new Error(`Work Item already has an active Develop Run: ${activeDevelopRun.id}.`);
+        if (activeDevelopTurn !== undefined) {
+            throw new Error(`Work Item already has an active Develop Turn: ${activeDevelopTurn.id}.`);
         }
         const task = this.store.getTask(item.taskId);
         const taskProjectIds = task.projectBindings.map(({ projectId }) => projectId);
@@ -72,8 +72,8 @@ export class TaskWorkspaceCoordinator {
         }
         if (item.workspaceDisposition === disposition)
             return "missing";
-        // Hold the per-Project maintenance fence so a concurrent migrate/rebuild/
-        // archive cannot interleave with worktree removal.
+        // Hold the per-Project maintenance fence so concurrent Project maintenance
+        // or Task archive cannot interleave with worktree removal.
         const workspace = this.store.getWorkItemWorkspace(item.taskId, item.id);
         const projectIds = workspace === null
             ? []
@@ -124,8 +124,8 @@ export class TaskWorkspaceCoordinator {
         }
         if (round.workspaceDisposition?.kind === "reassigned")
             return "missing";
-        // Hold the per-Project maintenance fence so a concurrent migrate/rebuild/
-        // archive cannot interleave with worktree removal.
+        // Hold the per-Project maintenance fence so concurrent Project maintenance
+        // or Task archive cannot interleave with worktree removal.
         const workspace = this.store.getReviewRoundWorkspace(taskId, reviewRoundId);
         const projectIds = workspace === null
             ? []
@@ -163,7 +163,7 @@ export class TaskWorkspaceCoordinator {
                 .localeCompare(managedWorkspaceKey(right.owner)));
             // Archive cleanup removes worktrees from every Project the Task uses:
             // hold each Project's maintenance fence so the Controller defers
-            // preparation and no migrate/rebuild/archive interleaves.
+            // preparation and no Project maintenance or Task archive interleaves.
             const projectIds = new Set(task.projectBindings.map(({ projectId }) => projectId));
             for (const workspace of managedWorkspaces) {
                 for (const entry of workspace.entries)
@@ -253,9 +253,9 @@ export class TaskWorkspaceCoordinator {
                 };
             }
             const activeRole = this.store.listRoles(taskId)
-                .find((role) => this.store.getActiveAgentRun(taskId, role.name) !== null);
+                .find((role) => this.store.getActiveTurn(taskId, role.name) !== null);
             if (activeRole !== undefined) {
-                throw new WorkspaceCleanupBlockedError("active-run", `role:${task.id}/${activeRole.name}`, true, `Task Role still has an active Run: ${task.id}/${activeRole.name}.`);
+                throw new WorkspaceCleanupBlockedError("active-turn", `role:${task.id}/${activeRole.name}`, true, `Task Role still has an active Turn: ${task.id}/${activeRole.name}.`);
             }
             const roleNames = this.store.listRoles(taskId).map(({ name }) => name);
             if (roleNames.length > 0) {
@@ -326,10 +326,10 @@ export class TaskWorkspaceCoordinator {
         }
     }
     #assertWorkItemRuntimeQuiescent(item) {
-        const activeRun = this.store.listAgentRuns(item.taskId)
+        const activeTurn = this.store.listTurns(item.taskId)
             .find((run) => run.status === "active" && run.workItemId === item.id);
-        if (activeRun !== undefined) {
-            throw new WorkspaceCleanupBlockedError("active-run", `work-item:${item.taskId}/${item.id}`, true, `Work item still has an active Run: ${item.taskId}/${item.id}.`);
+        if (activeTurn !== undefined) {
+            throw new WorkspaceCleanupBlockedError("active-turn", `work-item:${item.taskId}/${item.id}`, true, `Work item still has an active Turn: ${item.taskId}/${item.id}.`);
         }
     }
     /**
@@ -368,14 +368,10 @@ export class TaskWorkspaceCoordinator {
     }
     async #stopLiveRoles(taskId, roleNames) {
         const targets = [...new Set(roleNames)];
-        const getActiveRun = this.store.getActiveAgentRun?.bind(this.store);
+        const getActiveTurn = this.store.getActiveTurn?.bind(this.store);
         for (const roleName of targets) {
-            if (getActiveRun !== undefined && getActiveRun(taskId, roleName) !== null) {
-                throw new Error(`Role has an active Run: ${taskId}/${roleName}.`);
-            }
-            const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
-            if (sessions?.inFlight !== null && sessions?.inFlight !== undefined) {
-                throw new Error(`Role has unsettled Run state: ${taskId}/${roleName}.`);
+            if (getActiveTurn !== undefined && getActiveTurn(taskId, roleName) !== null) {
+                throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
             }
             if (this.store.getWorkMailbox !== undefined && hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName })))) {
                 throw new Error(`Role has unsettled runtime lifecycle state: ${taskId}/${roleName}.`);
@@ -397,7 +393,7 @@ export class TaskWorkspaceCoordinator {
         // The aggregate-16 dormant Claude placeholder is the sole exception to
         // strict workspace-session retirement. The synchronous pane inspection is
         // performed while holding the Task store transaction so a normal launch
-        // cannot reserve a Run/Session between absence proof and terminalization.
+        // cannot reserve a Turn/Session between absence proof and terminalization.
         if (inspect === undefined || this.store.transaction === undefined)
             return;
         this.store.transaction((tx) => {
@@ -406,8 +402,8 @@ export class TaskWorkspaceCoordinator {
                 if (panes.some((pane) => pane.roleName === roleName && !pane.dead)) {
                     throw new Error(`Task Role native pane must stop before workspace migration: ${roleName}.`);
                 }
-                if (tx.getActiveAgentRun(taskId, roleName) !== null) {
-                    throw new Error(`Role has an active Run: ${taskId}/${roleName}.`);
+                if (tx.getActiveTurn(taskId, roleName) !== null) {
+                    throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
                 }
                 if (tx.getWorkMailbox !== undefined && hasRuntimeLifecycleWork(tx.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName })))) {
                     throw new Error(`Role has unsettled runtime lifecycle state: ${taskId}/${roleName}.`);
@@ -436,8 +432,8 @@ export class TaskWorkspaceCoordinator {
         if (isTerminalWorkItem(item)) {
             throw new Error(`Work item is already terminal: ${item.id}.`);
         }
-        if (item.assignee !== undefined && this.store.getActiveAgentRun(task.id, item.assignee) !== null) {
-            throw new Error(`Role has an active Run: ${task.id}/${item.assignee}.`);
+        if (item.assignee !== undefined && this.store.getActiveTurn(task.id, item.assignee) !== null) {
+            throw new Error(`Role has an active Turn: ${task.id}/${item.assignee}.`);
         }
         if (item.assignee !== undefined && this.store.getRole(task.id, item.assignee) === null) {
             throw new Error(`Role not found: ${task.id}/${item.assignee}.`);

package/dist/repository/taskWorkspaceIdentity.js

@@ -46,20 +46,18 @@ export function taskWorkspaceRefSegmentFromIdentity(identity) {
     return `${valid.taskId}-${valid.token}`;
 }
 /**
- * The durable ref segment for a Task. A Task with a persisted workspace
- * identity always uses its token-bearing segment; a pre-identity record (a
- * valid v4 Task that never had a managed Git workspace, or one awaiting the
- * controlled rebuild) keeps its bare Task id so its existing worktrees remain
- * addressable until they are rebuilt.
+ * The durable ref segment for a Task. Every managed Git workspace uses the
+ * token-bearing identity minted before its first adoption.
  */
 export function taskWorkspaceRefSegment(task) {
-    if (task.workspaceIdentity === undefined)
-        return task.id;
+    if (task.workspaceIdentity === undefined) {
+        throw new Error(`Task workspace identity is required: ${task.id}.`);
+    }
     return taskWorkspaceRefSegmentFromIdentity(task.workspaceIdentity);
 }
 /**
  * The strict main-branch ref for a Task workspace. The main branch is always
- * `yui/task-N-<8hex>/main`; any other shape is a foreign or legacy ref.
+ * `yui/task-N-<8hex>/main`; any other shape is foreign to the current contract.
  */
 export function taskMainBranch(refSegment) {
     if (!TASK_WORKSPACE_REF_SEGMENT_PATTERN.test(refSegment)) {
@@ -89,11 +87,9 @@ export function taskIntegrationBranch(refSegment, integrationId) {
     return taskDerivedBranch(refSegment, `integration/${integrationId}`);
 }
 /**
- * The non-colliding, auditable archive ref for a legacy Task ref. The Home id
- * in the path keeps two Homes' archives apart even when they share a Project
+ * The non-colliding, auditable archive ref for a current managed Task ref.
+ * The Home id keeps two Homes' archives apart when they share a Project
  * repository; the full original ref name is preserved verbatim.
- * Legacy refs live at `refs/heads/yui/task-N/...`; archives at
- * `refs/yui/archive/<homeId>/heads/yui/task-N/...`.
  */
 export function taskArchiveRef(homeId, sourceRef) {
     const id = requireIdentityPart(homeId, "Home id");
@@ -105,15 +101,6 @@ export function taskArchiveRef(homeId, sourceRef) {
     }
     return `refs/yui/archive/${id}/${ref.slice("refs/".length)}`;
 }
-/**
- * Whether a managed branch belongs to the legacy (pre-identity) layout:
- * `yui/task-N/...` with a bare Task id segment. Identity-bearing branches
- * (`yui/task-N-<8hex>/...`) are never legacy.
- */
-export function isLegacyTaskRef(refName) {
-    const match = /^refs\/heads\/(yui\/(task-[0-9]+)\/.+)$/.exec(refName);
-    return match !== null && !TASK_WORKSPACE_REF_SEGMENT_PATTERN.test(match[2]);
-}
 export function validateTaskWorkspaceIdentity(identity) {
     if (identity.schemaVersion !== 1) {
         throw new Error("Task workspace identity must use schemaVersion 1.");