@zq-silk/yui 2.3.0 → 2.4.0

package/dist/kernel/builtinCapabilities.js

@@ -59,7 +59,8 @@ const definitions = [
     {
         name: "artifact.save", summary: "Save a file artifact by relativePath into the Task's local Git repository; returns a commit-pinned reference.",
         effect: "local-mutation", requiredPermissions: ["task:read"], source: "artifacts.saveArtifactCapability",
-        inputSchema: object({ taskId: text, relativePath: text, content: { type: "string" }, message: text, expectedHead: text }, ["taskId", "relativePath", "content"]),
+        inputSchema: object({ taskId: text, relativePath: text, content: { type: "string" },
+            encoding: { enum: ["utf8", "base64"] }, message: text, expectedHead: text }, ["taskId", "relativePath", "content"]),
         outputSchema: { type: "object", required: ["taskId", "commit", "relativePath"] }
     },
     {
@@ -319,6 +320,7 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
             if (name === "artifact.save")
                 return saveArtifactCapability(store.rootDirectory(), taskId, {
                     relativePath: params.relativePath, content: params.content,
+                    ...(params.encoding === undefined ? {} : { encoding: params.encoding }),
                     ...(params.message === undefined ? {} : { message: params.message }),
                     ...(params.expectedHead === undefined ? {} : { expectedHead: params.expectedHead })
                 });

package/dist/message/message.js

@@ -42,6 +42,9 @@ export function createTaskMessage(id, taskId, body, kind, author, now, context =
             : { inputControl: {
                     action: context.inputControl.action,
                     requestId: requireSafeIdentity(context.inputControl.requestId, "Message input requestId"),
+                    ...(context.inputControl.expectedSessionId === undefined ? {} : {
+                        expectedSessionId: requireText(context.inputControl.expectedSessionId, "Message Session")
+                    }),
                     ...(context.inputControl.expectedTarget === undefined
                         ? {} : { expectedTarget: requireText(context.inputControl.expectedTarget, "Message input expectedTarget") })
                 } }),
@@ -236,6 +239,8 @@ export function validateTaskMessage(message) {
             throw new Error(`Message input action is invalid: ${String(message.inputControl.action)}.`);
         }
         requireSafeIdentity(message.inputControl.requestId, "Message input requestId");
+        if (message.inputControl.expectedSessionId !== undefined)
+            requireText(message.inputControl.expectedSessionId, "Message Session");
         if (message.inputControl.expectedTarget !== undefined) {
             requireText(message.inputControl.expectedTarget, "Message input expectedTarget");
             if (message.inputControl.action !== "steer") {
@@ -317,7 +322,11 @@ export function validateTaskMessage(message) {
             throw new Error("A recipient requires an exact WorkItem or ReviewRound.");
         }
     }
-    if (message.continuation !== undefined && message.recipient?.ownerRunId === undefined) {
+    const selectedSessionNondelivery = message.inputControl?.action === "queue"
+        && message.inputControl.expectedSessionId !== undefined
+        && message.continuation?.runId === undefined
+        && message.continuation?.notDeliveredReason !== undefined;
+    if (message.continuation !== undefined && message.recipient?.ownerRunId === undefined && !selectedSessionNondelivery) {
         throw new Error("Message continuation requires an owner Assignment.");
     }
     if (message.continuation?.runId !== undefined) {
@@ -373,6 +382,9 @@ export function createGlobalRoleMessage(id, roleName, body, kind, author, now, c
             : { inputControl: {
                     action: context.inputControl.action,
                     requestId: requireSafeIdentity(context.inputControl.requestId, "Message input requestId"),
+                    ...(context.inputControl.expectedSessionId === undefined ? {} : {
+                        expectedSessionId: requireText(context.inputControl.expectedSessionId, "Message Session")
+                    }),
                     ...(context.inputControl.expectedTarget === undefined
                         ? {} : { expectedTarget: requireText(context.inputControl.expectedTarget, "Message input expectedTarget") })
                 } }),
@@ -404,6 +416,8 @@ export function validateGlobalRoleMessage(message) {
             throw new Error(`Message input action is invalid: ${String(message.inputControl.action)}.`);
         }
         requireSafeIdentity(message.inputControl.requestId, "Message input requestId");
+        if (message.inputControl.expectedSessionId !== undefined)
+            requireText(message.inputControl.expectedSessionId, "Message Session");
         if (message.inputControl.expectedTarget !== undefined) {
             requireText(message.inputControl.expectedTarget, "Message input expectedTarget");
             if (message.inputControl.action !== "steer") {

package/dist/output/rolePresentation.js

@@ -22,7 +22,10 @@ export function renderRoleLaunchComparison(role, effective) {
             permission(binding),
             current.defaultAccess
         ];
-    }), defaultTableWidth());
+    }), defaultTableWidth()) + "\n\nSkill package evidence:\n" + (effective.skillPackages === undefined
+        ? "  Legacy / externally recorded: complete package versions were not recorded."
+        : effective.skillPackages.map(skill => `  ${skill.id} @ ${skill.digest}\n    ${skill.source.kind}: ${skill.source.path}\n`
+            + `    ${skill.fileCount} files; ${skill.byteSize} bytes; inventory: ${skill.manifestPath}`).join("\n"));
 }
 export function activeRoleSummary(role) {
     const binding = role.agentBindings[role.activeAgentId];

package/dist/repository/executionLaneGitSnapshot.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { isDeepStrictEqual } from "node:util";
+import { supportedGit } from "./gitCompatibility.js";
 /**
  * Freeze the exact committed heads of a durable managed Lane workspace at the
  * synchronous runtime-terminalization boundary, before opening the result
@@ -67,7 +68,7 @@ export function snapshotExecutionLaneWorkspaceSync(store, workspace) {
 }
 function git(cwd, args) {
     try {
-        return execFileSync("git", args, {
+        return execFileSync(supportedGit().path, args, {
             cwd,
             encoding: "utf8",
             timeout: 5_000,

package/dist/repository/gitCompatibility.js

@@ -0,0 +1,62 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { resolveExecutable } from "../external/pinnedCommandRunner.js";
+// The fetch isolation boundary needs --no-write-fetch-head. Older Git cannot
+// implement it by saving/restoring FETCH_HEAD without racing another writer.
+export const MINIMUM_GIT_VERSION = "2.29.0";
+export function gitVersionSupport(output) {
+    const match = /^git version (\d+)\.(\d+)(?:\.(\d+))?(?:[.\s-].*)?$/u.exec(output.trim());
+    const version = match === null ? "unknown" : `${match[1]}.${match[2]}.${match[3] ?? "0"}`;
+    const supported = match !== null && (Number(match[1]) > 2
+        || (Number(match[1]) === 2 && Number(match[2]) >= 29));
+    return {
+        version, supported,
+        detail: `Git ${version}; requires >= ${MINIMUM_GIT_VERSION} (isolated fetch without writing FETCH_HEAD). `
+            + "Read-only version check; repository permissions, transport and server capabilities are not tested."
+    };
+}
+let cached;
+/** Pin the executable checked, reusing only an unchanged on-disk identity. */
+export function supportedGit() {
+    const selected = resolveExecutable("git", process.env.PATH);
+    if (selected === undefined)
+        throw new Error("Git executable not found in PATH; install a supported Git before retrying. No Git operation was started.");
+    const path = realpathSync(selected);
+    const stat = statSync(path);
+    const identity = `${path}:${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+    if (cached?.identity === identity)
+        return cached;
+    const output = execFileSync(path, ["--version"], {
+        encoding: "utf8", timeout: 5_000, stdio: ["ignore", "pipe", "pipe"]
+    });
+    const support = gitVersionSupport(output);
+    if (!support.supported) {
+        throw new Error(`${path}: ${support.detail} No Git operation was started by this call. `
+            + "Select a supported Git in PATH, run doctor, then retry; existing resources are retained.");
+    }
+    cached = { identity, path, version: support.version };
+    return cached;
+}
+/** Git paths are relative to the actual -C directory, not the Node process. */
+export function gitOutputLine(output) {
+    if (!output.endsWith("\n") || output.length === 1 || output.includes("\0")) {
+        throw new Error("Git returned an invalid path or line.");
+    }
+    // Remove exactly Git's record terminator, never spaces/tabs in a path.
+    return output.slice(0, -1);
+}
+/** rev-parse --verify accepts exactly one validated operand on old Git.
+ * Keep option-looking data out before removing the newer option terminator.
+ */
+export function compatibleGitArguments(args) {
+    const marker = args.indexOf("--end-of-options");
+    if (marker < 0)
+        return [...args];
+    const operand = args[marker + 1];
+    if (!args.includes("rev-parse") || !args.includes("--verify")
+        || marker !== args.length - 2 || operand === undefined
+        || operand.length === 0 || operand.startsWith("-") || /[\0\r\n]/u.test(operand)) {
+        throw new Error("Unsafe Git revision operand; no Git operation was started.");
+    }
+    return [...args.slice(0, marker), operand];
+}

package/dist/repository/gitWorkspace.js

@@ -5,7 +5,13 @@ import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { cleanupFailure } from "../workspace/cleanupInspection.js";
 import { externalProgramConfigViolations } from "../artifacts/managedGit.js";
+import { compatibleGitArguments, gitOutputLine, supportedGit } from "./gitCompatibility.js";
+import { gitPath, readGitWorktrees } from "./gitWorktreeInventory.js";
 const executeFile = promisify(execFile);
+const isolatedFetchOptions = [
+    "--no-tags", "--no-prune", "--no-prune-tags", "--no-recurse-submodules",
+    "--no-auto-gc", "--no-write-commit-graph", "--no-write-fetch-head", "--refmap="
+];
 /** Observed partial effects, not a rollback or permission to replay a refresh. */
 export class GitWorkspaceRefreshError extends Error {
     result;
@@ -160,13 +166,13 @@ export class NodeGitWorkspace {
         const remote = safeRemote(input.remoteUrl);
         const configuredBranch = await safeFetchBranch(input.branch);
         const branch = configuredBranch === "HEAD"
-            ? await resolveRemoteHeadBranch(remote)
+            ? await resolveRemoteHeadBranch(remote, repositoryPath)
             : configuredBranch;
         const fetchedRef = remoteBaselineRef(remote, branch);
         try {
             await git([
                 "-C", repositoryPath,
-                "fetch", "--no-tags", "--no-write-fetch-head",
+                "fetch", ...isolatedFetchOptions,
                 remote,
                 `refs/heads/${branch}:${fetchedRef}`
             ]);
@@ -212,8 +218,7 @@ export class NodeGitWorkspace {
             // An empty refmap disables opportunistic tracking updates even when the
             // Project URL is a named remote. Ignore configured prune/submodule effects.
             await git([
-                "-C", initial.root, "fetch", "--no-tags", "--no-prune", "--no-prune-tags",
-                "--no-recurse-submodules", "--no-auto-maintenance", "--no-write-fetch-head", "--refmap=",
+                "-C", initial.root, "fetch", ...isolatedFetchOptions,
                 remote, `refs/heads/${stableBranch}:${temporaryRef}`
             ]);
             fetchedCommit = await resolveFetchedCommit(initial.root, temporaryRef);
@@ -239,11 +244,11 @@ export class NodeGitWorkspace {
                 // Verify the stable branch and CAS the one configured destination in
                 // the same Git transaction. HEAD/index/worktree still use normal ff.
                 await git(["-C", initial.root, "update-ref", "--stdin"], { input: [
-                        "start", "option no-deref",
+                        "option no-deref",
                         `verify refs/heads/${stableBranch} ${fetchedCommit}`,
                         "option no-deref",
                         `update ${mapping.ref} ${fetchedCommit} ${old}`,
-                        "prepare", "commit", ""
+                        ""
                     ].join("\n") });
                 tracking = {
                     status: previous === fetchedCommit ? "current" : "updated",
@@ -305,15 +310,15 @@ export class NodeGitWorkspace {
     async resolveRemoteBaseline(input) {
         const remote = safeRemote(input.remoteUrl);
         const configuredRef = await safeFetchBranch(input.developmentRef);
+        const repository = await this.inspect(input.repositoryPath, "HEAD");
         const branch = configuredRef === "HEAD"
-            ? await resolveRemoteHeadBranch(remote)
+            ? await resolveRemoteHeadBranch(remote, repository.root)
             : configuredRef;
-        const repository = await this.inspect(input.repositoryPath, "HEAD");
         const temporaryRef = remoteBaselineRef(remote, branch);
         try {
             await git([
                 "-C", repository.root,
-                "fetch", "--no-tags", "--no-write-fetch-head",
+                "fetch", ...isolatedFetchOptions,
                 remote,
                 `refs/heads/${branch}:${temporaryRef}`
             ]);
@@ -321,7 +326,7 @@ export class NodeGitWorkspace {
                 "-C", repository.root,
                 "rev-parse", "--verify", "--end-of-options", `${temporaryRef}^{commit}`
             ]);
-            const advertisedCommit = await resolveRemoteBranchCommit(remote, branch);
+            const advertisedCommit = await resolveRemoteBranchCommit(remote, branch, repository.root);
             if (fetchedCommit.toLowerCase() !== advertisedCommit) {
                 throw new Error(`Project remote development branch changed while it was fetched: ${branch}.`);
             }
@@ -341,8 +346,10 @@ export class NodeGitWorkspace {
         }
     }
     async clone(input) {
+        supportedGit();
         const remote = safeRemote(input.remoteUrl);
-        const destination = resolve(requireText(input.destination, "Project destination"));
+        requireText(input.destination, "Project destination");
+        const destination = resolve(input.destination);
         if (await pathKind(destination) !== undefined) {
             throw new Error(`Project destination already exists: ${destination}.`);
         }
@@ -415,10 +422,8 @@ export class NodeGitWorkspace {
     async inspect(repositoryPath, baseRef = "HEAD") {
         const requested = await canonicalDirectory(repositoryPath, "Project");
         const ref = safeRef(baseRef);
-        const root = await canonicalDirectory(await gitLine(["-C", requested, "rev-parse", "--show-toplevel"]), "Project root");
-        const gitDirectory = await canonicalDirectory(await gitLine([
-            "-C", root, "rev-parse", "--path-format=absolute", "--git-common-dir"
-        ]), "Git common directory");
+        const root = await canonicalDirectory(await gitPath(requested, ["--show-toplevel"]), "Project root");
+        const gitDirectory = await canonicalDirectory(await gitPath(root, ["--git-common-dir"]), "Git common directory");
         const baseCommit = await gitLine([
             "-C", root, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`
         ]);
