@zq-silk/yui 0.14.1 → 0.14.2

package/dist/repository/executionLaneGitSnapshot.js

@@ -0,0 +1,80 @@
+import { execFileSync } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
+/**
+ * Freeze the exact committed heads of a durable managed Lane workspace at the
+ * synchronous runtime-terminalization boundary. Runtime event folds are
+ * synchronous inside the SQLite aggregate transaction, so this small Git read
+ * cannot use the asynchronous workspace-preparation port.
+ */
+export function snapshotExecutionLaneWorkspaceSync(store, workspace) {
+    if (workspace.owner.type !== "execution-lane") {
+        throw new Error("Only an Execution Lane workspace can freeze a producer result.");
+    }
+    const stored = store.getManagedWorkspace(workspace.owner);
+    if (stored === null || !isDeepStrictEqual(stored, workspace)) {
+        throw new Error("Execution Lane managed workspace is not the durable owner.");
+    }
+    const writable = workspace.entries.filter(({ access }) => access === "write");
+    if (writable.length === 0) {
+        return {
+            status: "failed",
+            cause: "no-writable-project",
+            diagnostic: "Core could not freeze an Execution Lane with no writable Project."
+        };
+    }
+    const projects = [];
+    for (const entry of writable) {
+        const status = git(entry.path, ["status", "--porcelain"]);
+        if (status === undefined) {
+            return {
+                status: "failed",
+                cause: "workspace-unavailable",
+                diagnostic: `Core could not inspect writable Project ${entry.projectId} at ${entry.path}.`
+            };
+        }
+        if (status.length > 0) {
+            return {
+                status: "failed",
+                cause: "workspace-dirty",
+                diagnostic: `Writable Project ${entry.projectId} is dirty; Core did not accept the Lane result.`
+            };
+        }
+        const branch = git(entry.path, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        const headCommit = git(entry.path, ["rev-parse", "--verify", "HEAD^{commit}"]);
+        if (branch === undefined || headCommit === undefined) {
+            return {
+                status: "failed",
+                cause: "workspace-unavailable",
+                diagnostic: `Core could not resolve the branch and commit for writable Project ${entry.projectId}.`
+            };
+        }
+        if (branch !== entry.branch) {
+            return {
+                status: "failed",
+                cause: "branch-mismatch",
+                diagnostic: `Writable Project ${entry.projectId} is on branch ${branch}; expected ${entry.branch}.`
+            };
+        }
+        projects.push({
+            projectId: entry.projectId,
+            headCommit: headCommit.toLowerCase(),
+            branch
+        });
+    }
+    return {
+        status: "captured",
+        snapshot: { schemaVersion: 1, projects }
+    };
+}
+function git(cwd, args) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/repository/gitWorkspace.js

@@ -70,10 +70,8 @@ export class NodeGitWorkspace {
         ]);
     }
     /**
-     * Every path changed between two commits.  The integration queue uses this
-     * to fence a validated entry: a target advance whose real path delta
-     * overlaps the entry's own paths (or whose impact cannot be proven)
-     * invalidates the entry's reusable evidence.
+     * Every path changed between two commits. Freshness and delta-review
+     * projections use this as objective Git evidence.
      */
     async changedFilesBetween(input) {
         const output = await git([
@@ -135,69 +133,6 @@ export class NodeGitWorkspace {
         const commit = await resolveRemoteBranchCommit(remote, branch);
         return { branch, commit };
     }
-    /**
-     * Merge a remote Project baseline into a clean, managed worktree.  The
-     * fetch is performed from that worktree and the stable checkout is never
-     * touched.  Fast-forward updates are preferred; a diverged baseline gets a
-     * deterministic merge commit so the caller can run its normal Integration
-     * checks and CAS the target ref.
-     */
-    async mergeRemoteIntoWorktree(input) {
-        const initial = await this.inspect(input.repositoryPath, "HEAD");
-        if (!await this.isClean(initial.root)) {
-            throw new Error("Managed Task/Integration worktree must be clean before remote merge.");
-        }
-        const fetched = await this.#fetchRemoteHeadIntoWorktree(input);
-        const fetchedCommit = fetched.commit;
-        const fetchedRef = fetched.fetchedRef;
-        try {
-            if (fetchedCommit === initial.baseCommit) {
-                return { fromCommit: initial.baseCommit, toCommit: fetchedCommit, changed: false };
-            }
-            if (await gitSucceeds([
-                "-C", initial.root,
-                "merge-base", "--is-ancestor", fetchedCommit, initial.baseCommit
-            ])) {
-                // The Task already contains the current remote baseline.
-                return { fromCommit: initial.baseCommit, toCommit: initial.baseCommit, changed: false };
-            }
-            if (await gitSucceeds([
-                "-C", initial.root,
-                "merge-base", "--is-ancestor", initial.baseCommit, fetchedCommit
-            ])) {
-                await git(["-C", initial.root, "merge", "--ff-only", "--no-edit", fetchedRef]);
-            }
-            else {
-                try {
-                    await git([
-                        "-C", initial.root,
-                        "-c", "user.name=Yui",
-                        "-c", "user.email=yui@local",
-                        "merge", "--no-edit", "--no-ff", fetchedRef
-                    ]);
-                }
-                catch (error) {
-                    const affected = (await git([
-                        "-C", initial.root,
-                        "diff", "--name-only", "--diff-filter=U"
-                    ])).trim().split("\n").filter(Boolean);
-                    const suffix = affected.length === 0 ? "" : ` (${affected.join(", ")})`;
-                    throw new RemoteBaselineConflictError(affected, `Remote baseline merge conflicts in managed worktree${suffix}; resolve it in the Integration workspace.`, { cause: error });
-                }
-            }
-            const mergedCommit = (await gitLine([
-                "-C", initial.root,
-                "rev-parse", "--verify", "--end-of-options", "HEAD^{commit}"
-            ])).toLowerCase();
-            if (!await this.isClean(initial.root)) {
-                throw new Error("Remote baseline merge left the managed worktree dirty.");
-            }
-            return { fromCommit: initial.baseCommit, toCommit: mergedCommit, changed: true };
-        }
-        finally {
-            await gitSucceeds(["-C", initial.root, "update-ref", "-d", fetchedRef]);
-        }
-    }
     /** Fetch a remote branch into a managed worktree without changing HEAD. */
     async fetchRemoteHeadIntoWorktree(input) {
         const fetched = await this.#fetchRemoteHeadIntoWorktree(input);
@@ -339,6 +274,13 @@ export class NodeGitWorkspace {
                 remote,
                 destination
             ]);
+            if (input.localBranch !== undefined) {
+                const localBranch = safeRef(input.localBranch);
+                if (!await gitSucceeds(["check-ref-format", "--branch", localBranch])) {
+                    throw new Error(`Local clone branch is invalid: ${localBranch}.`);
+                }
+                await git(["-C", destination, "branch", "-M", "--", localBranch]);
+            }
         }
         catch (error) {
             await rm(destination, { recursive: true, force: true });

package/dist/repository/taskBaseFreshness.js

@@ -187,6 +187,8 @@ function requireProject(store, projectId) {
 async function resolveBaseCommit(git, project, binding, entry) {
     if (entry?.baseCommit !== undefined)
         return entry.baseCommit;
+    if (binding.baseCommit !== undefined)
+        return binding.baseCommit;
     if (COMMIT_PATTERN.test(binding.baseRef))
         return binding.baseRef.toLowerCase();
     return (await git.inspect(project.path, binding.baseRef)).baseCommit;
@@ -225,7 +227,7 @@ async function resolveTracked(git, project, workspacePath, refresh) {
         }
     }
     const tracking = await git.inspectRemoteTracking({
-        repositoryPath: project.path,
+        repositoryPath: workspacePath,
         remoteUrl: project.remoteUrl,
         branch: project.developmentBranch
     });

package/dist/repository/taskWorkspaceCoordinator.js

@@ -171,6 +171,7 @@ export class TaskWorkspaceCoordinator {
             }
             releaseMaintenance = acquireProjectMaintenanceLocks(this.preparer.home, projectIds);
             const laneWorkspaces = managedWorkspaces.filter(({ owner }) => owner.type === "execution-lane");
+            const integrationWorkspaces = managedWorkspaces.filter(({ owner }) => owner.type === "integration-attempt");
             const workspaces = managedWorkspaces
                 .filter(({ owner }) => owner.type === "work-item");
             const workItems = workspaces.map((workspace) => {
@@ -240,6 +241,28 @@ export class TaskWorkspaceCoordinator {
                     };
                 }
             }
+            for (const workspace of integrationWorkspaces) {
+                if (workspace.owner.type !== "integration-attempt")
+                    continue;
+                const attempt = this.store.getIntegrationAttempt(task.id, workspace.owner.integrationAttemptId);
+                if (attempt === null
+                    || attempt.status === "running"
+                    || attempt.status === "blocked"
+                    || attempt.status === "validating") {
+                    throw new Error(`IntegrationAttempt must be terminal before archive cleanup: ${workspace.owner.integrationAttemptId}.`);
+                }
+                if (await this.preparer.inspectIntegrationWorkspace(task.id, attempt.id) === "dirty") {
+                    return {
+                        taskId,
+                        status: "retained-dirty",
+                        ...(task.cwd === undefined ? {} : { path: task.cwd }),
+                        error: `Integration worktree is dirty: ${attempt.id}.`,
+                        reason: "dirty-worktree",
+                        resource: `integration-attempt:${task.id}/${attempt.id}`,
+                        retryable: true
+                    };
+                }
+            }
             const state = await this.preparer.inspectTaskMainWorkspace(taskId);
             if (state === "dirty") {
                 return {
@@ -258,9 +281,7 @@ export class TaskWorkspaceCoordinator {
                 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) {
-                await this.runtime.stopTaskRoleSessions(taskId, roleNames);
-            }
+            await this.#stopLiveRoles(taskId, roleNames);
             await this.runtime.assertTaskPhysicalResourcesReleased?.(task.id);
             this.#assertTaskArchiveSnapshot(snapshot);
             for (const workspace of laneWorkspaces) {
@@ -269,6 +290,12 @@ export class TaskWorkspaceCoordinator {
                     await this.preparer.cleanupExecutionLaneWorkspace(task.id, workspace.owner.executionGroupId, workspace.owner.executionLaneId);
                 }
             }
+            for (const workspace of integrationWorkspaces) {
+                this.#assertTaskArchiveLifecycle(task);
+                if (workspace.owner.type === "integration-attempt") {
+                    await this.preparer.cleanupIntegrationWorkspace(task.id, workspace.owner.integrationAttemptId);
+                }
+            }
             for (const round of reviewRounds) {
                 this.#assertTaskArchiveLifecycle(task);
                 await this.preparer.cleanupReviewRoundWorkspace(task.id, round.id);
@@ -357,12 +384,13 @@ export class TaskWorkspaceCoordinator {
     #workItemRoleNames(item) {
         return [
             ...(item.assignee === undefined ? [] : [item.assignee]),
-            ...(item.executionGroups.flatMap((group) => group.lanes.map(({ roleName }) => roleName)))
+            ...item.executionGroups.flatMap((group) => group.lanes.map(({ roleName }) => roleName))
         ];
     }
     #reviewRoundRoleNames(round) {
         return [
             round.reviewerRoleName,
+            ...(round.executionGroup?.lanes.map(({ roleName }) => roleName) ?? []),
             ...(round.executionGroup?.lanes.map(({ roleName }) => roleName) ?? [])
         ];
     }