@zq-silk/yui 0.15.12 → 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",
@@ -421,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.");
         }
@@ -457,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);
@@ -520,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));
                 }
@@ -562,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
@@ -574,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,
@@ -596,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()));
@@ -604,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) {
@@ -642,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, {
@@ -654,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
@@ -668,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({
@@ -684,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) {
@@ -805,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") {
@@ -1036,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
-    };
-}

package/dist/lifecycle/exactRunTerminalization.js

@@ -8,7 +8,6 @@ import { boundedRunFailureDiagnostic } from "../domain/agentResultTransport.js";
 import { updateExecutionLane, updateWorkItemExecutionLane } from "../execution/workItemExecution.js";
 import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
-import { markTaskWakeConsumed } from "../scheduler/taskWake.js";
 import { workItemExecutionGroupById, updateWorkItemExecutionGroup } from "../workItem/workItem.js";
 /**
  * Validate every immutable identity and frozen Project head needed before a
@@ -81,7 +80,7 @@ export function validateExactRunReviewRound(store, run, options = {}) {
         }
     }
     const task = store.getTask(run.taskId);
-    const taskScope = (round.scope ?? "work-item") === "task";
+    const taskScope = round.scope === "task";
     const item = taskScope || round.workItemId === undefined
         ? null
         : store.getWorkItem(run.taskId, round.workItemId);
@@ -410,13 +409,6 @@ export function terminalizeExactTaskRun(store, input, now) {
         roleName: terminal.roleName
     }), dispatchIdentity);
     settleRoleRunDispatch(store, dispatchIdentity, dispatchToken);
-    if (terminal.roleName === "leader") {
-        const wake = store.listTaskWakes(input.taskId)
-            .find((candidate) => candidate.runId === terminal.id && candidate.status === "dispatched");
-        if (wake !== undefined) {
-            store.saveTaskWake(input.taskId, markTaskWakeConsumed(wake, now));
-        }
-    }
     if (terminal.executionGroupId !== undefined && terminal.executionLaneId !== undefined) {
         store.clearActiveExecutionLaneRun(input.taskId, terminal.executionGroupId, terminal.executionLaneId);
     }

package/dist/message/inputControlResolution.js

@@ -36,9 +36,8 @@ function resolveInputControl(sessions, kind, expectedTarget, roleName) {
             detail: `Agent plan '${active.adapterId}' has no native interrupt; Yui will not `
                 + "stop the owned process, kill, restart, or detach it." };
     }
-    // A Global Role now carries the same optional providerBinding as a Task Role;
-    // both read it the same way. Its absence is "no current Turn", never an error.
-    const binding = "providerBinding" in sessions ? sessions.providerBinding ?? null : null;
+    // Both scopes use the same explicit null for an uncontrolled Session.
+    const binding = sessions.providerBinding;
     const turn = binding?.run ?? null;
     if (binding === null || turn === null || !PRESENT_TURN_STATUSES.has(turn.status)) {
         return { outcome: "no-active-turn", code: "NO_ACTIVE_TURN",
@@ -78,7 +77,7 @@ function resolveInputControl(sessions, kind, expectedTarget, roleName) {
             ...(turn.nativeTurnId === undefined ? {} : { nativeTurnId: turn.nativeTurnId }),
             attemptId: turn.attemptId,
             authority: { epoch: binding.authority.epoch, owner: "controller",
-                holderId: binding.authority.holderId ?? "controller" }
+                holderId: binding.authority.holderId }
         } };
 }
 /**