@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/message/message.js

@@ -1,4 +1,5 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { requireKnownFields } from "../domain/validation.js";
 export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
 /**
  * How a user/operator submission asks its Task to react (task-32 Requirement A).
@@ -24,7 +25,7 @@ export const TASK_MESSAGE_INPUT_CONTROL_OUTCOMES = ["pending", "accepted", "reje
 export function createTaskMessage(id, taskId, body, kind, author, now, context = {}) {
     validateKindAndAuthor(kind, author);
     const message = {
-        schemaVersion: 3,
+        schemaVersion: 1,
         id: requireSafeIdentity(id, "Message id"),
         taskId: requireSafeIdentity(taskId, "Message Task id"),
         kind,
@@ -199,15 +200,16 @@ export function withSubmissionReceipt(message, receipt) {
     return updated;
 }
 export function validateTaskMessage(message) {
-    if (message.schemaVersion !== 3)
-        throw new Error("Task Message must use schemaVersion 3.");
+    if (message.schemaVersion !== 1)
+        throw new Error("Task Message must use schemaVersion 1.");
+    requireKnownFields(message, [
+        "schemaVersion", "id", "taskId", "kind", "author", "body", "intent", "submissionKey", "submissionReceipt",
+        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt"
+    ], "Task Message");
     validateTaskRecordReference({ taskId: message.taskId, localId: message.id }, "message");
     requireText(message.body, "Message body");
     validateKindAndAuthor(message.kind, message.author);
     normalizeAuthor(message.author);
-    if (Object.hasOwn(message, "wakePolicy")) {
-        throw new Error("Message contains a retired wake policy; use the storage upgrade boundary.");
-    }
     if ((message.kind === "user" || message.kind === "operator") && message.intent === undefined) {
         throw new Error("User/operator Message intent is required.");
     }

package/dist/message/messageContinuation.js

@@ -1,7 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
-import { createRun, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { createRun } from "../agentRun/agentRun.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot } from "../context/contextSnapshot.js";
+import { readRunContextSnapshot } from "../context/runContextPack.js";
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { enqueueRoleRunDispatch } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -265,12 +266,9 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
             continue;
         const previous = store.listRuns(taskId).filter((run) => run.roleName === owner.roleName
             && run.workItemId === owner.workItemId && run.reviewRoundId === owner.reviewRoundId).at(-1);
-        const baselineRef = previous.inputs[0]?.input.contextSnapshotRef;
-        const baseline = baselineRef === undefined ? null : store.getContextSnapshot(taskId, baselineRef.id);
-        if (baseline === null || baseline.digest !== baselineRef.digest) {
-            markNotDelivered(store, message, "assignment-context-unavailable");
-            continue;
-        }
+        // Missing or drifted evidence is diagnosed by the caller; never reconstruct
+        // an Assignment from today's Task facts.
+        const baseline = readRunContextSnapshot(store, previous);
         const runId = store.nextRunId(taskId);
         const round = owner.reviewRoundId === undefined ? null : store.getReviewRound(taskId, owner.reviewRoundId);
         const continuingRound = round === null ? null : (() => {
@@ -300,9 +298,10 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
             resources, refs: resources.map(({ ref }) => ref)
         });
         store.saveContextSnapshot(snapshot);
-        const run = withRunContextSnapshot(createRun(runId, taskId, recipient.roleName, "resume", createRunInput({ source: { type: "yui", channel: "message-continuation" },
+        const run = createRun(runId, taskId, recipient.roleName, "resume", createRunInput({ source: { type: "yui", channel: "message-continuation" },
             directive: `Continue the same Assignment in its existing workspace. Read Messages ${batch.map((m) => m.id).join(", ")} from this exact Context. Message receipt is not implementation or acceptance.`,
-            deltaRefIds: batch.map((entry) => entry.id) }), now, copyAssignment(owner)), contextSnapshotRef(snapshot), batch.map((entry) => entry.id));
+            contextSnapshotRef: contextSnapshotRef(snapshot),
+            deltaRefIds: batch.map((entry) => entry.id) }), now, copyAssignment(owner));
         store.saveRun(run);
         store.saveActiveRun(run);
         if (continuingRound !== null)

package/dist/milestone/milestone.js

@@ -1,8 +1,8 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { requireTimestamp } from "../domain/validation.js";
 export function validateMilestone(milestone) {
-    if (milestone.schemaVersion !== 2)
-        throw new Error("Milestone must use schemaVersion 2.");
+    if (milestone.schemaVersion !== 1)
+        throw new Error("Milestone must use schemaVersion 1.");
     validateTaskRecordReference({ taskId: milestone.taskId, localId: milestone.id }, "milestone");
     requireText(milestone.title, "Milestone title");
     requireText(milestone.summary, "Milestone summary");
@@ -12,7 +12,7 @@ export function validateMilestone(milestone) {
 }
 export function createMilestone(id, taskId, title, summary, createdBy, now) {
     return {
-        schemaVersion: 2,
+        schemaVersion: 1,
         id: validateTaskRecordReference({ taskId, localId: id }, "milestone").localId,
         taskId: requireSafeIdentity(taskId, "Task id"),
         title: requireText(title, "Milestone title"),

package/dist/observability/executionAudit.js

@@ -678,13 +678,6 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
     })();
     const storage = (() => {
         try {
-            let stateJsonBytes = UNSUPPORTED;
-            try {
-                stateJsonBytes = statSync(join(home, "state.json")).size;
-            }
-            catch {
-                stateJsonBytes = UNSUPPORTED;
-            }
             let databaseBytes = UNSUPPORTED;
             try {
                 databaseBytes = statSync(join(home, "yui.db")).size;
@@ -693,15 +686,13 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 databaseBytes = UNSUPPORTED;
             }
             return ok({
-                stateJsonBytes,
                 databaseBytes,
                 // The audit aggregates history; live db integrity is the status
                 // command's job (it runs PRAGMA quick_check). Report presence/size
                 // and the authoritative backend, not a duplicate health probe.
                 databaseHealth: UNSUPPORTED,
                 backend: resolveTaskStoreBackendForHome(home),
-                runtimeDirBytes: ports.directorySize(join(home, "runtime")) ?? UNSUPPORTED,
-                deploymentsBytes: ports.directorySize(join(home, "runtime", "deployments")) ?? UNSUPPORTED
+                runtimeDirBytes: ports.directorySize(join(home, "runtime")) ?? UNSUPPORTED
             });
         }
         catch (error) {

package/dist/observability/runtimeIdentity.js

@@ -165,9 +165,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
         || storage.status === "unsupported"
         ? storage.currentVersion
         : UNSUPPORTED;
-    const statePath = join(home, "state.json");
-    const statePresent = ports.exists(statePath);
-    const stateBytes = ports.fileSize(statePath);
     const dbPath = join(home, "yui.db");
     const dbPresent = ports.exists(dbPath);
     const dbBytes = ports.fileSize(dbPath);
@@ -221,14 +218,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             remediation: "Preserve this Home for diagnosis and restore a known-good backup."
         });
     }
-    if (ports.exists(join(home, "schema.json"))) {
-        findings.push({
-            code: "ignored-legacy-storage-manifest",
-            severity: "warning",
-            message: "schema.json is legacy metadata and is not a storage authority.",
-            remediation: "This file is not used. Preserve or archive it separately after inspecting its contents."
-        });
-    }
     if (dbPresent && dbHealth !== null && dbHealth !== "ok") {
         findings.push({
             code: "database-unhealthy",
@@ -237,14 +226,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    if (statePresent) {
-        findings.push({
-            code: "ignored-historical-store",
-            severity: "warning",
-            message: "state.json is present but is not read or written by the current store.",
-            remediation: "Keep it only as read-only historical evidence or archive it outside the active Home."
-        });
-    }
     const rawWorkerFlag = ports.env.YUI_STORE_WORKER;
     if (rawWorkerFlag !== undefined && !["0", "1", "false", "true"].includes(rawWorkerFlag.toLowerCase())) {
         findings.push({
@@ -261,10 +242,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
         minimumStorageVersion: MIN_SUPPORTED_STORAGE_VERSION,
         configuredBackend,
         workerEnabled,
-        physicalStateJson: {
-            present: statePresent,
-            bytes: stateBytes ?? UNSUPPORTED
-        },
         physicalDatabase: {
             present: dbPresent,
             bytes: dbBytes ?? UNSUPPORTED,

package/dist/output/agentConfigurationPresentation.js

@@ -23,7 +23,9 @@ export function renderAgentConfigurationCatalog(resolved) {
         // query rather than a deliberate boundary, so it is shown either way.
         field.available === false
             ? `unavailable${field.reason === undefined ? "" : `: ${field.reason}`}`
-            : field.reason === undefined ? "available" : `available: ${field.reason}`,
+            : field.available === true
+                ? `available${field.reason === undefined ? "" : `: ${field.reason}`}`
+                : field.reason ?? "Native support not confirmed",
         field.allowCustom ? "yes" : "no"
     ]);
     const sections = [
@@ -39,7 +41,7 @@ export function renderAgentConfigurationCatalog(resolved) {
         agentModelOptionsSummary(catalog),
         ...(fieldRows.length === 0
             ? []
-            : [renderTable("Other runtime configuration", [
+            : [renderTable("Configuration fields (native observations and static adapter contracts)", [
                     { header: "Field", minWidth: 12, maxWidth: 30 },
                     { header: "Values", minWidth: 18, maxWidth: 58 },
                     { header: "Status", minWidth: 10, maxWidth: 38 },

package/dist/profile/agentProfile.js

@@ -8,7 +8,7 @@ export const BUILTIN_PROFILE_IDS = Object.freeze([
 export function createAgentProfile(input, now) {
     const timestamp = now.toISOString();
     return validateAgentProfile({
-        schemaVersion: 3,
+        schemaVersion: 1,
         id: requireIdentity(input.id, "Agent Profile id"),
         revision: 1,
         ...normalizeInput(input),
@@ -31,8 +31,8 @@ export function updateAgentProfile(profile, patch, now) {
     return validateAgentProfile(candidate);
 }
 export function validateAgentProfile(profile) {
-    if (profile.schemaVersion !== 3) {
-        throw new Error("AgentProfile must use schemaVersion 3.");
+    if (profile.schemaVersion !== 1) {
+        throw new Error("AgentProfile must use schemaVersion 1.");
     }
     requireIdentity(profile.id, "Agent Profile id");
     requirePositiveInteger(profile.revision, "Agent Profile revision");

package/dist/release/releaseHandover.js

@@ -131,14 +131,14 @@ async function activateLocked(ports, locked) {
         catch (rollbackError) {
             return {
                 outcome: "aborted", phase: "preflight",
-                message: `Host compatibility failed: ${messageOf(error)}; rollback failed: ${messageOf(rollbackError)}`,
+                message: `Storage preflight failed: ${messageOf(error)}; rollback failed: ${messageOf(rollbackError)}`,
                 action: "No candidate was started and the release pointer is unchanged. Preserve the fence and inspect the old Controller.",
                 recoverable: true
             };
         }
         return {
             outcome: "aborted", phase: "preflight",
-            message: `Fenced compatibility preflight failed: ${messageOf(error)}`,
+            message: `Fenced storage preflight failed: ${messageOf(error)}`,
             action: "The old Controller is serving again; the active release and Home are unchanged.",
             recoverable: true
         };

package/dist/release/releaseIdempotencyStore.js

@@ -38,41 +38,19 @@ import { writeTextFileAtomically } from "../storage/durableFile.js";
  * an unpersisted success into an ambiguous/fail-closed outcome; reporting
  * success for an effect whose dedup record did not land would let a crash
  * re-run the effect.
- *
- * Unsupported layouts
- * -------------------
- * The per-key `schemaVersion: 1` layout is the only supported format. A
- * legacy whole-map file (`release-idempotency.json`) from an unsupported
- * older layout is never auto-migrated: it fails closed with a bounded
- * diagnostic so the operator can inspect and clean it up deliberately.
  */
 export const RELEASE_IDEMPOTENCY_SCHEMA_VERSION = 1;
 const DIRECTORY_NAME = "release-idempotency";
