@zq-silk/yui 0.15.11 → 0.16.0

package/dist/integration/gitIntegrationService.js

@@ -1,31 +1,30 @@
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
 import { lstat, mkdir, open, rm, stat } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { selectEnvironment } from "../agent/launchEnvironment.js";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { durableJobIdempotencyKey } from "../job/durableJob.js";
-import { applyIntegrationSource, assertIntegrationCandidate, assertRecordedSourceCandidate } from "./integrationSourceApplication.js";
-import { planBootstrapJobSteps, planL2JobSteps } from "../verification/verificationPlan.js";
-import { assertNoAdHocFullSuiteChecks, checkResultsFromGateArtifact, checkResultsFromGateJob, gateIdentityForCandidate, lookupReusableGateArtifact, recordGateArtifactFromJob, recordGateArtifactFromStepOutcomes, resolveVerificationGate, runGateStepsInProcess } from "../verification/verificationGateService.js";
-import { recordGateArtifactPotentialReuse, recordGateArtifactReuse } from "../verification/gateArtifact.js";
-import { touchGateArtifact } from "../verification/gateArtifactStore.js";
+import { readRuntimeIdentity } from "../release/runtimeRelease.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { integrationWorkspaceRoot } from "../repository/taskWorkspacePreparer.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
 import { taskWorkspaceRefSegment } from "../repository/taskWorkspaceIdentity.js";
+import { integrationWorkspaceRoot } from "../repository/taskWorkspacePreparer.js";
+import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { FileTaskRuntimeIsolation } from "../runtime/taskRuntimeIsolation.js";
-import { managedIntegrationRuntimeRoot } from "../storage/homeLayout.js";
+import { integrationTmuxSocketRoot, managedIntegrationRuntimeRoot } from "../storage/homeLayout.js";
 import { advanceTaskProjectCommit } from "../task/task.js";
 import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
-import { recordIntegrationCheckJob, updateIntegrationAttempt } from "./integrationAttempt.js";
+import { recordGateArtifactReuse } from "../verification/gateArtifact.js";
+import { touchGateArtifact } from "../verification/gateArtifactStore.js";
+import { beginGateVerification, checkResultsFromGateArtifact, checkResultsFromGateJob, gateIdentityForCandidate, lookupReusableGateArtifact, recordGateArtifactFromJob, recordGateArtifactFromStepOutcomes, resolveVerificationGate, runGateStepsInProcess } from "../verification/verificationGateService.js";
+import { planBootstrapJobSteps, planL2JobSteps } from "../verification/verificationPlan.js";
 import { createManagedWorkspace } from "../worktree/managedWorkspace.js";
-import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
-import { readRuntimeIdentity } from "../release/runtimeRelease.js";
-import { findReusableIntegrationCheckEvidence, INTEGRATION_RUNTIME_RELEASE_ENV } from "./integrationCheckEvidenceReuse.js";
+import { recordIntegrationCheckJob, updateIntegrationAttempt } from "./integrationAttempt.js";
+import { applyIntegrationSource, assertIntegrationCandidate, assertRecordedSourceCandidate } from "./integrationSourceApplication.js";
 const executeFile = promisify(execFile);
