@zq-silk/yui 0.14.0 → 0.14.2

package/dist/executor/fileRoleLaunchPlanner.js

@@ -16,7 +16,7 @@ import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.j
 import { classifyWorkspacePreflight, formatWorkspacePreflightError } from "./workspacePreflightClassification.js";
 import { activeLiveRoleAgentSession } from "./agentExecutor.js";
 import { effectiveLaunchSnapshotsCompatibleForTaskSession, effectiveLaunchSnapshotsCompatible, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeState, createExactControlPlaneDescriptor, createExactTaskRuntimeDescriptor, exactControlPlaneDigest, exactTaskRuntimeDescriptorPath, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
+import { YUI_CONTROL_PLANE_DESCRIPTOR, createExactControlPlaneDescriptor, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
 import { detectRunningRelease } from "../release/runtimeRelease.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
@@ -87,49 +87,6 @@ export class FileRoleLaunchPlanner {
         const hash = createHash("sha256").update(input.callerKey).digest("hex");
         this.store.setJobCallerKeyHash(input.taskId, input.roleName, input.agentId, hash);
     }
-    /** Re-publishes provider-discovered native identity after its durable fold. */
-    refreshTaskRuntimeDescriptor(input) {
-        const task = this.store.getTask(input.taskId);
-        const role = this.store.getRole(input.taskId, input.roleName);
-        if (task === null
-            || task.status !== "active"
-            || task.executionGate.state !== "enabled"
-            || role === null) {
-            throw new Error(`Task runtime is not current: ${input.taskId}/${input.roleName}.`);
-        }
-        const run = this.store.getActiveTurn(input.taskId, input.roleName);
-        const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
-        const session = sessions?.sessions[role.activeAgentId];
-        if (session === undefined || session.launchId === undefined) {
-            throw new Error(`Task runtime native Session is not ready: ${input.taskId}/${input.roleName}.`);
-        }
-        const effective = run?.effective ?? session.effective;
-        const descriptor = createExactTaskRuntimeDescriptor({
-            controlPlaneDigest: exactControlPlaneDigest(this.#controlPlane),
-            taskId: input.taskId,
-            roleName: input.roleName,
-            agentId: session.agentId,
-            adapterId: session.adapterId,
-            workspace: effective.workspace.root,
-            ...(run === null ? {} : { turnId: run.id }),
-            launchId: session.launchId,
-            nativeSessionId: session.nativeSessionId
-        });
-        if (descriptor.turnId !== input.turnId
-            || descriptor.launchId !== input.launchId
-            || descriptor.nativeSessionId !== input.nativeSessionId
-            || descriptor.agentId !== input.agentId
-            || descriptor.adapterId !== input.adapterId
-            || descriptor.workspace !== canonicalPath(input.workspace)) {
-            throw new Error("Prepared Task runtime generation is not current.");
-        }
-        assertExactTaskRuntimeState(descriptor, this.store);
-        // Publish only the current-control source. A reused native pane keeps its
-        // own stable source path; its Hook self-refreshes that source before the
-        // volatile fence instead of the Controller scanning history to find it.
-        const currentSource = exactTaskRuntimeDescriptorPath(this.home, descriptor);
-        this.#writeExactTaskRuntimeDescriptor(descriptor, currentSource);
-    }
     plan(input) {
         const task = this.store.getTask(input.taskId);
         if (task === null)
@@ -257,7 +214,7 @@ export class FileRoleLaunchPlanner {
         const launchRole = effectiveRoleForLaunch(role, effective);
         const binding = activeRoleAgentBinding(launchRole);
         if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
-            throw new Error(`Role launch identity changed: ${role.name}.`);
+            throw new Error(`Role runtime generation identity changed: ${role.name}.`);
         }
         const configured = this.store.getConfiguredAgent(input.agentId);
         if (configured === null)
@@ -297,7 +254,7 @@ export class FileRoleLaunchPlanner {
         if (runtimeIsolation !== undefined && (owner.scope !== "task"
             || runtimeIsolation.taskId !== owner.taskId
             || runtimeIsolation.workspace.root !== effectiveWorkspace
-            || runtimeIsolation.generation.launchId !== input.launchId)) {
+            || runtimeIsolation.generation.runtimeGenerationId !== input.runtimeGenerationId)) {
             throw new Error("Role launch does not match its Task runtime isolation descriptor.");
         }
         Object.assign(launchEnvironment, runtimeIsolation === undefined
@@ -374,9 +331,9 @@ export class FileRoleLaunchPlanner {
             : {};
         const preallocatedNativeSessionId = binding.adapterId === "claude"
             && resumeNativeSessionId === undefined
-            ? requireText(input.launchId === undefined
+            ? requireText(input.runtimeGenerationId === undefined
                 ? this.#createNativeSessionId()
-                : nativeSessionIdForLaunch(this.home, input.launchId, input.agentId, input.adapterId), "Native session id")
+                : nativeSessionIdForLaunch(this.home, input.runtimeGenerationId, input.agentId, input.adapterId), "Native session id")
             : resumeNativeSessionId;
         const managedCompiled = managedControl
             ? adapter.compileManagedControl(compileInput, launchMode, preallocatedNativeSessionId)
@@ -443,27 +400,6 @@ export class FileRoleLaunchPlanner {
         if (managedClaudeRun && (managedRun === null || managedRun.status !== "active")) {
             throw new Error(`Managed Claude Turn is no longer active: ${input.turnId}.`);
         }
-        const runtimeDescriptor = owner.scope === "task"
-            ? createExactTaskRuntimeDescriptor({
-                controlPlaneDigest: exactControlPlaneDigest(this.#controlPlane),
-                taskId: owner.taskId,
-                roleName: role.name,
-                agentId: configured.id,
-                adapterId: configured.adapterId,
-                workspace: effectiveWorkspace,
-                ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
-                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-                ...(session === null
-                    ? {}
-                    : { nativeSessionId: session.nativeSessionId })
-            })
-            : undefined;
-        const runtimeDescriptorSource = runtimeDescriptor === undefined
-            ? undefined
-            : exactTaskRuntimeDescriptorPath(this.home, runtimeDescriptor);
-        if (runtimeDescriptor !== undefined && runtimeDescriptorSource !== undefined) {
-            this.#writeExactTaskRuntimeDescriptor(runtimeDescriptor, runtimeDescriptorSource);
-        }
         // Generate a candidate per-Provider-process DurableJob caller key for
         // every task-scope launch. A reused live Conversation keeps the key that
         // its process inherited; a new Host or a Conversation replacement commits
@@ -479,7 +415,7 @@ export class FileRoleLaunchPlanner {
             throw new Error(`Managed Turn is no longer active: ${input.turnId}.`);
         }
         const providerAuthority = managedControl
-            ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId, input.mode)
+            ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.runtimeGenerationId, input.mode)
             : undefined;
         const providerOwnedTurn = managedControl && input.mode === "resume"
             ? this.#providerOwnedTurnForLaunch(owner.taskId, role.name, input.turnId)
@@ -537,11 +473,10 @@ export class FileRoleLaunchPlanner {
                 YUI_SESSION_MANIFEST: sessionContext.sessionManifestPath,
                 YUI_SESSION_CLI: sessionContext.sessionCliPath,
                 ...(jobCallerKey === undefined ? {} : { YUI_JOB_CALLER_KEY: jobCallerKey }),
-                ...(runtimeDescriptor === undefined
+                ...(owner.scope !== "task"
                     ? {}
                     : {
-                        [YUI_CONTROL_PLANE_DESCRIPTOR]: serializeExactDescriptor(this.#controlPlane),
-                        [YUI_TASK_RUNTIME_DESCRIPTOR]: runtimeDescriptorSource
+                        [YUI_CONTROL_PLANE_DESCRIPTOR]: serializeExactDescriptor(this.#controlPlane)
                     }),
                 ...(sessionTitle === undefined
                     ? {}
@@ -554,10 +489,13 @@ export class FileRoleLaunchPlanner {
                             }
                             : {})
                     }),
-                ...(input.launchId === undefined
+                ...(input.runtimeGenerationId === undefined
                     ? {}
-                    : { YUI_LAUNCH_ID: input.launchId }),
-                ...(input.turnId === undefined ? {} : { YUI_TURN_ID: input.turnId }),
+                    : { YUI_RUNTIME_GENERATION_ID: input.runtimeGenerationId }),
+                // No Turn is exported into the Session environment. A native pane
+                // outlives its Turn, so a Turn id frozen here would be stale for every
+                // later Turn. The Agent Host sets it explicitly per spawned Provider
+                // Turn, and every durable decision reads the active Turn from state.
                 ...(session === null
                     ? {}
                     : { YUI_NATIVE_SESSION_ID: session.nativeSessionId })
@@ -567,7 +505,13 @@ export class FileRoleLaunchPlanner {
         const scopedLaunch = owner.scope === "task"
             ? this.#applyWorkspaceScope(owner.taskId, role, launch, workspaceOverride)
             : launch;
-        const ordinaryConversationLaunch = withCodexThreadEnvironment(scopedLaunch);
+        const sharedDaemonLaunch = owner.scope === "global" && configured.adapterId === "codex"
+            ? {
+                ...scopedLaunch,
+                args: addCodexSharedDaemonRemote(scopedLaunch.args, launchMode, scopedLaunch.env)
+            }
+            : scopedLaunch;
+        const ordinaryConversationLaunch = withCodexThreadEnvironment(sharedDaemonLaunch);
         return {
             role: {
                 name: role.name,
@@ -579,8 +523,8 @@ export class FileRoleLaunchPlanner {
             ...(sessionTitle === undefined ? {} : { sessionTitle })
         };
     }
-    #providerAuthorityForLaunch(taskId, roleName, launchId, mode) {
-        const activationId = requireText(launchId, "Managed Provider Activation id");
+    #providerAuthorityForLaunch(taskId, roleName, runtimeGenerationId, mode) {
+        const activationId = requireText(runtimeGenerationId, "Managed Provider Activation id");
         const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
         if (binding === null || binding === undefined) {
             return { epoch: 1, owner: "controller", holderId: activationId };
@@ -647,10 +591,6 @@ export class FileRoleLaunchPlanner {
             }
         };
     }
-    #writeExactTaskRuntimeDescriptor(descriptor, sourcePath) {
-        writeTextFileAtomically(sourcePath, `${serializeExactDescriptor(descriptor)}\n`);
-        this.#resourceRegistrar().registerExactTaskRuntimeDescriptor(descriptor, sourcePath);
-    }
     #selectConfiguredAgentEnvironment(source) {
         const selected = {};
         for (const agent of this.store.listConfiguredAgents()) {
@@ -830,6 +770,34 @@ function addCodexSessionNotify(args, mode, cliPath) {
     }
     return [...args.slice(0, -2), ...managed, ...args.slice(-2)];
 }
+/**
+ * Global Codex keeps its native TUI, but the TUI is only a client attachment
+ * to the user's shared App Server. The daemon owns the Thread and its writer,
+ * so Desktop can open the same Yui-created Thread without a second rollout
+ * writer or a Yui-specific takeover.
+ */
+export function addCodexSharedDaemonRemote(args, mode, environment = {}) {
+    const sessionEnvironment = Object.fromEntries(Object.entries(environment).filter(([name]) => name.startsWith("YUI_")));
+    const remote = [
+        "--remote",
+        "unix://",
+        ...(Object.keys(sessionEnvironment).length === 0
+            ? []
+            : ["--config", codexShellEnvironmentConfig(sessionEnvironment)])
+    ];
+    if (mode === "new")
+        return [...args, ...remote];
+    if (args.length < 2 || args.at(-2) !== "resume") {
+        throw new Error("Codex resume launch shape is invalid.");
+    }
+    return [...args.slice(0, -2), ...remote, ...args.slice(-2)];
+}
+function codexShellEnvironmentConfig(environment) {
+    const entries = Object.entries(environment)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => `${JSON.stringify(name)}=${JSON.stringify(value)}`);
+    return `shell_environment_policy.set={${entries.join(",")}}`;
+}
 /**
  * Codex 0.145 discovers lifecycle hooks from its effective config. Keep Yui's
  * two handlers invocation-local: this avoids mutating CODEX_HOME or the Task

package/dist/external/githubPublicationVerifier.js

@@ -0,0 +1,114 @@
+import { createExecFileCommandRunner, createPinnedCommandRunner } from "./pinnedCommandRunner.js";
+import { redactLaunchText } from "../runtime/launchDiagnostics.js";
+const GIT_COMMIT = /^[0-9a-f]{40}$/iu;
+const GITHUB_REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u;
+const MAX_FAILURE_DETAIL_CHARS = 4_000;
+const PULL_REQUEST_NUMBER = /^[1-9][0-9]*$/u;
+export function createGitHubCliPublicationVerifier(options = {}) {
+    const run = options.runCommand ?? createPinnedCommandRunner(createExecFileCommandRunner(), ["gh"], options.environmentPath);
+    return {
+        inspect: (input) => inspectGitHubPullRequest(run, input)
+    };
+}
+async function inspectGitHubPullRequest(run, input) {
+    if (input.provider !== "github" || input.externalKind !== "pull-request") {
+        throw new Error(`GitHub verifier cannot inspect ${input.provider}/${input.externalKind}.`);
+    }
+    if (!GITHUB_REPOSITORY.test(input.repository)) {
+        throw new Error(`GitHub repository must use owner/name: ${input.repository}.`);
+    }
+    if (!PULL_REQUEST_NUMBER.test(input.externalId)) {
+        throw new Error(`GitHub pull request id must be numeric: ${input.externalId}.`);
+    }
+    const result = await run("gh", [
+        "pr", "view", input.externalId,
+        "--repo", input.repository,
+        "--json", "number,state,headRefOid,mergeCommit,mergedAt,url"
+    ]);
+    if (result.code !== 0) {
+        if (result.code === 127) {
+            throw new Error("GitHub verification requires a trusted gh executable on PATH.");
+        }
+        const detail = boundedFailureDetail(redactLaunchText(result.stderr || result.stdout).trim());
+        throw new Error(`gh pr view failed for ${input.repository}#${input.externalId} `
+            + `(exit ${result.code})${detail.length === 0 ? "" : `: ${detail}`}`);
+    }
+    return parseGitHubPullRequest(result.stdout, input.repository, input.externalId);
+}
+export function parseGitHubPullRequest(stdout, repository, externalId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.trim());
+    }
+    catch {
+        throw new Error("gh pr view returned invalid JSON.");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("gh pr view returned an invalid pull request object.");
+    }
+    const record = parsed;
+    const number = typeof record.number === "number"
+        ? String(record.number)
+        : typeof record.number === "string" ? record.number : undefined;
+    if (number !== externalId) {
+        throw new Error(`gh pr view returned pull request ${number ?? "unknown"}, expected ${externalId}.`);
+    }
+    const state = githubState(record.state);
+    const headCommit = gitCommit(record.headRefOid, "GitHub PR head commit");
+    const remoteCommit = mergeCommit(record.mergeCommit);
+    if (state === "merged" && remoteCommit === undefined) {
+        throw new Error("Merged GitHub PR did not expose a merge commit.");
+    }
+    const externalUrl = optionalText(record.url);
+    const mergedAt = optionalText(record.mergedAt);
+    return {
+        provider: "github",
+        repository,
+        externalKind: "pull-request",
+        externalId,
+        ...(externalUrl === undefined ? {} : { externalUrl }),
+        state,
+        headCommit,
+        ...(remoteCommit === undefined ? {} : { remoteCommit }),
+        ...(mergedAt === undefined ? {} : { mergedAt }),
+        evidence: `gh pr view ${repository}#${externalId}: state=${state}; `
+            + `head=${headCommit}; remote=${remoteCommit ?? "none"}`
+    };
+}
+function githubState(value) {
+    if (typeof value !== "string") {
+        throw new Error("GitHub PR state is unavailable.");
+    }
+    switch (value.toUpperCase()) {
+        case "OPEN": return "open";
+        case "MERGED": return "merged";
+        case "CLOSED": return "closed";
+        default: throw new Error(`GitHub PR state is unsupported: ${value}.`);
+    }
+}
+function mergeCommit(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === "string")
+        return gitCommit(value, "GitHub merge commit");
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("GitHub merge commit is invalid.");
+    }
+    return gitCommit(value.oid, "GitHub merge commit");
+}
+function gitCommit(value, label) {
+    if (typeof value !== "string" || !GIT_COMMIT.test(value)) {
+        throw new Error(`${label} must be a full 40-character Git SHA.`);
+    }
+    return value.toLowerCase();
+}
+function optionalText(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function boundedFailureDetail(value) {
+    return value.length <= MAX_FAILURE_DETAIL_CHARS
+        ? value
+        : `${value.slice(0, MAX_FAILURE_DETAIL_CHARS)}…`;
+}

package/dist/external/gitlabPublicationVerifier.js

@@ -0,0 +1,158 @@
+import { createExecFileCommandRunner, createPinnedCommandRunner } from "./pinnedCommandRunner.js";
+import { redactLaunchText } from "../runtime/launchDiagnostics.js";
+const GIT_COMMIT = /^[0-9a-f]{40}$/iu;
+const GITLAB_REPOSITORY = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+$/u;
+const MAX_FAILURE_DETAIL_CHARS = 4_000;
+const MERGE_REQUEST_IID = /^[1-9][0-9]*$/u;
+export function createGitLabCliPublicationVerifier(options = {}) {
+    const run = options.runCommand ?? createPinnedCommandRunner(createExecFileCommandRunner(), ["glab"], options.environmentPath);
+    return {
+        inspect: (input) => inspectGitLabMergeRequest(run, input)
+    };
+}
+async function inspectGitLabMergeRequest(run, input) {
+    if (input.provider !== "gitlab" || input.externalKind !== "merge-request") {
+        throw new Error(`GitLab verifier cannot inspect ${input.provider}/${input.externalKind}.`);
+    }
+    if (!GITLAB_REPOSITORY.test(input.repository)) {
+        throw new Error(`GitLab repository must use namespace/project: ${input.repository}.`);
+    }
+    if (!MERGE_REQUEST_IID.test(input.externalId)) {
+        throw new Error(`GitLab merge request id must be numeric: ${input.externalId}.`);
+    }
+    const hostname = gitLabHostname(input.externalUrl);
+    const endpoint = `projects/${encodeURIComponent(input.repository)}`
+        + `/merge_requests/${input.externalId}`;
+    const result = await run("glab", [
+        "api",
+        endpoint,
+        ...(hostname === undefined ? [] : ["--hostname", hostname])
+    ]);
+    if (result.code !== 0) {
+        if (result.code === 127) {
+            throw new Error("GitLab verification requires a trusted glab executable on PATH.");
+        }
+        const detail = boundedFailureDetail(redactLaunchText(result.stderr || result.stdout).trim());
+        throw new Error(`glab api failed for ${input.repository}!${input.externalId} `
+            + `(exit ${result.code})${detail.length === 0 ? "" : `: ${detail}`}`);
+    }
+    return parseGitLabMergeRequest(result.stdout, input.repository, input.externalId, hostname ?? "gitlab.com");
+}
+export function parseGitLabMergeRequest(stdout, repository, externalId, expectedHost) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.trim());
+    }
+    catch {
+        throw new Error("glab api returned invalid JSON.");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("glab api returned an invalid merge request object.");
+    }
+    const record = parsed;
+    const iid = typeof record.iid === "number"
+        ? String(record.iid)
+        : typeof record.iid === "string" ? record.iid : undefined;
+    if (iid !== externalId) {
+        throw new Error(`glab api returned merge request ${iid ?? "unknown"}, expected ${externalId}.`);
+    }
+    const state = gitLabState(record.state);
+    const headCommit = gitCommit(record.sha, "GitLab MR head commit");
+    const remoteCommit = firstCommit(record.merge_commit_sha, record.squash_commit_sha);
+    if (state === "merged" && remoteCommit === undefined) {
+        throw new Error("Merged GitLab MR did not expose an integrated commit.");
+    }
+    const externalUrl = optionalText(record.web_url);
+    assertGitLabReference(record.references, repository, externalId);
+    if (externalUrl !== undefined && expectedHost !== undefined) {
+        assertGitLabWebUrl(externalUrl, expectedHost, repository, externalId);
+    }
+    const mergedAt = optionalText(record.merged_at);
+    return {
+        provider: "gitlab",
+        repository,
+        externalKind: "merge-request",
+        externalId,
+        ...(externalUrl === undefined ? {} : { externalUrl }),
+        state,
+        headCommit,
+        ...(remoteCommit === undefined ? {} : { remoteCommit }),
+        ...(mergedAt === undefined ? {} : { mergedAt }),
+        evidence: `glab api ${repository}!${externalId}: state=${state}; `
+            + `head=${headCommit}; remote=${remoteCommit ?? "none"}`
+    };
+}
+function gitLabState(value) {
+    if (typeof value !== "string")
+        throw new Error("GitLab MR state is unavailable.");
+    switch (value.toLowerCase()) {
+        case "opened": return "open";
+        case "merged": return "merged";
+        case "closed": return "closed";
+        default: throw new Error(`GitLab MR state is unsupported: ${value}.`);
+    }
+}
+function assertGitLabReference(value, repository, externalId) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("GitLab MR repository reference is unavailable.");
+    }
+    const full = optionalText(value.full);
+    if (full !== `${repository}!${externalId}`) {
+        throw new Error(`GitLab MR repository reference ${full ?? "unknown"} does not match `
+            + `${repository}!${externalId}.`);
+    }
+}
+function assertGitLabWebUrl(value, expectedHost, repository, externalId) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("GitLab MR web URL is invalid.");
+    }
+    const expectedSuffix = `/${repository}/-/merge_requests/${externalId}`;
+    if ((url.protocol !== "https:" && url.protocol !== "http:")
+        || url.host.toLowerCase() !== expectedHost.toLowerCase()
+        || !url.pathname.endsWith(expectedSuffix)) {
+        throw new Error(`GitLab MR web URL does not match ${expectedHost}/${repository}!${externalId}.`);
+    }
+}
+function firstCommit(...values) {
+    for (const value of values) {
+        if (value === null || value === undefined || value === "")
+            continue;
+        return gitCommit(value, "GitLab integrated commit");
+    }
+    return undefined;
+}
+function gitCommit(value, label) {
+    if (typeof value !== "string" || !GIT_COMMIT.test(value)) {
+        throw new Error(`${label} must be a full 40-character Git SHA.`);
+    }
+    return value.toLowerCase();
+}
+function optionalText(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function gitLabHostname(externalUrl) {
+    if (externalUrl === undefined)
+        return undefined;
+    let url;
+    try {
+        url = new URL(externalUrl);
+    }
+    catch {
+        throw new Error(`GitLab external URL is invalid: ${externalUrl}.`);
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new Error(`GitLab external URL protocol is invalid: ${url.protocol}.`);
+    }
+    return url.hostname === "gitlab.com" ? undefined : url.host;
+}
+function boundedFailureDetail(value) {
+    return value.length <= MAX_FAILURE_DETAIL_CHARS
+        ? value
+        : `${value.slice(0, MAX_FAILURE_DETAIL_CHARS)}…`;
+}

package/dist/external/pinnedCommandRunner.js

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, isAbsolute, resolve } from "node:path";
+import { promisify } from "node:util";
+export function createExecFileCommandRunner() {
+    const exec = promisify(execFile);
+    return async (command, args, cwd, env) => {
+        try {
+            const { stdout, stderr } = await exec(command, args, {
+                cwd,
+                maxBuffer: 16 * 1024 * 1024,
+                ...(env === undefined ? {} : { env: { ...process.env, ...env } })
+            });
+            return { code: 0, stdout, stderr };
+        }
+        catch (error) {
+            const failure = error;
+            return {
+                code: typeof failure.code === "number" ? failure.code : 1,
+                stdout: failure.stdout ?? "",
+                stderr: failure.stderr ?? failure.message ?? String(error)
+            };
+        }
+    };
+}
+/**
+ * Resolve an external command once through the supplied PATH. Callers pin the
+ * result for the lifetime of an adapter so a later PATH change cannot swap the
+ * executable that supplies an external fact or effect.
+ */
+export function resolveExecutable(command, environmentPath) {
+    if (isAbsolute(command))
+        return command;
+    for (const directory of (environmentPath ?? "").split(delimiter)) {
+        if (directory.length === 0)
+            continue;
+        const candidate = resolve(directory, command);
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Keep walking PATH.
+        }
+    }
+    return undefined;
+}
+export function createPinnedCommandRunner(base, commands, environmentPath = process.env.PATH) {
+    const pinned = new Map();
+    for (const command of commands) {
+        pinned.set(command, resolveExecutable(command, environmentPath));
+    }
+    return (command, args, cwd, env) => {
+        let resolved;
+        if (pinned.has(command)) {
+            resolved = pinned.get(command);
+        }
+        else {
+            resolved = isAbsolute(command)
+                ? command
+                : resolveExecutable(command, environmentPath);
+            pinned.set(command, resolved);
+        }
+        if (resolved === undefined) {
+            return Promise.resolve({
+                code: 127,
+                stdout: "",
+                stderr: `Unable to resolve trusted executable: ${command}`
+            });
+        }
+        return base(resolved, args, cwd, env);
+    };
+}

package/dist/integration/changeSetManifest.js

@@ -15,7 +15,6 @@ export function createChangeSetManifest(input) {
         schemaVersion: CHANGE_SET_MANIFEST_SCHEMA_VERSION,
         tags: [...input.tags],
         deletedPaths: [...input.deletedPaths],
-        evidenceRefs: [...(input.evidenceRefs ?? [])],
         ...(input.targetRef === undefined ? {} : { targetRef: input.targetRef })
     });
 }
@@ -33,12 +32,10 @@ export function validateChangeSetManifest(manifest) {
     }
     const tags = normalizedUniqueText(manifest.tags, "ChangeSet manifest tag");
     const deletedPaths = normalizedUniqueText(manifest.deletedPaths, "ChangeSet manifest deleted path");
-    const evidenceRefs = normalizedUniqueText(manifest.evidenceRefs, "ChangeSet manifest evidence reference");
     return {
         schemaVersion: CHANGE_SET_MANIFEST_SCHEMA_VERSION,
         tags,
         deletedPaths,
-        evidenceRefs,
         ...(manifest.targetRef === undefined ? {} : {
             targetRef: requireText(manifest.targetRef, "ChangeSet manifest target ref")
         })

package/dist/integration/deliveryObligation.js

@@ -1,4 +1,38 @@
 import { governingWorkItemCandidate } from "../workItem/workItem.js";
+/**
+ * Resolve the exact Git boundary produced by the Candidate that currently
+ * governs a WorkItem. Read-only context Projects are not delivery sources.
+ */
+export function governingWorkItemDeliveries(workItems) {
+    return workItems.flatMap((item) => {
+        const candidate = governingWorkItemCandidate(item);
+        if (candidate?.workspace === undefined || candidate.gitSnapshot === undefined)
+            return [];
+        const results = new Map(candidate.gitSnapshot.projects.map(({ projectId, commit }) => [projectId, commit]));
+        return candidate.workspace.entries
+            .filter(({ access }) => access === "write")
+            .map((entry) => {
+            const resultCommit = results.get(entry.projectId);
+            if (resultCommit === undefined) {
+                throw new Error(`WorkItem Candidate result is missing Project ${item.id}/${entry.projectId}.`);
+            }
+            return {
+                workItemId: item.id,
+                projectId: entry.projectId,
+                startCommit: entry.baseCommit,
+                resultCommit
+            };
+        });
+    });
+}
+export function workItemDeliverySettled(delivery, integrations) {
+    return integrations.some((attempt) => (attempt.status === "committed"
+        && attempt.projectId === delivery.projectId
+        && attempt.source.kind === "work-item"
+        && attempt.source.workItemId === delivery.workItemId
+        && attempt.source.startCommit === delivery.startCommit
+        && attempt.source.resultCommit === delivery.resultCommit));
+}
 /**
  * Delivery obligations follow the Candidate that currently governs each
  * WorkItem. Older Candidates and their ChangeSets remain audit evidence, but
@@ -26,7 +60,11 @@ export function governingChangeSets(workItems, changeSets) {
     return [...selected.values()].sort(compareChangeSets);
 }
 export function changeSetDeliverySettled(changeSet, integrations, queueEntries = []) {
-    if (integrations.some((attempt) => (attempt.status === "committed" && attempt.changeSetIds.includes(changeSet.id))))
+    if (integrations.some((attempt) => (attempt.status === "committed"
+        && attempt.projectId === changeSet.projectId
+        && attempt.source.kind === "work-item"
+        && attempt.source.workItemId === changeSet.workItemId
+        && attempt.source.resultCommit === changeSet.headCommit)))
         return true;
     const latestQueueEntry = queueEntries
         .filter((entry) => entry.changeSetId === changeSet.id)
@@ -52,11 +90,10 @@ export function latestGoverningQueueEntries(changeSets, queueEntries) {
  * reference has been replaced by a newer governing Candidate. Attempts that
  * may still be writing remain blockers regardless of Candidate history.
  */
-export function integrationAttemptRequiresSettlement(attempt, changeSets) {
-    if (attempt.status === "running" || attempt.status === "validating")
-        return true;
-    const governingIds = new Set(changeSets.map(({ id }) => id));
-    return attempt.changeSetIds.some((id) => governingIds.has(id));
+export function integrationAttemptRequiresSettlement(attempt) {
+    return attempt.status === "running"
+        || attempt.status === "validating"
+        || attempt.status === "blocked";
 }
 function candidateProjectHead(candidate, projectId) {
     return candidate.gitSnapshot?.projects.find((project) => project.projectId === projectId)?.commit