@zq-silk/yui 0.15.0 → 0.15.2

package/dist/controller/runtimeLaunchCoordinator.js

@@ -1,7 +1,7 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { createRuntimeBinding, RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeLaunchError } from "../runtime/index.js";
-import { effectiveLaunchSnapshotsCompatible, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
+import { sameEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 class RuntimeBindingContractError extends Error {
     constructor(message, options) {
         super(message, options);
@@ -25,7 +25,6 @@ export class RuntimeLaunchCoordinator {
     #createGenerationId;
     #now;
     #assertCurrent;
-    #launchFingerprint;
     #onCleanupRequired;
     #runtimeIsolation;
     constructor(reservations, host, options = {}) {
@@ -34,8 +33,6 @@ export class RuntimeLaunchCoordinator {
         this.#createGenerationId = options.createGenerationId ?? randomUUID;
         this.#now = options.now ?? (() => new Date());
         this.#assertCurrent = options.assertCurrent;
-        this.#launchFingerprint = options.launchFingerprint
-            ?? defaultLaunchFingerprint;
         this.#onCleanupRequired = options.onCleanupRequired;
         this.#runtimeIsolation = options.runtimeIsolation;
     }
@@ -79,22 +76,19 @@ export class RuntimeLaunchCoordinator {
         if (request.owner.scope === "global" && request.managedWorkspace !== undefined) {
             throw new Error("A global runtime cannot use a Task ManagedWorkspace.");
         }
-        const expectedFingerprint = requireText(this.#launchFingerprint(request), "Launch fingerprint");
         const assertLaunchCurrent = () => {
             this.#assertCurrent?.(request);
             assertCurrent?.();
-            if (this.#launchFingerprint(request) !== expectedFingerprint) {
-                throw new Error(`Role or Agent launch state changed: ${request.owner.roleName}.`);
-            }
         };
-        const generationPrefix = `runtime-${expectedFingerprint}:generation:`;
         const proposedGenerationId = requireText(this.#createGenerationId(), "Launch generation id");
-        let proposedRuntimeGenerationId = `${generationPrefix}${proposedGenerationId}`;
+        // A Host activation id is an opaque durable identity, not a digest of the
+        // launch configuration. Whether a live activation may be reused is answered
+        // by the Role's durable Session record through `assertCurrent`, so launch
+        // configuration that only shapes the next activation never invalidates the
+        // current one.
+        let proposedRuntimeGenerationId = `runtime-${proposedGenerationId}`;
         let reusedConfirmedRunningHost = false;
         if (request.mode === "resume" && request.hostActivationId !== undefined) {
-            if (!request.hostActivationId.startsWith(generationPrefix)) {
-                throw new Error("Session restore targets an incompatible Host activation.");
-            }
             const inspection = await this.host.inspectOwner(request.owner);
             if (inspection.state === "unavailable" || inspection.state === "starting") {
                 throw new RuntimeLaunchError(true, request.hostActivationId, `Host activation is temporarily ${inspection.state}: ${request.owner.roleName}.`);
@@ -112,10 +106,6 @@ export class RuntimeLaunchCoordinator {
             runtimeGenerationId: proposedRuntimeGenerationId
         }, assertLaunchCurrent, this.#now());
         if (reservation.status === "existing") {
-            if (!reservation.runtimeGenerationId.startsWith(generationPrefix)) {
-                this.#requireCleanup(request.owner);
-                throw new Error(`Runtime launch reservation belongs to stale Role or Agent state: ${request.owner.roleName}.`);
-            }
             const inspection = await this.host.inspectOwner(request.owner);
             if (inspection.state === "unavailable" || inspection.state === "starting") {
                 throw new RuntimeLaunchError(true, reservation.runtimeGenerationId, `Runtime is temporarily ${inspection.state}: ${request.owner.roleName}/${reservation.runtimeGenerationId}.`);
@@ -416,7 +406,7 @@ function validateRuntimeLaunchPreflight(preflight, request, runtimeGenerationId)
         || preflight.turnId !== request.turnId
         || preflight.agentId !== request.agentId
         || preflight.adapterId !== request.adapterId
-        || !effectiveLaunchSnapshotsCompatible(preflight.effective, request.effective)
+        || !sameEffectiveLaunch(preflight.effective, request.effective)
         || (request.mode === "resume"
             && preflight.nativeSessionId !== request.nativeSessionId)) {
         throw new Error(`Session host pre-start launch fence does not match the requested runtime: ${request.owner.roleName}.`);
@@ -445,17 +435,6 @@ function requireMatchingRuntimeBinding(raw, request, runtimeGenerationId) {
     }
     return binding;
 }
-function defaultLaunchFingerprint(request) {
-    return createHash("sha256").update(JSON.stringify([
-        request.owner,
-        request.agentId,
-        request.adapterId,
-        request.effective,
-        request.workspace,
-        request.managedWorkspace,
-        request.runtimePolicy
-    ])).digest("hex");
-}
 function requireText(value, label) {
     if (typeof value !== "string"
         || value.length === 0

package/dist/controller/sessionNotify.js

@@ -7,6 +7,11 @@ import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 /** Hidden CLI entrypoint used by Codex's structured notify hook. */
 export async function runSessionNotifyCommand(payloadArgument, environment = process.env, call, setThreadName = setCodexThreadName) {
     const params = parseCodexSessionNotification(payloadArgument, environment);
+    // Old global TUIs can still emit their invocation-local hook. It is not
+    // evidence of a shared-daemon Thread's identity or process lifecycle.
+    // Global identity is committed from App Server at successful host start.
+    if (params.scope === "global")
+        return;
     const home = requireText(environment.YUI_HOME, "YUI_HOME");
     // A Codex process outlives its Turn, so the notify envelope cannot say which
     // Turn or runtime generation is current. Durable Session state answers both;

package/dist/core/boundedRpc.js

@@ -33,7 +33,9 @@ export function serializeError(error) {
             ...(error.stack === undefined ? {} : { stack: error.stack }),
             ...("code" in error && typeof error.code === "string"
                 ? { code: error.code }
-                : {})
+                : {}),
+            ...("currentRevision" in error && typeof error.currentRevision === "number"
+                ? { currentRevision: error.currentRevision } : {})
         };
     }
     return { name: "Error", message: String(error) };

package/dist/executor/agentExecutor.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validateRecentTurnIds } from "../runtime/recentTurnIds.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
+import { roleSessionMayContinue, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
 import { currentProviderActivation, endProviderActivation, settleProviderTurn, settleProviderTurnSubmission, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
@@ -66,10 +66,9 @@ export function recordRoleAgentSession(set, input, now) {
         throw new Error(`Role Agent session effective identity is inconsistent: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId === nativeSessionId
-        && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)
-        && !(set.owner.scope === "task"
-            && effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective))) {
-        throw new Error(`Role Agent session effective launch cannot change: ${agentId}.`);
+        && !roleSessionMayContinue(existing.effective, effective)) {
+        throw new Error(`Role Agent session cannot continue under this launch: ${agentId}. `
+            + "Its Agent, adapter or physical workspace changed.");
     }
     if (existing !== undefined && existing.nativeSessionId !== nativeSessionId
         && existing.status === "active") {
@@ -280,13 +279,11 @@ export function roleAgentSessionResumeMode(set, agentId, desired) {
     if (session.status === "ended") {
         return "new";
     }
-    const compatible = set.owner.scope === "task"
-        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, desired)
-        : effectiveLaunchSnapshotsCompatible(session.effective, desired);
-    if (compatible)
+    if (roleSessionMayContinue(session.effective, desired))
         return "resume";
-    throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
-        + "Stop the existing native process before starting a fresh Session.");
+    throw new Error(`Role Agent session cannot continue under the next launch: ${agentId}. `
+        + "Its Agent, adapter or physical workspace changed; stop the existing native "
+        + "process before starting a fresh Session.");
 }
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);

package/dist/executor/effectiveLaunch.js

@@ -69,7 +69,12 @@ function claudeConfigFromSnapshot(snapshot) {
             : { settingsSources: [...snapshot.settingsSources] })
     };
 }
-export function effectiveLaunchSnapshotsCompatible(existing, desired) {
+/**
+ * Exactness fence for one launch: the same resolved launch must be observed by
+ * every participant of that launch. Desired-revision bookkeeping is provenance
+ * and never part of the resolved launch itself.
+ */
+export function sameEffectiveLaunch(existing, desired) {
     validateEffectiveLaunchSnapshot(existing);
     validateEffectiveLaunchSnapshot(desired);
     const withoutDesiredRevision = (snapshot) => {
@@ -79,20 +84,24 @@ export function effectiveLaunchSnapshotsCompatible(existing, desired) {
     return isDeepStrictEqual(withoutDesiredRevision(existing), withoutDesiredRevision(desired));
 }
 /**
- * Task Role Sessions keep one physical workspace while Turn-scoped facts move.
- * Candidate commits, ReviewRound identity and desired-revision bookkeeping do
- * not define a native Session. Agent, adapter, permission, model, sandbox,
- * manifest, Role context and physical workspace identity still do.
+ * Whether a live native Session can still serve the next launch request.
+ *
+ * Only facts that make continuation impossible participate: the Session
+ * protocol, the provider identity that owns the conversation, and the physical
+ * workspace the Session runs in. Launch configuration such as model, effort,
+ * permission, Role context, declared write scope, and Turn-scoped facts like
+ * ReviewRound identity or candidate commits shape the next Host activation
+ * instead of ending the Session; that divergence is acknowledged where the
+ * configuration changes and stays visible as launch provenance.
+ *
+ * Session kind needs no separate check: a Role's review Turns run in their own
+ * ReviewRound workspace, so the physical workspace already separates a review
+ * Session from an execution Session.
  */
-export function effectiveLaunchSnapshotsCompatibleForTaskSession(existing, desired) {
-    if (effectiveLaunchSnapshotsCompatible(existing, desired))
-        return true;
+export function roleSessionMayContinue(existing, desired) {
     validateEffectiveLaunchSnapshot(existing);
     validateEffectiveLaunchSnapshot(desired);
-    if ((existing.reviewRoundId === undefined) !== (desired.reviewRoundId === undefined)) {
-        return false;
-    }
-    return isDeepStrictEqual(taskSessionCompatibleSnapshot(existing), taskSessionCompatibleSnapshot(desired));
+    return isDeepStrictEqual(sessionContinuitySnapshot(existing), sessionContinuitySnapshot(desired));
 }
 /** Preserves a fixed Session's launch configuration while freezing fresh Task-main Git facts. */
 export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
@@ -109,13 +118,21 @@ export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
         }
     });
 }
-function taskSessionCompatibleSnapshot(snapshot) {
-    const { sourceDesiredRevision: _sourceDesiredRevision, reviewRoundId: _reviewRoundId, reviewBaseCommit: _reviewBaseCommit, workspace, ...launch } = snapshot;
+function sessionContinuitySnapshot(snapshot) {
     return {
-        ...launch,
+        schemaVersion: snapshot.schemaVersion,
+        contextProtocolVersion: snapshot.contextProtocolVersion,
+        agentId: snapshot.agentId,
+        adapterId: snapshot.adapterId,
         workspace: {
-            root: workspace.root,
-            entries: workspace.entries.map(({ baseCommit: _baseCommit, baseRef: _baseRef, ...entry }) => entry)
+            root: snapshot.workspace.root,
+            entries: snapshot.workspace.entries.map((entry) => ({
+                projectId: entry.projectId,
+                directory: entry.directory,
+                access: entry.access,
+                path: entry.path,
+                branch: entry.branch
+            }))
         }
     };
 }

package/dist/executor/fileRoleLaunchPlanner.js

@@ -15,7 +15,7 @@ import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { classifyWorkspacePreflight, formatWorkspacePreflightError } from "./workspacePreflightClassification.js";
 import { activeLiveRoleAgentSession } from "./agentExecutor.js";
-import { effectiveLaunchSnapshotsCompatibleForTaskSession, effectiveLaunchSnapshotsCompatible, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.js";
+import { roleSessionMayContinue, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.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";
@@ -176,9 +176,7 @@ export class FileRoleLaunchPlanner {
         const effective = input.effective ?? resolvedEffective;
         const existing = sessionSet?.sessions[effective.agentId];
         const compatibleExisting = existing !== undefined
-            && (input.mode === "resume"
-                ? effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective)
-                : effectiveLaunchSnapshotsCompatible(existing.effective, effective));
+            && roleSessionMayContinue(existing.effective, effective);
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Task Role resume effective snapshot drifted: ${task.id}/${role.name}.`);
         }
@@ -204,7 +202,7 @@ export class FileRoleLaunchPlanner {
         const effective = input.effective ?? resolvedEffective;
         const existing = sessionSet?.sessions[effective.agentId];
         const compatibleExisting = existing !== undefined
-            && effectiveLaunchSnapshotsCompatible(existing.effective, effective);
+            && roleSessionMayContinue(existing.effective, effective);
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Global Role resume effective snapshot drifted: ${role.name}.`);
         }
@@ -246,7 +244,9 @@ export class FileRoleLaunchPlanner {
                     : undefined,
                 trustWorkspace: true
             });
-            assertCodexLaunchOverridesAvailable(codexConfig, ["developerInstructions", "notify"]);
+            assertCodexLaunchOverridesAvailable(codexConfig, owner.scope === "global"
+                ? ["developerInstructions"]
+                : ["developerInstructions", "notify"]);
         }
         const runtimeIsolation = input.runtimeIsolation === undefined
             ? undefined
@@ -365,10 +365,10 @@ export class FileRoleLaunchPlanner {
             args.push("--plugin-dir", ensureClaudeLifecyclePlugin(this.home, this.#cliPath));
         }
         if (binding.adapterId === "codex") {
-            // Global/interactive Codex sessions still use notify for presentation.
+            // Interactive Task sessions may use notify for presentation.
             // Managed Turns receive lifecycle facts through their ordinary App Server
             // subscription, avoiding a second Hook channel for the same Turn.
-            if (owner.scope !== "task" || input.turnId === undefined) {
+            if (owner.scope === "task" && input.turnId === undefined) {
                 args = addCodexSessionNotify(args, launchMode, this.#cliPath);
             }
             // Managed Codex Turns use disposable proxy clients against the shared
@@ -472,6 +472,9 @@ export class FileRoleLaunchPlanner {
                 YUI_WORKSPACE: effectiveWorkspace,
                 YUI_SESSION_MANIFEST: sessionContext.sessionManifestPath,
                 YUI_SESSION_CLI: sessionContext.sessionCliPath,
+                ...(owner.scope === "global" && configured.adapterId === "codex"
+                    ? { YUI_AGENT_BASE_ARGS: JSON.stringify(configured.baseArgs) }
+                    : {}),
                 ...(jobCallerKey === undefined ? {} : { YUI_JOB_CALLER_KEY: jobCallerKey }),
                 ...(owner.scope !== "task"
                     ? {}

package/dist/job/durableJob.js

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-export const CURRENT_DURABLE_JOB_SCHEMA_VERSION = 1;
+import { recordOperationEvidence, validateOperationFacts } from "../kernel/operationFacts.js";
+export const CURRENT_DURABLE_JOB_SCHEMA_VERSION = 2;
+export const JOB_RUNNER_IMPLEMENTATION = Object.freeze({ id: "yui:job-runner", generation: "1" });
 export const DURABLE_JOB_TERMINAL_STATUSES = [
     "succeeded",
     "failed",
@@ -14,7 +16,7 @@ export function isDurableJobTerminal(status) {
 }
 export function createDurableJob(input, now) {
     const timestamp = now.toISOString();
-    const idempotencyKey = input.retryOf === undefined
+    const contentKey = input.retryOf === undefined
         ? durableJobIdempotencyKey({
             owner: input.owner,
             projectId: input.projectId,
@@ -31,6 +33,10 @@ export function createDurableJob(input, now) {
             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");
     return validateDurableJob({
         schemaVersion: CURRENT_DURABLE_JOB_SCHEMA_VERSION,
         id: input.id,
@@ -42,6 +48,18 @@ export function createDurableJob(input, now) {
         env: { ...input.env },
         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",
+            targetId: input.workspace,
+            capability: "job.start",
+            implementation: JOB_RUNNER_IMPLEMENTATION,
+            effect: "none",
+            receiptRefs: [],
+            partialResultRefs: []
+        },
         status: "queued",
         artifactsLocator: input.artifactsLocator,
         createdAt: timestamp,
@@ -58,6 +76,10 @@ export function startDurableJob(job, process, now) {
     return validateDurableJob({
         ...job,
         status: "running",
+        operation: recordOperationEvidence(job.operation, {
+            effect: "confirmed",
+            receiptRefs: [`${job.artifactsLocator}/start.json`]
+        }),
         process: { ...process },
         startedAt: timestamp,
         heartbeatAt: timestamp,
@@ -87,20 +109,46 @@ export function completeDurableJob(job, result, now) {
     return validateDurableJob({
         ...job,
         status: result.outcome,
+        operation: recordOperationEvidence(job.operation, {
+            partialResultRefs: result.steps.map((step) => step.logPath),
+            receiptRefs: result.evidenceSource === undefined ? []
+                : [`${job.artifactsLocator}/${result.evidenceSource === "checkpoint" ? "checkpoint.json" : "exit.json"}`]
+        }),
         result: normalizeDurableJobResult(result),
         terminalAt: timestamp,
         updatedAt: timestamp
     });
 }
+/** A refused, unattempted request has a known failed outcome, not an unknown effect. */
+export function rejectQueuedDurableJob(job, reason, now) {
+    validateDurableJob(job);
+    if (job.status !== "queued" || job.operation.effect !== "none") {
+        throw new Error("Only an unattempted queued Job can be rejected.");
+    }
+    const timestamp = now.toISOString();
+    return validateDurableJob({
+        ...job,
+        status: "failed",
+        result: {
+            outcome: "failed", exitCode: null, signal: null,
+            unknownReason: requireText(reason, "DurableJob rejection reason"), steps: []
+        },
+        terminalAt: timestamp,
+        updatedAt: timestamp
+    });
+}
 export function markDurableJobUnknown(job, unknownReason, completedSteps, now) {
     validateDurableJob(job);
-    if (job.status !== "running") {
-        throw new Error(`DurableJob can only be marked unknown from running: ${job.status}.`);
+    if (job.status !== "running" && !(job.status === "queued" && job.operation.effect !== "none")) {
+        throw new Error(`DurableJob can only be marked unknown after an attempted effect: ${job.status}.`);
     }
     const timestamp = now.toISOString();
     return validateDurableJob({
         ...job,
         status: "unknown-needs-attention",
+        operation: recordOperationEvidence(job.operation, {
+            partialResultRefs: completedSteps.map((step) => step.logPath)
+        }),
         result: {
             outcome: "unknown-needs-attention",
             exitCode: null,
@@ -205,6 +253,7 @@ export function validateDurableJob(job) {
     if (job.schemaVersion !== CURRENT_DURABLE_JOB_SCHEMA_VERSION) {
         throw new Error(`DurableJob must use schemaVersion ${CURRENT_DURABLE_JOB_SCHEMA_VERSION}.`);
     }
+    validateOperationFacts(job.operation);
     validateTaskRecordReference({
         taskId: job.taskId,
         localId: job.id
@@ -326,7 +375,15 @@ export function validDurableJobTransition(before, after) {
         || before.createdAt !== after.createdAt
         || !isDeepStrictEqual(before.owner, after.owner)
         || !isDeepStrictEqual(before.env, after.env)
-        || !isDeepStrictEqual(before.steps, after.steps))
+        || !isDeepStrictEqual(before.steps, after.steps)
+        || before.operation.requestId !== after.operation.requestId
+        || before.operation.inputDigest !== after.operation.inputDigest
+        || before.operation.actorId !== after.operation.actorId
+        || before.operation.authorityRef !== after.operation.authorityRef
+        || before.operation.targetId !== after.operation.targetId
+        || before.operation.capability !== after.operation.capability
+        || !isDeepStrictEqual(before.operation.implementation, after.operation.implementation)
+        || !isDeepStrictEqual(recordOperationEvidence(before.operation, after.operation), after.operation))
         return false;
     if (isDurableJobTerminal(before.status)) {
         // A terminal job is immutable except for two one-way flags:
@@ -340,12 +397,17 @@ export function validDurableJobTransition(before, after) {
             && after.acknowledgedAt !== undefined;
         return before.status === after.status
             && isDeepStrictEqual(before.result, after.result)
+            && isDeepStrictEqual(before.operation, after.operation)
             && before.terminalAt === after.terminalAt
             && (before.wakeupNotified === after.wakeupNotified || wakeupFlip)
             && (before.acknowledgedAt === after.acknowledgedAt || acknowledgeFlip);
     }
     const allowed = {
-        queued: ["queued", "running", "cancelled"],
+        queued: [
+            "queued", "running", "cancelled", "unknown-needs-attention",
+            ...(before.operation.effect === "none" && after.operation.effect === "none"
+                ? ["failed"] : [])
+        ],
         running: [
             "running",
             "succeeded",

package/dist/kernel/callAuthority.js

@@ -0,0 +1,24 @@
+export class CallAuthority {
+    authenticateCurrent;
+    #credentials = new WeakMap();
+    constructor(authenticateCurrent) {
+        this.authenticateCurrent = authenticateCurrent;
+    }
+    authenticate(credential, targetId) {
+        const actorId = this.authenticateCurrent(credential, targetId);
+        const context = Object.freeze({ actorId, targetId });
+        this.#credentials.set(context, credential);
+        return context;
+    }
+    /** Reauthenticate at each new action; a context or implementation handle is
+     * not a permanent grant. Domain-specific authorization remains in its owner.
+     */
+    authorize(context, targetId) {
+        if (!this.#credentials.has(context) || context.targetId !== targetId) {
+            throw new Error("Untrusted or out-of-scope call context.");
+        }
+        const actorId = this.authenticateCurrent(this.#credentials.get(context), targetId);
+        if (actorId !== context.actorId)
+            throw new Error("Call authority changed.");
+    }
+}

package/dist/kernel/instanceHost.js

@@ -0,0 +1,97 @@
+export class InstanceHost {
+    #instances = new Map();
+    #closed = false;
+    attach(implementation, value, ownedDisposers = []) {
+        if (this.#closed)
+            throw new Error("Instance Host is closed.");
+        const key = implementationKey(implementation);
+        if (this.#instances.has(key))
+            throw new Error(`Implementation already attached: ${key}.`);
+        let resolve;
+        let reject;
+        const drained = new Promise((yes, no) => { resolve = yes; reject = no; });
+        // A disposer can fail before detach's caller starts awaiting the drain.
+        void drained.catch(() => undefined);
+        const ref = Object.freeze({ ...implementation });
+        this.#instances.set(key, {
+            implementation: ref, value, references: 0, detached: false,
+            disposers: [...ownedDisposers], drained, resolve, reject
+        });
+        return ref;
+    }
+    acquire(implementation) {
+        const instance = this.#instances.get(implementationKey(implementation));
+        if (this.#closed || instance === undefined || instance.detached) {
+            throw new Error("Implementation unavailable.");
+        }
+        instance.references += 1;
+        let released = false;
+        return Object.freeze({
+            implementation: instance.implementation,
+            value: instance.value,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                instance.references -= 1;
+                if (instance.detached && instance.references === 0)
+                    await this.#dispose(instance);
+            }
+        });
+    }
+    async use(implementation, call) {
+        const handle = this.acquire(implementation);
+        try {
+            return await call(handle.value, handle.implementation);
+        }
+        finally {
+            await handle.release();
+        }
+    }
+    /** Stops acquisition immediately. Resolves only after all calls/Sessions release. */
+    detach(implementation) {
+        const instance = this.#instances.get(implementationKey(implementation));
+        if (instance === undefined)
+            throw new Error("Implementation is not attached.");
+        instance.detached = true;
+        if (instance.references === 0)
+            void this.#dispose(instance).catch(() => undefined);
+        return instance.drained;
+    }
+    async close() {
+        this.#closed = true;
+        const results = await Promise.allSettled([...this.#instances.values()].map((instance) => this.detach(instance.implementation)));
+        const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (errors.length)
+            throw new AggregateError(errors, "Instance cleanup failed.");
+    }
+    #dispose(instance) {
+        instance.disposal ??= (async () => {
+            const errors = [];
+            for (const dispose of [...instance.disposers].reverse()) {
+                try {
+                    await dispose();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            // Keep the identity reserved for this Host's lifetime, including failures.
+            // Re-attaching a generation must not resurrect an old reference.
+            instance.value = undefined;
+            instance.disposers = [];
+            if (errors.length)
+                throw new AggregateError(errors, "Instance cleanup failed.");
+        })();
+        void instance.disposal.then(instance.resolve, instance.reject);
+        return instance.disposal;
+    }
+}
+function implementationKey(ref) {
+    for (const value of [ref.id, ref.generation]) {
+        if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
+            throw new Error("Implementation identity is invalid.");
+        }
+    }
+    return JSON.stringify([ref.id, ref.generation]);
+}

package/dist/kernel/kernelPorts.js

@@ -0,0 +1,44 @@
+import { createDurableJobControl } from "../controller/jobControl.js";
+import { JOB_RUNNER_IMPLEMENTATION } from "../job/durableJob.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.
+ */
+export function createKernelPorts(store, runner) {
+    const host = new InstanceHost();
+    const runnerImplementation = host.attach(JOB_RUNNER_IMPLEMENTATION, runner);
+    const runnerHandle = host.acquire(runnerImplementation);
+    const jobImplementation = host.attach({ id: "yui:job-control", generation: "1" }, createDurableJobControl(store));
+    // The Controller is a long-lived consumer of this exact implementation.
+    const jobHandle = host.acquire(jobImplementation);
+    return {
+        host,
+        jobImplementation,
+        runnerImplementation,
+        runner: runnerHandle.value,
+        jobs: jobHandle.value,
+        close: async () => {
+            const drain = host.close();
+            await jobHandle.release();
+            await runnerHandle.release();
+            await drain;
+        }
+    };
+}
+/** 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/kernel/operationFacts.js

@@ -0,0 +1,32 @@
+export function validateOperationFacts(facts) {
+    for (const value of [
+        facts?.requestId, facts?.actorId, facts?.authorityRef, facts?.targetId, facts?.capability,
+        facts?.implementation?.id, facts?.implementation?.generation
+    ]) {
+        if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
+            throw new Error("Operation identity is invalid.");
+        }
+    }
+    if (!/^[a-f0-9]{64}$/u.test(facts.inputDigest))
+        throw new Error("Operation input digest is invalid.");
+    if (!["none", "possible", "confirmed"].includes(facts.effect))
+        throw new Error("Operation effect is invalid.");
+    for (const refs of [facts.receiptRefs, facts.partialResultRefs]) {
+        if (!Array.isArray(refs) || refs.some((ref) => typeof ref !== "string" || !ref.trim())) {
+            throw new Error("Operation evidence references are invalid.");
+        }
+    }
+}
+/** Effects only accumulate. Later output failure or cancellation cannot erase evidence. */
+export function recordOperationEvidence(facts, evidence) {
+    const rank = { none: 0, possible: 1, confirmed: 2 };
+    const next = {
+        ...facts,
+        effect: evidence.effect !== undefined && rank[evidence.effect] > rank[facts.effect]
+            ? evidence.effect : facts.effect,
+        receiptRefs: [...new Set([...facts.receiptRefs, ...(evidence.receiptRefs ?? [])])],
+        partialResultRefs: [...new Set([...facts.partialResultRefs, ...(evidence.partialResultRefs ?? [])])]
+    };
+    validateOperationFacts(next);
+    return next;
+}