+/** Preserve the exact execution-environment fence in durable Job input digests. */
+const INTEGRATION_RUNTIME_RELEASE_ENV = "YUI_INTEGRATION_RUNTIME_RELEASE_ID";
 const INTEGRATION_OPERATIONAL_ENVIRONMENT_NAMES = [
     "PATH",
     "USER",
@@ -76,7 +75,7 @@ export class GitIntegrationService {
     #resourceRegistrar() {
         return this.#resourceRegistrarValue ??= new ResourceRegistrar(this.home, this.now);
     }
-    async integrate(taskId, integrationId) {
+    async integrate(taskId, integrationId, signal) {
         let initial = requireIntegration(this.store, taskId, integrationId);
         if (!["running", "conflicted", "blocked", "validating"].includes(initial.status)) {
             throw new Error(`Integration cannot continue from ${initial.status}.`);
@@ -86,7 +85,7 @@ export class GitIntegrationService {
         // CAS. A concurrent `project migrate` must not switch the catalog path or
         // remove the old checkout mid-Integration, so the per-Project maintenance
         // fence is held across every Git effect and released only on exit.
-        const release = acquireProjectMaintenanceLocks(this.home, [initial.projectId]);
+        const release = await acquireProjectMaintenanceLocks(this.home, [initial.projectId], { signal });
         try {
             // A concurrent abort may have settled the attempt while this caller was
             // acquiring the same Project fence. Never execute a pre-fence snapshot.
@@ -260,9 +259,9 @@ export class GitIntegrationService {
     /** Abandon under the same fence as Git/CAS, not just a status whitelist.
      * A delivered validating candidate is recorded as committed; a provably
      * unadvanced one may be abandoned without requiring obsolete check settings. */
-    async abort(taskId, integrationId, reason, authorize) {
+    async abort(taskId, integrationId, reason, authorize, signal) {
         const initial = requireIntegration(this.store, taskId, integrationId);
-        const release = acquireProjectMaintenanceLocks(this.home, [initial.projectId]);
+        const release = await acquireProjectMaintenanceLocks(this.home, [initial.projectId], { signal });
         try {
             const attempt = requireIntegration(this.store, taskId, integrationId);
             authorize(this.store, taskId);
@@ -338,12 +337,25 @@ export class GitIntegrationService {
             release();
         }
     }
-    async cleanup(integration) {
+    async cleanup(integration, options = {}) {
         // The whole cleanup is one Git transaction against the Project's
         // repository, mirroring integrate(): a concurrent `project migrate` must
         // not switch the catalog path or remove the old checkout mid-cleanup.
-        const release = acquireProjectMaintenanceLocks(this.home, [integration.projectId]);
+        const release = await acquireProjectMaintenanceLocks(this.home, [integration.projectId], { signal: options.signal });
         try {
+            options.authorize?.();
+            const current = requireIntegration(this.store, integration.taskId, integration.id);
+            if (current.projectId !== integration.projectId
+                || !["committed", "superseded", "failed"].includes(current.status)) {
+                throw new Error("Integration changed before cleanup; read its current record.");
+            }
+            integration = current;
+            const activeJob = this.store.listDurableJobs(integration.taskId).find(job => job.owner.kind === "integration-attempt" && job.owner.integrationAttemptId === integration.id
+                && (job.status === "queued" || job.status === "running"
+                    || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
+            if (activeJob !== undefined) {
+                throw new Error(`Integration ${integration.id} has an active DurableJob: ${activeJob.id}/${activeJob.status}.`);
+            }
             const task = this.store.getTask(integration.taskId);
             if (task === null || !task.projectBindings.some(({ projectId }) => projectId === integration.projectId)) {
                 throw new Error(`Integration Task Project is unavailable: ${integration.id}.`);
@@ -408,26 +420,7 @@ export class GitIntegrationService {
         }
         await assertIntegrationCandidate(path, attempt.candidateCommit, workspace.branch);
         await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.beforeCommit);
-        const { runtime, head, steps, environment, inputDigest, releaseId } = await this.#checkSpecification(attempt, managedWorkspace, gate);
-        const ownedJobs = this.store.listDurableJobs(attempt.taskId).filter(job => job.owner.kind === "integration-attempt" && job.owner.integrationAttemptId === attempt.id);
-        if (gate === undefined && releaseId !== null && attempt.checkInputDigest === undefined
-            && ownedJobs.length === 0 && attempt.jobId === undefined) {
-            const reusable = findReusableIntegrationCheckEvidence({
-                taskId: attempt.taskId,
-                projectId: attempt.projectId,
-                currentAttemptId: attempt.id,
-                candidateCommit: head,
-                checkCommands: attempt.checkCommands,
-                runtimeReleaseId: releaseId,
-                attempts: this.store.listIntegrationAttempts(attempt.taskId),
-                jobs: this.store.listDurableJobs(attempt.taskId),
-                logExists: (homeRelativePath) => existsSync(join(this.home, homeRelativePath)),
-                logPathFor: (job, relativeLogPath) => (join(job.artifactsLocator, "logs", relativeLogPath))
-            });
-            if (reusable !== null) {
-                return this.#finalizeGateSuccess(updateIntegrationAttempt(attempt, { checkInputDigest: inputDigest }, this.now()), workspace, repositoryPath, head, [...reusable.checks]);
-            }
-        }
+        const { runtime, head, steps, environment, inputDigest } = await this.#checkSpecification(attempt, managedWorkspace, gate);
         if (attempt.checkInputDigest !== undefined && attempt.checkInputDigest !== inputDigest) {
             throw new Error("Integration check conditions changed since admission; inspect the original Job, then abort or start a new attempt.");
         }
@@ -444,6 +437,14 @@ export class GitIntegrationService {
             })
         }, this.now());
         this.store.saveIntegrationAttempt(attempt.taskId, persisted);
+        if (gate !== undefined) {
+            // Resumption can enter here after persisting admission but before the
+            // original call withdrew old proof or recorded its Job id.
+            beginGateVerification(this.store, gateIdentityForCandidate({
+                projectId: attempt.projectId, gate, level: "L2", commit: head,
+                targetRef: attempt.targetRef, baseHead: attempt.beforeCommit
+            }), gate.plan, this.now());
+        }
         // All domain admission and durable candidate identity precede Job effects.
         this.runtimeIsolation.activate(runtime);
         await prepareIntegrationRuntimeHome(runtime, this.home);
@@ -507,7 +508,7 @@ export class GitIntegrationService {
                 baseHead: attempt.beforeCommit
             });
             try {
-                const artifact = await recordGateArtifactFromJob(this.store, this.home, identity, gate.plan, job, this.now());
+                const artifact = await this.#publishGateEvidence(workspace, job.head, () => recordGateArtifactFromJob(this.store, this.home, identity, gate.plan, job, this.now()));
                 if (checks.every((check) => check.outcome !== "failed")) {
                     checks.push(...checkResultsFromGateArtifact(artifact));
                 }
@@ -549,11 +550,10 @@ export class GitIntegrationService {
     /**
      * Issue 08: the VerificationPlan gate for a configured Project.
      *
-     * Enforce mode rejects ad-hoc full-suite checks before the gate. Reuse mode
-     * returns an existing successful artifact for the same identity tuple
+     * Returns an existing successful artifact for the same identity tuple
      * (project + exact commit + plan digest + toolchain digest + target
-     * boundary); record mode always runs and only counts shadow potential
-     * reuses. The gate itself runs as bootstrap + L2 DurableJob steps (or
+     * boundary), unless this attempt explicitly requests fresh checks.
+     * The gate itself runs as bootstrap + L2 DurableJob steps (or
      * in-process when no Controller job port is available) and records a
      * self-contained GateArtifact. The final CAS in
      * {@link #finalizeGateSuccess} still fences a target that moves during the
@@ -561,19 +561,26 @@ export class GitIntegrationService {
      */
     async #runVerificationGate(attempt, workspace, path, managedWorkspace, repositoryPath, gate) {
         const spec = await this.#checkSpecification(attempt, managedWorkspace, gate);
+        const unsettled = this.store.listIntegrationAttempts(attempt.taskId).find(other => {
+            if (other.id === attempt.id || other.projectId !== attempt.projectId
+                || other.targetRef !== attempt.targetRef || other.beforeCommit !== attempt.beforeCommit
+                || other.candidateCommit !== attempt.candidateCommit
+                || other.gatePlanDigest !== gate.planDigest || other.gateToolchainDigest !== gate.toolchainDigest)
+                return false;
+            if (other.status === "running" || other.status === "validating")
+                return true;
+            const job = other.jobId === undefined ? null : this.store.getDurableJob(other.taskId, other.jobId);
+            return job !== null && (job.status === "queued" || job.status === "running"
+                || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined));
+        });
+        if (unsettled !== undefined) {
+            throw new Error(`Exact verification is unsettled in ${unsettled.taskId}/${unsettled.id}; continue or settle its original Job before requesting another check.`);
+        }
         attempt = updateIntegrationAttempt(attempt, {
             checkInputDigest: spec.inputDigest,
             gatePlanDigest: gate.planDigest, gateToolchainDigest: gate.toolchainDigest
         }, this.now());
         this.store.saveIntegrationAttempt(attempt.taskId, attempt);
-        if (gate.mode === "enforce") {
-            try {
-                assertNoAdHocFullSuiteChecks(gate.plan, attempt.checkCommands);
-            }
-            catch (error) {
-                return this.#fail(attempt, error instanceof Error ? error : new Error(String(error)), "verification-plan", workspace);
-            }
-        }
         const candidateCommit = await gitLine(["-C", path, "rev-parse", "HEAD^{commit}"]);
         const identity = gateIdentityForCandidate({
             projectId: attempt.projectId,
@@ -583,7 +590,7 @@ export class GitIntegrationService {
             targetRef: attempt.targetRef,
             baseHead: attempt.beforeCommit
         });
-        if (gate.mode !== "record") {
+        if (!attempt.rerunChecks && attempt.checkCommands.length === 0) {
             const existing = await lookupReusableGateArtifact(this.store, identity);
             if (existing !== null) {
                 touchGateArtifact(this.store, recordGateArtifactReuse(existing, this.now()));
@@ -591,31 +598,22 @@ export class GitIntegrationService {
                 return this.#finalizeGateSuccess(attempt, workspace, repositoryPath, candidateCommit, checks);
             }
         }
-        else {
-            // Record mode: observe the potential reuse without skipping the gate.
-            const existing = await lookupReusableGateArtifact(this.store, identity);
-            if (existing !== null) {
-                touchGateArtifact(this.store, recordGateArtifactPotentialReuse(existing, this.now()));
-            }
-        }
         if (this.jobPort !== undefined) {
             return this.#startCheckJob(attempt, workspace, path, managedWorkspace, repositoryPath, gate);
         }
-        // Jobless fallback (queue processing without a Controller): run the
+        beginGateVerification(this.store, identity, gate.plan, this.now());
+        // An explicit local caller without a Controller Job port runs the
         // plan gate in-process and record the artifact directly.
         const runtime = this.#runtimePreparation(attempt, managedWorkspace);
         this.runtimeIsolation.activate(runtime);
         let cleanupReason = "failure";
         try {
             await prepareIntegrationRuntimeHome(runtime, this.home);
-            const steps = [
-                ...planBootstrapJobSteps(gate.plan),
-                ...planL2JobSteps(gate.plan)
-            ];
+            const steps = spec.steps;
             const outcomes = await runGateStepsInProcess(path, steps, spec.environment, integrationCheckDirectory(this.home, attempt.taskId, attempt.id), candidateCommit);
             const succeeded = outcomes.length === steps.length
                 && outcomes.every((outcome) => outcome.exitCode === 0 && outcome.signal === null && !outcome.timedOut);
-            const artifact = await recordGateArtifactFromStepOutcomes(this.store, identity, gate.plan, outcomes, succeeded, this.now());
+            const artifact = await this.#publishGateEvidence(workspace, candidateCommit, () => recordGateArtifactFromStepOutcomes(this.store, identity, gate.plan, outcomes, succeeded, this.now()));
             const checks = checkResultsFromGateArtifact(artifact);
             cleanupReason = succeeded ? "completion" : "failure";
             if (!succeeded) {
@@ -629,6 +627,13 @@ export class GitIntegrationService {
             this.runtimeIsolation.cleanup(runtime, cleanupReason);
         }
     }
+    /** Both executors publish proof only for the exact clean candidate they
+     * checked. A later delivery/CAS failure is separate from this evidence, but
+     * a mutated candidate must never enter the reusable-success cache. */
+    async #publishGateEvidence(workspace, candidateCommit, publish) {
+        await assertIntegrationCandidate(workspace.path, candidateCommit, workspace.branch);
+        return publish();
+    }
     async #finalizeGateSuccess(attempt, workspace, repositoryPath, candidateCommit, checks) {
         await assertIntegrationCandidate(workspace.path, candidateCommit, workspace.branch);
         const validating = updateIntegrationAttempt(attempt, {
@@ -641,7 +646,7 @@ export class GitIntegrationService {
         const committed = this.#recordCommitted(validating);
         return this.#terminalResult("committed", committed, workspace);
     }
-    #runtimePreparation(attempt, workspace) {
+    #runtimePreparation(_attempt, workspace) {
         return this.runtimeIsolation.preflight({
             workspace,
             allowExactActive: true
@@ -655,11 +660,12 @@ export class GitIntegrationService {
         const head = attempt.candidateCommit;
         if (head === undefined)
             throw new Error("Integration check specification requires a candidate.");
-        const steps = gate === undefined
-            ? attempt.checkCommands.map((command, index) => ({
-                name: `check-${index + 1}`, command, timeoutMs: 30 * 60_000
-            }))
-            : [...planBootstrapJobSteps(gate.plan), ...planL2JobSteps(gate.plan)]
+        const explicitChecks = attempt.checkCommands.map((command, index) => ({
+            name: `check-${index + 1}`, command, timeoutMs: 30 * 60_000
+        }));
+        const steps = gate === undefined ? explicitChecks
+            : [...planBootstrapJobSteps(gate.plan, managedWorkspace.root),
+                ...planL2JobSteps(gate.plan, managedWorkspace.root), ...explicitChecks]
                 .map(step => ({ ...step, timeoutMs: 30 * 60_000 }));
         const releaseId = integrationRuntimeReleaseIdentity(this.home);
         const environment = Object.freeze({
@@ -671,7 +677,7 @@ export class GitIntegrationService {
             projectId: attempt.projectId, head, workspace: managedWorkspace.root,
             env: environment, steps
         });
-        return { runtime, head, steps, environment, inputDigest, releaseId };
+        return { runtime, head, steps, environment, inputDigest };
     }
     async #recoverValidating(attempt, workspace, managedWorkspace, repositoryPath) {
         if (attempt.candidateCommit === undefined || attempt.checks === undefined) {
@@ -792,11 +798,6 @@ function integrationSummary(attempt) {
             ? `Upstream ${attempt.source.remoteCommit} was already represented; Task head was unchanged.`
             : `Rebased Task changes onto upstream ${attempt.source.remoteCommit}.`;
     }
-    if (attempt.source.kind === "historical-change-sets") {
-        return unchanged
-            ? "Historical Integration was already represented; Task head was unchanged."
-            : "Historical Integration advanced the Task head.";
-    }
     if (attempt.source.strategy === "manual") {
         const decision = attempt.resolution;
         if (decision?.action !== "manual-resolution") {
@@ -1023,18 +1024,6 @@ function defaultIntegrationRuntimeIsolation(home, homeId) {
         }
     });
 }
-/**
- * Short `/tmp` directory that holds ONLY the integration check's tmux socket
- * endpoint. tmux uses a `sockaddr_un` path whose length budget cannot absorb a
- * deep Home path, so this single IPC endpoint is the one approved exception to
- * the unified-Home contract. All other integration runtime state (data, cache,
- * ordinary temp) lives in the Home partition from `managedIntegrationRuntimeRoot`.
- */
-function integrationTmuxSocketRoot(home) {
-    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-    const homeDigest = createHash("sha256").update(resolve(home)).digest("hex").slice(0, 16);
-    return join("/tmp", `yi-${uid.toString(36)}-${homeDigest}`);
-}
 /**
  * Reuse is enabled only for an immutable installed release. Development
  * checkouts have no content-addressed release identity, so they return.

package/dist/integration/integrationAttempt.js

@@ -12,6 +12,7 @@ export function createIntegrationAttempt(input, now) {
         source: input.source,
         beforeCommit: input.beforeCommit,
         checkCommands: normalizedUniqueText(input.checkCommands ?? [], "Integration check command"),
+        rerunChecks: input.rerunChecks ?? false,
         status: "running",
         createdAt: timestamp,
         updatedAt: timestamp
@@ -143,6 +144,8 @@ export function validateIntegrationAttempt(attempt) {
     requireCommit(attempt.beforeCommit, "Integration before commit");
     validateIntegrationSource(attempt.taskId, attempt.source);
     normalizedUniqueText(attempt.checkCommands, "Integration check command");
+    if (typeof attempt.rerunChecks !== "boolean")
+        throw new Error("Integration rerunChecks must be explicit.");
     if (attempt.candidateCommit !== undefined) {
         requireCommit(attempt.candidateCommit, "Integration candidate commit");
     }
@@ -239,20 +242,6 @@ function validateIntegrationSource(taskId, source) {
         }
         return;
     }
-    if (source.kind === "historical-change-sets") {
-        if (!Array.isArray(source.changeSetIds) || source.changeSetIds.length === 0) {
-            throw new Error("Historical Integration source requires ChangeSet ids.");
-        }
-        const seen = new Set();
-        for (const changeSetId of source.changeSetIds) {
-            validateTaskRecordReference({ taskId, localId: changeSetId }, "changeSet");
-            if (seen.has(changeSetId)) {
-                throw new Error(`Historical Integration ChangeSet is duplicated: ${changeSetId}.`);
-            }
-            seen.add(changeSetId);
-        }
-        return;
-    }
     throw new Error("Integration source is invalid.");
 }
 function normalizeConflictReport(report) {

package/dist/integration/integrationSourceApplication.js

@@ -33,9 +33,6 @@ export async function applyIntegrationSource(input) {
         });
         return pending;
     };
-    if (source.kind === "historical-change-sets") {
-        throw new Error("Historical Integration source has no current application proof; preserve evidence and abort explicitly.");
-    }
     if (source.kind === "work-item" && source.strategy === "manual") {
         if (current.candidateCommit !== undefined) {
             await assertIntegrationCandidate(path, current.candidateCommit);
@@ -61,15 +58,11 @@ export async function applyIntegrationSource(input) {
     const branch = workspace.branch.startsWith("refs/") ? workspace.branch : `refs/heads/${workspace.branch}`;
     const active = await activeGitOperation(path);
     if (current.sourceProgress === undefined) {
-        // Historical unfinished operations can be adopted only when Git still
-        // carries their exact source/target identity. Finished old operations
-        // without a receipt are deliberately not inferred from a clean tree.
+        // Only a pristine candidate can establish this attempt's first receipt.
+        // An unfinished operation without that receipt belongs to explicit recovery.
         const head = await line(path, "rev-parse", "HEAD");
         if (active !== undefined) {
-            if (kind === "cherry-pick") {
-                throw new Error("Historical cherry-pick has no durable completed-step cursor; preserve it and choose explicit recovery.");
-            }
-            await assertOperation(path, kind, commits[0], current.beforeCommit, branch, source);
+            throw new Error("Active Git operation has no attempt-owned progress receipt; preserve it and choose explicit recovery.");
         }
         else if (head !== current.beforeCommit || current.status === "conflicted") {
             throw new Error("Integration source completion is unproven: no attempt-owned Git receipt. Preserve the candidate; do not replay.");
@@ -79,8 +72,7 @@ export async function applyIntegrationSource(input) {
         }
         save({ sourceProgress: {
                 workspace: resolve(path), branch, sourceDigest, completedSteps: 0,
-                head: current.beforeCommit,
-                ...(active === undefined ? {} : { activeAction: actionId() })
+                head: current.beforeCommit
             } });
     }
     let progress = current.sourceProgress;

package/dist/integration/manifestTags.js

@@ -77,7 +77,7 @@ function isCommandPath(lowerPath, segments, lowerFile) {
         || lowerFile.startsWith("cli")
         || lowerPath.includes("/bin/");
 }
-function isContractPath(lowerPath, segments, lowerFile) {
+function isContractPath(lowerPath, _segments, lowerFile) {
     return lowerFile === "index.ts"
         || lowerFile === "index.js"
         || lowerFile === "index.mjs"
@@ -87,7 +87,7 @@ function isContractPath(lowerPath, segments, lowerFile) {
         || lowerPath.includes("/contract/")
         || lowerPath.includes("/contracts/");
 }
-function isTestPath(lowerPath, segments, lowerFile) {
+function isTestPath(_lowerPath, segments, lowerFile) {
     if (segments.includes("test") || segments.includes("tests") || segments.includes("__tests__")) {
         return true;
     }

package/dist/job/durableJob.js

@@ -16,27 +16,9 @@ export function isDurableJobTerminal(status) {
 }
 export function createDurableJob(input, now) {
     const timestamp = now.toISOString();
-    const contentKey = input.retryOf === undefined
-        ? durableJobIdempotencyKey({
-            owner: input.owner,
-            projectId: input.projectId,
-            head: input.head,
-            steps: input.steps,
-            workspace: input.workspace,
-            env: input.env
-        })
-        : retryDurableJobIdempotencyKey(durableJobIdempotencyKey({
-            owner: input.owner,
-            projectId: input.projectId,
-            head: input.head,
-            steps: input.steps,
-            workspace: input.workspace,
-            env: input.env
-        }), input.retryOf);
-    const idempotencyKey = input.operation === undefined ? contentKey
-        : createHash("sha256").update(JSON.stringify([
-            input.operation.actorId, input.operation.requestId
-        ])).digest("hex");
+    const idempotencyKey = createHash("sha256").update(JSON.stringify([
+        input.operation.actorId, input.operation.requestId
+    ])).digest("hex");
     return validateDurableJob({
         schemaVersion: CURRENT_DURABLE_JOB_SCHEMA_VERSION,
         id: input.id,
@@ -49,10 +31,7 @@ export function createDurableJob(input, now) {
         steps: input.steps.map((step) => ({ ...step })),
         idempotencyKey,
         operation: {
-            requestId: input.operation?.requestId ?? idempotencyKey,
-            inputDigest: input.operation?.inputDigest ?? idempotencyKey,
-            actorId: input.operation?.actorId ?? "internal:job",
-            authorityRef: input.operation?.authorityRef ?? "internal:job",
+            ...input.operation,
             targetId: input.workspace,
             capability: "job.start",
             implementation: JOB_RUNNER_IMPLEMENTATION,

package/dist/job/jobAssignmentScope.js

@@ -0,0 +1,22 @@
+import { resolve } from "node:path";
+export class JobAssignmentScopeError extends Error {
+}
+/** Authentication identifies the current Session; it does not grant another
+ * Assignment's workspace. Share this check across admission, management and
+ * the last pre-spawn boundary. Existing running Jobs settle independently. */
+export function assertJobAssignmentScope(store, target, caller) {
+    if (caller.scope !== "task" || caller.role === "leader")
+        return;
+    const run = caller.role === undefined ? null : store.getActiveRun(target.taskId, caller.role);
+    const workspace = run?.workspace ?? run?.effective.workspace;
+    const item = run?.workItemId === undefined ? null : store.getWorkItem(target.taskId, run.workItemId);
+    if (run?.status !== "active" || run.reviewRoundId !== undefined
+        || target.owner.kind !== "work-item" || target.owner.workItemId !== run.workItemId
+        || item?.status !== "open" || item.assignee !== caller.role
+        || !item.writeProjectIds.includes(target.projectId)
+        || !run.effective.writeProjectIds.includes(target.projectId)
+        || workspace === undefined || resolve(workspace.root) !== resolve(target.workspace)
+        || !workspace.entries.some(entry => entry.projectId === target.projectId && entry.access === "write")) {
+        throw new JobAssignmentScopeError("Job is outside the caller's current Assignment. Use the exact assigned WorkItem workspace and writable Project; this Job owner cannot represent a Review or replica Lane.");
+    }
+}

package/dist/job/jobOperation.js

@@ -0,0 +1,16 @@
+/** A read model over the one Job, never separately persisted.
+ * confirmed means the selected runner was observed, not that every action
+ * performed by an arbitrary command succeeded. Inspect original step receipts.
+ */
+export function inspectJobOperation(job) {
+    return {
+        operationRef: { taskId: job.taskId, jobId: job.id },
+        ...job.operation,
+        state: job.status === "queued" ? "pending"
+            : job.status === "running" ? "running"
+                : job.status === "unknown-needs-attention" ? "unknown" : "finished",
+        outcome: job.result?.outcome,
+        result: job.result,
+        checkpoint: job.checkpoint
+    };
+}

package/dist/job/jobRunner.js

@@ -11,6 +11,7 @@ import { spawn } from "node:child_process";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, utimesSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { jobStepDirectory } from "./stepDirectory.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
 const DEFAULT_STEP_TIMEOUT_MS = 30 * 60_000;
@@ -129,7 +130,7 @@ export async function runDurableJobRunner(specPath) {
                 // Issue 08: a structured argv step executes without a shell so its
                 // tokens can never be reinterpreted; a legacy command step keeps the
                 // shell form. A per-step cwd/env override applies to either form.
-                const stepCwd = step.cwd ?? spec.workspace;
+                const stepCwd = jobStepDirectory(spec.workspace, step.cwd);
                 const stepEnv = step.env === undefined
                     ? spec.env
                     : { ...spec.env, ...step.env };

package/dist/job/stepDirectory.js

@@ -0,0 +1,15 @@
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+/** Recheck at execution, including directories created by a bootstrap step. */
+export function jobStepDirectory(workspace, override) {
+    const root = realpathSync(workspace);
+    const cwd = override ?? workspace;
+    if (!isAbsolute(cwd))
+        throw new Error("Job step cwd must be absolute.");
+    const actual = realpathSync(cwd);
+    const nested = relative(root, actual);
+    if (nested === ".." || nested.startsWith(`..${sep}`) || isAbsolute(nested)) {
+        throw new Error(`Job step cwd is outside its managed workspace: ${resolve(cwd)}.`);
+    }
+    return actual;
+}

package/dist/kernel/builtinCapabilities.js

@@ -1,13 +1,14 @@
-import { updateTaskMetadataCommand, sendTaskMessageCommand } from "../commands/taskCommands.js";
+import { listArtifactsCapability, readArtifactCapability, saveArtifactCapability } from "../artifacts/artifactCapability.js";
 import { runConfigCommand } from "../commands/configCommands.js";
-import { readTaskContext, readTaskContextDelta, inspectTaskContext, withContextObservations } from "../context/taskContext.js";
+import { sendTaskMessageCommand, updateTaskMetadataCommand } from "../commands/taskCommands.js";
 import { CONFIG_DOMAINS } from "../config/configCatalog.js";
+import { inspectTaskContext, readTaskContext, readTaskContextDelta, withContextObservations } from "../context/taskContext.js";
 import { createJobCallAuthority, parseDurableJobStartParams } from "../controller/jobControl.js";
-import { inspectJobOperation } from "./kernelPorts.js";
-import { CapabilityRegistry, } from "./capabilityRegistry.js";
-import { createProjectResources } from "../resources/projectResourceService.js";
-import { saveArtifactCapability, readArtifactCapability, listArtifactsCapability } from "../artifacts/artifactCapability.js";
+import { inspectJobOperation } from "../job/jobOperation.js";
+import { assertJobAssignmentScope } from "../job/jobAssignmentScope.js";
 import { createPluginService } from "../plugins/pluginService.js";
+import { createProjectResources } from "../resources/projectResourceService.js";
+import { CapabilityRegistry, } from "./capabilityRegistry.js";
 const text = { type: "string", minLength: 1 };
 const strings = { type: "object", additionalProperties: { type: "string" } };
 const object = (properties, required = Object.keys(properties)) => ({
@@ -26,7 +27,6 @@ const definitions = [
         effect: "local-mutation", requiredPermissions: ["task:read"], source: "sendTaskMessageCommand",
         inputSchema: object({ taskId: text, body: text,
             intent: { enum: ["record", "discuss", "develop"] },
-            wakePolicy: { enum: ["leader", "none"] },
             recipient: object({ roleName: text, workItemId: text, reviewRoundId: text }, ["roleName"])
         }, ["taskId", "body"]), outputSchema: recordOutput
     },
@@ -170,7 +170,8 @@ const definitions = [
                 ] },
             env: strings,
             steps: { type: "array", minItems: 1, items: object({
-                    name: text, command: text, timeoutMs: { type: "integer" }
+                    name: text, command: text, timeoutMs: { type: "integer" },
+                    argv: { type: "array", minItems: 1, items: text }, cwd: text, env: strings
                 }, ["name", "command"]) },
             retryOf: text
         }, ["taskId", "projectId", "head", "workspace", "owner", "env", "steps"]),
@@ -247,7 +248,7 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 // gains develop from an intent argument; only a global Operator Session
                 // (user-authority) may carry one. sendTaskMessageCommand enforces this,
                 // so the capability just forwards the optional intent unchanged.
-                const result = sendTaskMessageCommand(store, taskId, params.body, params.wakePolicy, { environment: callerEnvironment(caller) }, params.recipient, params.intent);
+                const result = sendTaskMessageCommand(store, taskId, params.body, { environment: callerEnvironment(caller) }, params.recipient, params.intent);
                 signal(taskId);
                 return result.message;
             }
@@ -338,11 +339,11 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                     ...(patch.tags?.length === 0 ? { tags: null } : {})
                 }, {
                     environment: callerEnvironment(caller),
-                    runtime: { notifyStateChanged: signal, reconcileTask: signal }
+                    runtime: { notifyMailboxChanged: () => signal(taskId), reconcileTask: signal }
                 });
             }
             if (name === "job.get") {
-                const job = jobs.getJob(taskId, params.jobId);
+                const job = jobs.getJob(taskId, params.jobId, caller);
                 if (!job)
                     throw new Error(`Job not found: ${taskId}/${params.jobId}.`);
                 const operation = inspectJobOperation(job);
@@ -379,6 +380,9 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 if (sessions?.sessions[sessions.activeAgentId]?.effective.executionAuthority !== "delivery") {
                     throw new Error("Planning Sessions cannot start delivery Jobs.");
                 }
+                if (descriptor?.name === "job.start" && input !== undefined) {
+                    assertJobAssignmentScope(store, input, caller);
+                }
             }
             if (permission === "task:read" || permission === "job:start")
                 continue;

package/dist/kernel/kernelPorts.js

@@ -1,7 +1,7 @@
 import { createDurableJobControl } from "../controller/jobControl.js";
 import { JOB_RUNNER_IMPLEMENTATION } from "../job/durableJob.js";
-import { InstanceHost } from "./instanceHost.js";
 import { createBuiltinCapabilities } from "./builtinCapabilities.js";
+import { InstanceHost } from "./instanceHost.js";
 /** Called once by the existing Controller root. Does not open a Store, start
  * another Controller, or provide arbitrary persistence to plugin code.
  * T02 registers contributions on this Host and wraps this same Job control.
@@ -29,19 +29,3 @@ export function createKernelPorts(store, runner, signal = () => undefined, conte
         }
     };
 }
-/** A read model over the one Job, never separately persisted.
- * confirmed means the selected runner was observed, not that every action
- * performed by an arbitrary command succeeded. Inspect original step receipts.
- */
-export function inspectJobOperation(job) {
-    return {
-        operationRef: { taskId: job.taskId, jobId: job.id },
-        ...job.operation,
-        state: job.status === "queued" ? "pending"
-            : job.status === "running" ? "running"
-                : job.status === "unknown-needs-attention" ? "unknown" : "finished",
-        outcome: job.result?.outcome,
-        result: job.result,
-        checkpoint: job.checkpoint
-    };
-}