-const LEGACY_FILE_NAME = "release-idempotency.json";
 export function createFileReleaseIdempotencyStore(home, now = () => new Date()) {
     const directory = join(home, DIRECTORY_NAME);
-    const legacyPath = join(home, LEGACY_FILE_NAME);
     function recordPath(key) {
         // encodeURIComponent is injective and leaves only Linux-filename-safe
         // characters unescaped, so distinct keys never collide on disk.
         return join(directory, `${encodeURIComponent(key)}.json`);
     }
-    /**
-     * Fail closed when an unsupported legacy whole-map file is present.
-     * The per-key layout is the only supported format; a whole-map file
-     * from an unsupported older layout must not be silently trusted.
-     */
-    function rejectLegacyLayout() {
-        if (existsSync(legacyPath)) {
-            throw new Error(`unsupported legacy release idempotency layout: ${legacyPath} ` +
-                `(whole-map file). Remove it after inspecting its contents; ` +
-                `the per-key schemaVersion 1 layout is the only supported format.`);
-        }
-    }
     return {
         async load(key) {
             try {
-                rejectLegacyLayout();
                 const path = recordPath(key);
                 if (!existsSync(path))
                     return undefined;
@@ -88,7 +66,6 @@ export function createFileReleaseIdempotencyStore(home, now = () => new Date())
                 throw new Error(`release idempotency store only records succeeded effects: ${effect.outcome}`);
             }
             try {
-                rejectLegacyLayout();
                 const record = Object.freeze({
                     schemaVersion: RELEASE_IDEMPOTENCY_SCHEMA_VERSION,
                     key,

package/dist/release/releaseWorkflowPorts.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { runUpdate } from "../cli/updateOrchestrator.js";
+import { renderUpdateResult } from "../cli/updateCommand.js";
 import { activatedControllerEntrypoint } from "../cli/updatePorts.js";
 import { runProjectCommand } from "../commands/projectCommands.js";
 import { restartFileTaskController, stopFileTaskController } from "../controller/clientRuntime.js";
@@ -116,11 +117,14 @@ export function createReleaseWorkflowPorts(deps) {
                     // Best-effort persistence; the effect may still succeed.
                 }
                 const result = runUpdate(inspectedPorts, { home: deps.home });
+                // Preserve cleanup/restore receipts in the existing step log, even
+                // when the binary result is success or a later phase is blocked.
+                const updateLog = renderUpdateResult(result);
                 if (result.outcome === "updated" || result.outcome === "already-current") {
                     return {
                         outcome: "succeeded",
                         externalId: result.version,
-                        logs: [`cli-update: ${result.outcome} (${result.version})`]
+                        logs: [updateLog]
                     };
                 }
                 if (result.outcome === "aborted" && !result.recoverable) {
@@ -143,7 +147,7 @@ export function createReleaseWorkflowPorts(deps) {
                     if (result.controllerOwnershipUnknown === true) {
                         return {
                             outcome: "timeout",
-                            logs: [`cli-update Controller ownership unknown at phase ${result.phase}: ${result.message}`]
+                            logs: [updateLog]
                         };
                     }
                     // P1-2 (rr22): persist the EXACT activation target (the resolved
@@ -154,13 +158,13 @@ export function createReleaseWorkflowPorts(deps) {
                     return {
                         outcome: "timeout",
                         ...(identity === undefined ? {} : { externalIdentity: identity }),
-                        logs: [`cli-update ambiguous at phase ${result.phase}: ${result.message}`]
+                        logs: [updateLog]
                     };
                 }
                 return {
                     outcome: "failed",
                     error: `cli-update aborted at phase ${result.phase}: ${result.message}`,
-                    logs: [`cli-update: ${result.message}`]
+                    logs: [updateLog]
                 };
             }
             case "controller-replace": {

package/dist/release/runtimeRelease.js

@@ -15,6 +15,7 @@
  * deterministic and recoverable.
  */
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { isStorageVersion, compareStorageVersions } from "../storage/storageVersions.js";
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
@@ -133,7 +134,7 @@ export function writeActiveReleasePointer(home, pointer) {
 }
 /**
  * Resolves the Home's active release. Returns null when no pointer exists
- * (legacy/dev Home). Fails closed when the pointer names a release that is
+ * (no immutable release selected). Fails closed when the pointer names a release that is
  * missing or drifted.
  */
 export function resolveActiveRelease(home) {
@@ -478,7 +479,7 @@ function validatePointer(value) {
 function validateRuntimeIdentity(value) {
     if (value === null
         || typeof value !== "object"
-        || value.schemaVersion !== 2
+        || value.schemaVersion !== 1
         || typeof value.version !== "string"
         || typeof value.executablePath !== "string"
         || value.executablePath === ""
@@ -487,15 +488,16 @@ function validateRuntimeIdentity(value) {
         || typeof value.cliRealpath !== "string"
         || typeof value.controllerRealpath !== "string"
         || !isPositiveInteger(value.controllerProtocolVersion)
-        || !isPositiveInteger(value.storageVersion)
-        || !isPositiveInteger(value.minimumStorageVersion)
-        || value.minimumStorageVersion
-            > value.storageVersion
+        || !isStorageVersion(value.storageVersion)
+        || !isStorageVersion(value.minimumStorageVersion)
+        || compareStorageVersions(value.minimumStorageVersion, value.storageVersion) > 0
         || typeof value.pid !== "number"
         || typeof value.processStartIdentity !== "string"
         || (value.mode !== "primary"
             && value.mode !== "candidate")
-        || typeof value.dualOwner !== "boolean") {
+        || typeof value.dualOwner !== "boolean"
+        || value.storageBackend !== "sqlite"
+        || typeof value.workerEnabled !== "boolean") {
         throw new Error("Runtime identity receipt is invalid.");
     }
     return value;

package/dist/repository/gitWorkspace.js

@@ -348,6 +348,11 @@ export class NodeGitWorkspace {
         }
         await canonicalContainer(dirname(destination), true);
         const branch = input.branch === undefined ? undefined : safeRef(input.branch);
+        // Reserve exactly this operation's directory before invoking Git. A clone
+        // rejection because somebody else created the destination cannot authorize
+        // removal of that other directory.
+        await mkdir(destination, { mode: 0o700 });
+        const createdDirectory = await lstat(destination);
         try {
             await git([
                 "clone",
@@ -363,12 +368,31 @@ export class NodeGitWorkspace {
                 }
                 await git(["-C", destination, "branch", "-M", "--", localBranch]);
             }
+            return await this.inspect(destination, "HEAD");
         }
         catch (error) {
-            await rm(destination, { recursive: true, force: true });
+            try {
+                const current = await lstat(destination).catch(failure => {
+                    if (isErrno(failure, "ENOENT"))
+                        return undefined;
+                    throw failure;
+                });
+                if (current !== undefined) {
+                    if (!current.isDirectory() || current.dev !== createdDirectory.dev || current.ino !== createdDirectory.ino) {
+                        throw new Error("Clone destination ownership changed; no direct deletion attempted.");
+                    }
+                    await rm(destination, { recursive: true });
+                }
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], `Clone failed at ${destination}: ${error instanceof Error ? error.message : String(error)}. `
+                    + `Temporary compensation failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. `
+                    + "Cleanup effects are unconfirmed; inspect this exact destination before retrying.");
+            }
+            if (error instanceof Error)
+                error.message += ` Exact temporary clone directory removed or already absent: ${destination}.`;
             throw error;
         }
-        return this.inspect(destination, "HEAD");
     }
     async ensureLocalBranch(repositoryPath, branch) {
         try {
@@ -822,31 +846,54 @@ export class NodeGitWorkspace {
      * worktree's own Git identity instead. Only call for unadopted worktrees
      * that are safe to discard (e.g. Lane preparation compensation).
      */
-    async removeStrandedWorktree(path) {
-        const kind = await pathKind(path);
-        if (kind === undefined)
-            return "missing";
-        if (kind === "symlink")
-            throw new Error("Stranded worktree path must not be a symbolic link.");
-        // Inspect dirty state through the worktree's own Git, bypassing the
-        // Project ownership check that fails after a catalog switch.
-        const porcelain = await git(["-C", path, "status", "--porcelain=v1", "--untracked-files=all"]);
-        if (porcelain.length > 0)
-            return "dirty";
+    async removeStrandedWorktree(path, identity) {
+        let worktreeRemoved = false;
         try {
-            await git(["-C", path, "worktree", "remove", "--force", "--", path]);
+            const expected = managedPath(resolve(identity.container), safeIdentity(identity.directory, "Project directory"));
+            if (path !== expected)
+                throw new Error("Unadopted worktree does not match its exact managed path.");
+            const kind = await pathKind(path);
+            if (kind === undefined)
+                return "missing";
+            if (kind === "symlink")
+                throw new Error("Stranded worktree path must not be a symbolic link.");
+            await canonicalContainer(identity.container, false);
+            if (!(await lstat(join(path, ".git"))).isFile()) {
+                throw new Error("Expected a linked worktree, not a standalone clone.");
+            }
+            const project = await this.inspect(path, "HEAD");
+            await assertOwnedWorktree(project, resolve(identity.container), path);
+            const branch = worktreeIdentity(identity.taskSegment, identity.roleName).branch;
+            await assertExpectedBranch(path, branch);
+            if (project.baseCommit !== identity.expectedCommit) {
+                throw new Error("Unadopted worktree HEAD changed since preparation; retained.");
+            }
+            if (!await this.inspectClean(path))
+                return "dirty";
+            // Use the worktree's proven common directory, never the changed catalog.
+            // Git still enforces locks/submodule restrictions. A Git error is not
+            // authority for direct filesystem deletion, even for unadopted work.
+            await git(["--git-dir", project.gitDirectory, "worktree", "remove", "--", path]);
+            worktreeRemoved = true;
+            if (identity.deleteBranch === true) {
+                await git(["--git-dir", project.gitDirectory, "update-ref", "-d", `refs/heads/${branch}`, identity.expectedCommit]);
+            }
+            return "removed";
         }
-        catch {
-            // The worktree's common-dir (old external repo) may itself be gone.
-            // Remove the directory directly; the worktree is unadopted.
-            await rm(path, { recursive: true, force: true });
+        catch (error) {
+            throw new Error(`Unadopted worktree cleanup failed at ${path}: ${error instanceof Error ? error.message : String(error)} `
+                + `Confirmed worktree removal: ${worktreeRemoved}; failed-command effects remain unconfirmed. `
+                + "No direct deletion was attempted. Inspect this exact path and its Git registration before choosing recovery.", { cause: error });
         }
-        return "removed";
     }
     async removeTaskClone(input) {
         const state = await this.inspectTaskClone(input);
         if (state !== "clean")
             return state;
+        if (input.expectedCommit !== undefined
+            && await resolveRefCommit(input.path, "HEAD") !== input.expectedCommit) {
+            throw new Error(`Unadopted Task clone HEAD changed since preparation; retained at ${input.path}.`);
+        }
         await rm(managedPath(resolve(input.container), input.directory), { recursive: true });
         return "removed";
     }

package/dist/repository/project.js

@@ -8,7 +8,7 @@ export function managedProjectPath(home, projectId) {
 export function createProject(id, name, path, branches, now, metadata = {}) {
     const timestamp = now.toISOString();
     return validateProject({
-        schemaVersion: 6,
+        schemaVersion: 1,
         id: requireIdentity(id, "Project id"),
         name: validateProjectName(name),
         aliases: normalizeAliases(metadata.aliases ?? [], name),
@@ -278,8 +278,8 @@ export function assertProjectCatalog(projects) {
     }
 }
 export function validateProject(project) {
-    if (project.schemaVersion !== 6) {
-        throw new Error("Project must use schemaVersion 6.");
+    if (project.schemaVersion !== 1) {
+        throw new Error("Project must use schemaVersion 1.");
     }
     if (!Array.isArray(project.resourceRefs))
         throw new Error("Project resourceRefs must be an array.");