@@ -485,7 +490,7 @@ export class NodeGitWorkspace {
                 const importedRef = `${importRoot}/${index}`;
                 await git([
                     "-C", destination.root,
-                    "fetch", "--no-tags", "--no-write-fetch-head", "--",
+                    "fetch", ...isolatedFetchOptions, "--",
                     source.root, `${snapshot.ref}:${importedRef}`
                 ]);
                 const imported = await resolveRefCommit(destination.root, importedRef);
@@ -567,36 +572,11 @@ export class NodeGitWorkspace {
         const excluded = input.excludeWorktreePath === undefined
             ? undefined
             : await realpath(resolve(input.excludeWorktreePath)).catch(() => undefined);
-        const porcelain = await git(["-C", root, "worktree", "list", "--porcelain"]);
-        const records = [];
-        let current = { prunable: false };
-        for (const line of porcelain.split("\n")) {
-            if (line.length === 0) {
-                const path = current.path;
-                if (path !== undefined) {
-                    records.push({ path, branch: current.branch, prunable: current.prunable });
-                }
-                current = { prunable: false };
-                continue;
-            }
-            if (line.startsWith("worktree ")) {
-                current.path = line.slice("worktree ".length);
-            }
-            else if (line.startsWith("branch ")) {
-                current.branch = line.slice("branch ".length);
-            }
-            else if (line.startsWith("prunable")) {
-                current.prunable = true;
-            }
-        }
-        const lastPath = current.path;
-        if (lastPath !== undefined) {
-            records.push({ path: lastPath, branch: current.branch, prunable: current.prunable });
-        }
+        const records = await readGitWorktrees(root);
         for (const record of records) {
             // A dead registration (its directory is gone) occupies nothing; a
             // worktree on another ref or a detached HEAD does not occupy this one.
-            if (record.prunable || record.branch !== wanted)
+            if ((record.prunable && !record.locked) || record.branch !== wanted)
                 continue;
             // git reports canonical absolute paths; compare canonicals so a
             // symlinked workspace root cannot make the recorded worktree look
@@ -724,11 +704,7 @@ export class NodeGitWorkspace {
     }
     async listWorktrees(repositoryPath) {
         const root = await canonicalDirectory(repositoryPath, "Project");
-        const output = await git(["-C", root, "worktree", "list", "--porcelain"]);
-        return output
-            .split(/\r?\n/u)
-            .filter((line) => line.startsWith("worktree "))
-            .map((line) => line.slice("worktree ".length).trim());
+        return (await readGitWorktrees(root)).map(entry => entry.path);
     }
     async listCommitsBetween(input) {
         const root = await canonicalDirectory(input.repositoryPath, "Project");
@@ -919,9 +895,8 @@ export class NodeGitWorkspace {
         await assertExpectedBranch(expected, input.branch);
         if (!await this.inspectClean(expected))
             return "dirty";
-        const worktrees = (await git(["-C", expected, "worktree", "list", "--porcelain", "-z"]))
-            .split("\0").filter(line => line.startsWith("worktree "));
-        if (worktrees.length !== 1 || worktrees[0] !== `worktree ${expected}`) {
+        const worktrees = await readGitWorktrees(expected);
+        if (worktrees.length !== 1 || worktrees[0].path !== expected) {
             cleanupFailure("git-worktree-registrations", "Task clone still owns Git worktree registrations; retained.", 1, worktrees.length);
         }
         return "clean";
@@ -1051,16 +1026,14 @@ async function removeMissingWorktreeRegistration(repositoryRoot, path, branch, a
     await git(["-C", repositoryRoot, "worktree", "remove", "--force", "--", path]);
 }
 async function inspectMissingWorktreeRegistration(repositoryRoot, path, branch, allowDetached = false) {
-    const records = (await git(["-C", repositoryRoot, "worktree", "list", "--porcelain", "-z"])).split("\0\0");
-    const fields = records.map(record => record.split("\0")).find(record => record.includes(`worktree ${path}`));
-    if (fields === undefined)
+    const entry = (await readGitWorktrees(repositoryRoot)).find(record => record.path === path);
+    if (entry === undefined)
         return false;
-    const pinnedDetached = allowDetached && fields.includes("detached")
+    const pinnedDetached = allowDetached && entry.detached
         && await gitSucceeds(["-C", repositoryRoot, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`])
-        && fields.includes(`HEAD ${await resolveRefCommit(repositoryRoot, `refs/heads/${branch}`)}`);
-    if ((!fields.includes(`branch refs/heads/${branch}`) && !pinnedDetached) || fields.some(field => field.startsWith("locked"))) {
-        cleanupFailure("git-registration-mismatch", "Missing worktree has uncertain or locked Git ownership; metadata retained.", { branch, locked: false }, { branch: fields.find(field => field.startsWith("branch "))?.slice(7) ?? null,
-            locked: fields.some(field => field.startsWith("locked")) });
+        && entry.head === await resolveRefCommit(repositoryRoot, `refs/heads/${branch}`);
+    if ((entry.branch !== `refs/heads/${branch}` && !pinnedDetached) || entry.locked) {
+        cleanupFailure("git-registration-mismatch", "Missing worktree has uncertain or locked Git ownership; metadata retained.", { branch, locked: false }, { branch: entry.branch ?? null, locked: entry.locked });
     }
     return true;
 }
@@ -1103,8 +1076,7 @@ async function assertExpectedBranch(path, expected, allowRebase = false) {
         // Rebase temporarily detaches HEAD. Git's per-worktree metadata must still
         // identify this exact Integration branch; unrelated detachment is invalid.
         for (const backend of ["rebase-merge", "rebase-apply"]) {
-            const headNamePath = await gitLine(["-C", path, "rev-parse", "--path-format=absolute",
-                "--git-path", `${backend}/head-name`]);
+            const headNamePath = await gitPath(path, ["--git-path", `${backend}/head-name`]);
             let headName;
             try {
                 headName = (await readFile(headNamePath, "utf8")).trim();
@@ -1135,10 +1107,10 @@ async function assertOwnedWorktree(project, container, path) {
     assertContained(container, canonicalPath);
     if (canonicalPath !== path)
         throw new Error("Managed worktree resolves through a symbolic link.");
-    const root = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--show-toplevel"]), "Managed worktree root");
+    const root = await canonicalDirectory(await gitPath(path, ["--show-toplevel"]), "Managed worktree root");
     if (root !== path)
         throw new Error("Managed worktree root does not match its deterministic path.");
-    const common = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"]), "Managed Git common directory");
+    const common = await canonicalDirectory(await gitPath(path, ["--git-common-dir"]), "Managed Git common directory");
     if (common !== project.gitDirectory) {
         cleanupFailure("workspace-identity-mismatch", "Managed worktree belongs to another project.", "Task main Git common directory", "different Git common directory");
     }
@@ -1162,7 +1134,7 @@ async function inspectExactRecordedWorktree(input) {
     if (path !== expectedPath) {
         throw new Error("Recorded managed worktree resolves through a symbolic link.");
     }
-    const root = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--show-toplevel"]), "Recorded managed worktree root");
+    const root = await canonicalDirectory(await gitPath(path, ["--show-toplevel"]), "Recorded managed worktree root");
     if (root !== path) {
         throw new Error("Recorded managed worktree root does not match its deterministic path.");
     }
@@ -1170,7 +1142,7 @@ async function inspectExactRecordedWorktree(input) {
     if (branch !== input.branch) {
         throw new Error(`Recorded managed worktree is on an unexpected branch: ${branch}.`);
     }
-    const gitDirectory = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"]), "Recorded managed Git common directory");
+    const gitDirectory = await canonicalDirectory(await gitPath(path, ["--git-common-dir"]), "Recorded managed Git common directory");
     const destination = await new NodeGitWorkspace().inspect(input.repositoryPath);
     const head = await resolveRefCommit(path, "HEAD");
     const retained = await resolveRefCommit(destination.root, `refs/heads/${input.branch}`);
@@ -1267,8 +1239,8 @@ async function cleanupContainer(path) {
     }
 }
 async function canonicalDirectory(path, label) {
-    const value = requireText(path, label);
-    const canonical = await realpath(isAbsolute(value) ? value : resolve(value));
+    requireText(path, label);
+    const canonical = await realpath(isAbsolute(path) ? path : resolve(path));
     return canonical;
 }
 function managedPath(container, directory) {
@@ -1307,7 +1279,7 @@ async function readWorktreeStatus(path) {
     return readStatusGit(path, ["status", "--porcelain=v1", "--untracked-files=all"]);
 }
 async function readStatusGit(path, args) {
-    return git(["--no-optional-locks", "-c", "core.fsmonitor=false",
+    return git(["--no-optional-locks", "-c", "core.fsmonitor=",
         "-c", "protocol.allow=never", "-c", "protocol.file.allow=never",
         "-C", path, ...args], { environment: { GIT_NO_LAZY_FETCH: "1" } });
 }
@@ -1353,8 +1325,10 @@ async function assertStatusProgramsAbsent(path) {
     }
 }
 async function git(args, options = {}) {
+    const program = supportedGit();
+    const invocation = compatibleGitArguments(args);
     try {
-        const execution = executeFile("git", [...args], {
+        const execution = executeFile(program.path, invocation, {
             encoding: "utf8",
             maxBuffer: 1024 * 1024,
             timeout: 30_000,
@@ -1375,6 +1349,7 @@ async function git(args, options = {}) {
     }
 }
 async function gitSucceeds(args) {
+    supportedGit();
     try {
         await git(args);
         return true;
@@ -1384,7 +1359,7 @@ async function gitSucceeds(args) {
     }
 }
 async function gitLine(args) {
-    const lines = (await git(args)).trimEnd().split("\n");
+    const lines = gitOutputLine(await git(args)).split("\n");
     if (lines.length !== 1 || lines[0]?.length === 0 || lines[0]?.includes("\0")) {
         throw new Error("Git returned invalid output.");
     }
@@ -1533,6 +1508,7 @@ function safeRef(value) {
     return ref;
 }
 async function safeFetchBranch(value) {
+    supportedGit();
     const configuredRef = safeRef(value);
     if (configuredRef === "HEAD")
         return configuredRef;
@@ -1624,7 +1600,8 @@ function isCommit(value) {
     return /^[a-f0-9]{40}(?:[a-f0-9]{24})?$/iu.test(value);
 }
 function safeRemote(value) {
-    const remote = requireText(value, "Git remote URL");
+    requireText(value, "Git remote URL");
+    const remote = value;
     if (remote.startsWith("-") || /[\r\n]/.test(remote)) {
         throw new Error("Git remote URL is invalid.");
     }

package/dist/repository/gitWorktreeInventory.js

@@ -0,0 +1,121 @@
+import { execFile } from "node:child_process";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { gitOutputLine, supportedGit } from "./gitCompatibility.js";
+const execute = promisify(execFile);
+async function run(args) {
+    return (await execute(supportedGit().path, args, {
+        encoding: "utf8", timeout: 10_000, maxBuffer: 1024 * 1024
+    })).stdout;
+}
+export async function gitPath(cwd, args) {
+    return resolve(cwd, gitOutputLine(await run(["-C", cwd, "rev-parse", ...args])));
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+/**
+ * Old porcelain omits locks and does not delimit/quote arbitrary paths. Read
+ * Git's worktree administrative records instead. These are observations only:
+ * never write/prune them, and never infer ownership merely from a directory.
+ * Mutating consumers still check the recorded owner and ask Git to remove it.
+ */
+export async function readGitWorktrees(cwd) {
+    const common = await realpath(await gitPath(cwd, ["--git-common-dir"]));
+    const result = [];
+    // This is also Git's own main-worktree listing convention (including bare
+    // and separate-git-dir repositories), not a claim of managed ownership.
+    const main = basename(common) === ".git" ? dirname(common) : common;
+    result.push(await inspect(common, main, false));
+    const directory = join(common, "worktrees");
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return result;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            throw new Error(`Uncertain Git worktree administration: ${join(directory, entry.name)}; retained.`);
+        const admin = join(directory, entry.name);
+        const pointer = gitOutputLine(await readFile(join(admin, "gitdir"), "utf8"));
+        if (basename(pointer) !== ".git") {
+            throw new Error(`Invalid Git worktree back-pointer: ${admin}; retained.`);
+        }
+        // Relative back-pointers are based at the administrative directory,
+        // not the caller's cwd (Git's worktree.useRelativePaths setting).
+        const path = dirname(resolve(admin, pointer));
+        const adminCommon = await realpath(resolve(cwd, gitOutputLine(await run([
+            "-C", cwd, `--git-dir=${admin}`, "rev-parse", "--git-common-dir"
+        ]))));
+        if (adminCommon !== common)
+            throw new Error(`Git worktree common directory mismatch: ${admin}; retained.`);
+        if (await exists(path)) {
+            const actual = await realpath(await gitPath(path, ["--git-dir"]));
+            if (actual !== admin)
+                throw new Error(`Git worktree back-pointer mismatch: ${path}; retained.`);
+        }
+        result.push(await inspect(admin, path, true));
+    }
+    if (new Set(result.map(entry => entry.path)).size !== result.length) {
+        throw new Error("Duplicate Git worktree registrations; retained.");
+    }
+    return result;
+}
+async function inspect(admin, path, linked) {
+    // Ask Git rather than parsing HEAD: Git owns ref storage (including newer
+    // backends), symbolic resolution and per-worktree pseudorefs.
+    let branch;
+    try {
+        branch = gitOutputLine(await run([`--git-dir=${admin}`, "symbolic-ref", "--quiet", "HEAD"]));
+    }
+    catch (error) {
+        if (error.code !== 1)
+            throw error;
+    }
+    if (branch !== undefined && !branch.startsWith("refs/")) {
+        throw new Error(`Invalid Git worktree HEAD: ${admin}; retained.`);
+    }
+    let head;
+    try {
+        head = gitOutputLine(await run([`--git-dir=${admin}`, "rev-parse", "--verify", "HEAD"]));
+        if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/iu.test(head))
+            throw new Error("Invalid Git HEAD");
+    }
+    catch (error) {
+        // A genuinely unborn branch (main or linked) is valid discovery, not cleanup proof.
+        if (branch === undefined)
+            throw error;
+        try {
+            await run([`--git-dir=${admin}`, "show-ref", "--verify", "--quiet", branch]);
+        }
+        catch (missing) {
+            if (missing.code === 1) {
+                return {
+                    path, branch, detached: false, prunable: !await exists(path),
+                    locked: linked && await exists(join(admin, "locked"))
+                };
+            }
+            throw missing;
+        }
+        throw error;
+    }
+    return {
+        path, ...(head === undefined ? {} : { head }),
+        ...(branch === undefined ? {} : { branch }),
+        detached: branch === undefined, prunable: !await exists(path),
+        locked: linked && await exists(join(admin, "locked"))
+    };
+}