@zq-silk/yui 2.3.0 → 2.5.0

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { taskNotificationPresentation } from "../interaction/notificationPresentation.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { interruptThenTerminalState, prepareMessageContinuations } from "../message/messageContinuation.js";
 import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
@@ -35,7 +36,7 @@ import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } fro
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { acceptProviderTurn, beginProviderTurn, cancelQuiescentProviderInput, clearProviderGoal, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, settleProviderTurn, settleProviderTurnSubmission, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeUsageEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
 import { enqueueSupervisorEvent, recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT, foldRunProgressFacts, isRoleRunStalled, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey } from "../scheduler/roleRunStall.js";
@@ -1192,6 +1193,16 @@ export class FileSchedulerStoreAdapter {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
             }
             const currentRun = binding.run;
+            if (input.roleName === "leader" && input.attemptId.startsWith(`notification:${input.taskId}/`)) {
+                const wakeId = input.attemptId.split("/")[1];
+                const wake = store.listTaskWakes(input.taskId).find(w => w.id === wakeId);
+                const ids = new Set(wake?.refs?.filter(r => r.type === "message").map(r => r.id));
+                if (store.listMessages(input.taskId).some(m => ids.has(m.id)
+                    && m.inputControl?.expectedSessionId !== undefined
+                    && m.inputControl.expectedSessionId !== input.nativeSessionId)) {
+                    throw new AgentHostProviderTurnFenceError("Notification input belongs to the selected old Session; do not retarget.");
+                }
+            }
             if (session.effective.executionEnvironment !== undefined) {
                 assertExecutionEnvironmentCurrent(store, input.taskId, session.effective.executionEnvironment);
             }
@@ -1248,7 +1259,7 @@ export class FileSchedulerStoreAdapter {
             // before the Provider write; provider-visible userMessage items alone
             // are NOT proof of human authorship (managed prompts use those too).
             // This shares the exact writer/session admission and its transaction.
-            if (input.authorityOwner === "human" && input.roleName === "leader"
+            if ((input.authorityOwner === "human" || input.attemptId.startsWith(`human:${input.holderId}:`)) && input.roleName === "leader"
                 && input.runId === undefined && input.boundedText !== undefined) {
                 const prior = store.listEvents(input.taskId).find(event => event.type === "message.native-user-input" && event.payload.attemptId === input.attemptId);
                 if (prior !== undefined) {
@@ -1770,7 +1781,7 @@ export class FileSchedulerStoreAdapter {
                 directive: `Plan Task ${taskId} with the user. Persist requirements and decisions. Request activation explicitly; planning grants no delivery authority.`,
                 contextSnapshotRef: contextSnapshotRef(snapshot),
                 deltaRefIds: [] }), now, {
-                purpose: "planning", effective: resolveEffectiveLaunch({ role, purpose: "planning" })
+                purpose: "planning", effective: resolveEffectiveLaunch({ store, role, purpose: "planning" })
             });
             store.saveRun(run);
             store.saveActiveRun(run);
@@ -1838,7 +1849,11 @@ export class FileSchedulerStoreAdapter {
                 }
                 const nextAttempt = `notification:${taskId}/${wakeId}/${randomUUID()}`;
                 store.saveWorkMailbox({ ...mailbox, processing: { ...processing, batchId: nextAttempt } });
-                return { wakeId, attemptId: nextAttempt, disposition: "submit" };
+                const wake = store.getTaskWake(taskId, wakeId);
+                if (wake === null)
+                    throw new Error(`Notification wake is unavailable: ${taskId}/${wakeId}.`);
+                return { wakeId, attemptId: nextAttempt, disposition: "submit",
+                    presentation: taskNotificationPresentation(wake, store) };
             }
             if (mailbox.pending === null || (provider !== null && provider !== undefined
                 && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
@@ -1849,6 +1864,18 @@ export class FileSchedulerStoreAdapter {
             const sessions = store.getTaskRoleSessionSet(taskId, "leader");
             const session = sessions?.sessions[sessions.activeAgentId];
             const obsoleteIds = new Set();
+            for (const message of store.listMessages(taskId)) {
+                if (!pendingMessageIds.has(message.id) || message.inputControl?.expectedSessionId === undefined)
+                    continue;
+                if (message.inputControl.expectedSessionId !== session?.nativeSessionId
+                    || message.continuation?.notDeliveredReason !== undefined) {
+                    obsoleteIds.add(message.id);
+                    if (message.continuation?.notDeliveredReason === undefined)
+                        store.updateMessage(taskId, {
+                            ...message, continuation: { notDeliveredReason: "selected-native-session-changed" }
+                        });
+                }
+            }
             for (const message of claimedMessages) {
                 const claim = message.interruptThen;
                 if (claim.notDeliveredReason !== undefined
@@ -1896,7 +1923,7 @@ export class FileSchedulerStoreAdapter {
             // batch, rather than delivering them with the chosen immediate successor.
             if (remainingRefs.length > 0)
                 enqueueWork(store, target, "user-message", now, remainingRefs, { source: "controller", dedupeKey: `then-remainder:${wakeId}` });
-            return { wakeId, attemptId, disposition: "submit" };
+            return { wakeId, attemptId, disposition: "submit", presentation: taskNotificationPresentation(wake, store) };
         });
     }
     settleLeaderNotification(taskId, attemptId, outcome, now, detail, failure) {
@@ -3136,6 +3163,7 @@ function mapRole(store, role) {
     // Active AgentRun delivery separately and exclusively uses turn.effective.
     const effective = reopened || (liveSession !== null && liveSession.agentId !== role.activeAgentId)
         ? resolveEffectiveLaunch({
+            store,
             role,
             purpose,
             ...(workspace === undefined ? {} : { workspace }),
@@ -3144,6 +3172,7 @@ function mapRole(store, role) {
         : liveSession !== null && workspace?.owner.type === "task"
             ? effectiveLaunchWithTaskMainWorkspace(liveSession.effective, workspace)
             : liveSession?.effective ?? resolveEffectiveLaunch({
+                store,
                 role,
                 purpose,
                 ...(workspace === undefined ? {} : { workspace }),
@@ -3199,6 +3228,8 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
     return effective;
 }
 function globalSessionEffective(role, existing) {
+    // A native hook without a captured launch is not proof of loaded resources.
+    // Actual controlled launches supply their frozen effective snapshot explicitly.
     return existing?.effective ?? resolveEffectiveLaunch({ role, purpose: "execution" });
 }
 function mapSession(session) {
@@ -3292,10 +3323,10 @@ function compactedRuntimeObservationIds(events, incoming) {
     });
     const remove = ({ observation }) => {
         if (incoming.kind === "activity.observed") {
-            if (isRuntimeTokenEvidence(incoming))
+            if (isRuntimeUsageEvidence(incoming))
                 return false;
             return observation.kind === "activity.observed"
-                && !isRuntimeTokenEvidence(observation);
+                && !isRuntimeUsageEvidence(observation);
         }
         if (incoming.kind === "operation.started") {
             return (observation.kind === "operation.started"
@@ -3549,7 +3580,7 @@ function usageSnapshotIsSuperseded(events, incoming) {
         && observationIsStrictlyNewer(observation, incoming));
 }
 function hasPersistedRuntimeObservation(events, incoming) {
-    const usageIdentity = isRuntimeTokenEvidence(incoming)
+    const usageIdentity = isRuntimeUsageEvidence(incoming)
         ? incoming.eventId
         : undefined;
     return events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT

package/dist/controller/globalInputDelivery.js

@@ -4,6 +4,7 @@ import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/
 import { markGlobalRoleMessageNotDelivered } from "../message/message.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { globalMessagePresentation } from "../interaction/notificationPresentation.js";
 /** Messages are the only queue. Host's atomic begin arbitrates native writers. */
 export async function deliverGlobalInputs(home, store, ensure, onError) {
     for (const role of store.listGlobalRoles()) {
@@ -119,10 +120,7 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn", nativeSessionId,
                     authority: { epoch: binding.authority.epoch, owner: "controller",
                         holderId: binding.authority.holderId },
-                    run: { attemptId, boundedText: [
-                            `Yui Global Message: role=${role.name} message=${next.id}.`,
-                            "Read your Session Context and the referenced Message in full, then act on its durable input."
-                        ].join("\n") }
+                    run: { attemptId, boundedText: globalMessagePresentation(role.name, next.id, next) }
                 }
             });
             if (result.outcome === "rejected") {

package/dist/controller/jobControl.js

@@ -20,6 +20,7 @@ import { CliError } from "../errors/cliError.js";
 import { assertJobAssignmentScope, JobAssignmentScopeError } from "../job/jobAssignmentScope.js";
 import { assertContextRecordReadable } from "../context/taskContext.js";
 import { assertTaskProjectWriteAuthority } from "../task/taskAuthority.js";
+import { validateHttpPreview } from "../job/httpPreview.js";
 export function createDurableJobControl(store) {
     const authority = createJobCallAuthority(store);
     return {
@@ -32,6 +33,7 @@ export function createDurableJobControl(store) {
                 const context = authority.authenticate(Object.freeze({ ...params.caller }), params.taskId);
                 requireJobAssignment(tx, params, params.caller);
                 assertNonSecretJobInput(params);
+                validateHttpPreview(params.env, params.steps);
                 const baseKey = durableJobIdempotencyKey({
                     owner: params.owner,
                     projectId: params.projectId,

package/dist/controller/nativeHostInput.js

@@ -0,0 +1,37 @@
+import { applyTaskInputControl } from "../commands/taskCommands.js";
+import { applyGlobalInputControl } from "../commands/globalRoleCommands.js";
+/** The Host terminal is a human ingress, like the authenticated local Web
+ * surface. Fence that ingress before reusing the existing Message/control
+ * transaction; the Host performs the one Provider write after this returns. */
+export function prepareNativeHostSteer(store, input) {
+    return store.transaction(tx => {
+        const set = input.taskId === undefined ? tx.getGlobalRoleSessionSet(input.roleName)
+            : tx.getTaskRoleSessionSet(input.taskId, input.roleName);
+        const session = set?.sessions[input.agentId], binding = set?.providerBinding;
+        if (!session || session.status !== "active" || session.adapterId !== "codex"
+            || set?.activeAgentId !== input.agentId || session.nativeSessionId !== input.nativeSessionId
+            || binding?.run?.status !== "accepted" || binding.run.nativeTurnId !== input.nativeTurnId
+            || binding.authority.owner !== input.authorityOwner || binding.authority.epoch !== input.authorityEpoch
+            || binding.authority.holderId !== input.holderId
+            || (input.taskId !== undefined && input.roleName !== "leader")) {
+            throw new Error("Native steer carries a stale or unsupported Session/Turn/writer fence.");
+        }
+        if (!input.boundedText.trim() || input.boundedText.includes("\0") || Buffer.byteLength(input.boundedText) > 12000) {
+            throw new Error("Native steer exceeds its text bound.");
+        }
+        const control = { action: "steer", body: input.boundedText, to: input.roleName,
+            requestId: input.attemptId, expectedTarget: input.nativeTurnId, expectedSessionId: input.nativeSessionId };
+        if (input.taskId === undefined) {
+            applyGlobalInputControl(input.roleName, control, tx, { env: {} });
+        }
+        else {
+            applyTaskInputControl(input.taskId, { ...control, to: "leader" }, tx, { environment: {}, now: () => input.now });
+        }
+        const messages = input.taskId === undefined ? tx.listGlobalRoleMessages(input.roleName) : tx.listMessages(input.taskId);
+        const message = messages.find(message => message.inputControl?.requestId === input.attemptId);
+        if (message?.control?.outcome !== "pending") {
+            throw new Error("Native steer is already settled or unconfirmed; do not resubmit.");
+        }
+        return { attemptId: message.control.receiptId, boundedText: input.boundedText };
+    });
+}

package/dist/controller/providerRetryDelivery.js

@@ -10,6 +10,7 @@ import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending, prov
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { retryIntentBlocker } from "./providerRetryAdmission.js";
 import { recordGlobalRuntimeAttention } from "./globalRuntimeAttention.js";
+import { globalMessagePresentation, taskNotificationPresentation } from "../interaction/notificationPresentation.js";
 /** Hooks in the existing Controller pass and nearest-deadline timer. SQLite's
  * current Provider input is the only pending intent; nothing is queued here. */
 export function createProviderRetryHooks(home, store, ports = {}) {
@@ -185,11 +186,12 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                             });
                         }
                         else {
+                            const wake = retry.input.kind === "wake" ? store.getTaskWake(retry.input.taskId, retry.input.wakeId) : null;
                             const original = retry.input.kind === "text" ? retry.input.text
                                 : retry.input.kind === "wake"
-                                    ? `Yui Task notification: task=${retry.input.taskId} wake=${retry.input.wakeId}.\nRead current Task context and that fixed wake window, including original Messages in full. This is not an execution assignment.`
+                                    ? wake === null ? undefined : taskNotificationPresentation(wake, store)
                                     : retry.input.kind === "message"
-                                        ? `Yui Global Message: role=${retry.input.roleName} message=${retry.input.messageId}.\nRead your Session Context and referenced original Message in full.`
+                                        ? globalMessagePresentation(retry.input.roleName, retry.input.messageId, store.listGlobalRoleMessages(retry.input.roleName).find(message => retry.input.kind === "message" && message.id === retry.input.messageId))
                                         : undefined;
                             if (original === undefined) {
                                 stop(set, "original-input-unavailable", at);

package/dist/controller/runtime.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
+import { prepareNativeHostSteer } from "./nativeHostInput.js";
 import { archiveLeaderTask } from "../task/leaderArchive.js";
 import { TaskWorkspaceCoordinator } from "../repository/taskWorkspaceCoordinator.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
@@ -33,8 +34,15 @@ import { openSchedulerTelemetry } from "../telemetry/telemetryWiring.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { createControllerWeb } from "../web/controllerWeb.js";
+import { createTaskPreviews } from "../web/taskPreviews.js";
 import { TmuxWebTerminalService } from "../web/tmuxWebTerminal.js";
 import { createWebTaskSurface } from "../web/webTaskSurface.js";
+import { createWebConversationSurface } from "../web/webConversation.js";
+import { WebRequestRejected } from "../web/webMutation.js";
+import { inspectAgentHost, sendAgentHostNativeControl, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
+import { archiveOrdinaryTask } from "../task/ordinaryArchive.js";
+import { createWebSettings } from "../web/webSettings.js";
+import { createWebSkills } from "../web/webSkills.js";
 import { isTaskOwnedWorkspace, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { AgentRuntimeObserver } from "./agentRuntimeObserver.js";
 import { createCapabilityDispatcher } from "./capabilityBridge.js";
@@ -378,10 +386,64 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                         runningRuntime?.signal(`task:${target.taskId}`);
                 },
                 reconcileTask: (taskId) => runningRuntime?.signal(`task:${taskId}`)
-            }, yuiHome: home });
+            }, yuiHome: home }, [], undefined, {
+            archive: async (taskId) => {
+                if (!(workspacePreparer instanceof FileTaskWorkspacePreparer))
+                    throw new Error("Archive workspace owner unavailable.");
+                return archiveOrdinaryTask(new TaskWorkspaceCoordinator(store, workspacePreparer, webWorkflow), taskId, { environment: {}, yuiHome: home });
+            }
+        });
         const surfaces = new SurfaceContributions(kernel.capabilities.registry);
+        const validateNativeWrite = (request) => {
+            const sessions = request.scope === "task" ? store.getTaskRoleSessionSet(request.taskId, request.roleName)
+                : store.getGlobalRoleSessionSet(request.roleName);
+            const selected = sessions?.sessions[sessions.activeAgentId];
+            if (!request.nativeSessionId || selected?.nativeSessionId !== request.nativeSessionId
+                || selected.status !== "active"
+                || (request.scope === "task" && (request.roleName !== "leader"
+                    || selected.adapterId !== "codex" || !sessions?.providerBinding
+                    || !["active", "draft"].includes(store.getTask(request.taskId)?.status ?? "")
+                    || store.getTask(request.taskId)?.executionGate.state !== "enabled"))) {
+                throw new Error("Native input requires the selected current controlled Codex Operator/Leader.");
+            }
+        };
         const web = createControllerWeb(store, {
+            previews: () => createTaskPreviews(store, home),
+            skills: createWebSkills(store),
+            settings: createWebSettings(store, {
+                environment: options.environment ?? process.env, catalogs,
+                refreshConfiguration: () => {
+                    if (!runningRuntime)
+                        throw new Error("Controller runtime unavailable.");
+                    runningRuntime.reloadReconciliationInterval();
+                }
+            }),
             surface: webSurface,
+            conversation: createWebConversationSurface(store, webSurface, (owner, id) => planner.planNativeControl(owner, id), undefined, (owner) => inspectAgentHost({ home, ...owner }), {
+                hasWriter: owner => tmux.hasWritableClient(owner.scope === "task" ? owner.taskId : "operator", owner.scope === "task" ? owner.roleName : undefined),
+                respond: async (owner, id, requestId, nativeTurnId, result) => {
+                    const receipt = await sendAgentHostNativeControl({
+                        home, ...owner, control: { protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "native-respond",
+                            nativeSessionId: id, requestId, nativeTurnId, result }
+                    });
+                    if (receipt.outcome !== "accepted")
+                        throw new Error(receipt.snapshot.detail ?? "Native answer was not confirmed.");
+                    return { outcome: receipt.outcome };
+                },
+                setModel: async (owner, id, model) => {
+                    const result = await sendAgentHostNativeControl({
+                        home, ...owner, control: { protocol: AGENT_HOST_CONTROL_PROTOCOL,
+                            type: "native-model", nativeSessionId: id, model }
+                    });
+                    if (result.outcome !== "accepted") {
+                        const detail = result.snapshot.detail ?? "Model adoption is unconfirmed.";
+                        if (result.failure?.inputDisposition === "not-accepted")
+                            throw new WebRequestRejected(detail);
+                        throw new Error(detail);
+                    }
+                    return { outcome: result.outcome, runConfiguration: result.snapshot.runConfiguration };
+                }
+            }, catalogs),
             answerInput: async ({ taskId, inputId, answer }) => webSurface.answer(taskId, inputId, answer),
             panels: {
                 list: (taskId) => surfaces.listPanels(kernel.capabilities.authenticateWebQuery(taskId)),
@@ -390,6 +452,26 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             terminal: new TmuxWebTerminalService({
                 yuiHome: home, tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin), tmux,
                 prepareGlobalRole: (roleName) => webWorkflow.prepareGlobalRoleEnter(roleName),
+                prepareNative: async (request) => {
+                    if (!request.nativeSessionId)
+                        return false;
+                    const sessions = request.scope === "task" ? store.getTaskRoleSessionSet(request.taskId, request.roleName)
+                        : store.getGlobalRoleSessionSet(request.roleName);
+                    const selected = sessions?.sessions[sessions.activeAgentId];
+                    if (request.scope === "task" && (request.roleName !== "leader" || selected?.adapterId !== "codex"))
+                        return false;
+                    validateNativeWrite(request);
+                    // Preserve ordinary global native access on other adapters and the
+                    // existing uncontrolled Codex TUI. No lifecycle operation on a switch.
+                    if (selected?.adapterId !== "codex" || !sessions?.providerBinding)
+                        return request.scope === "global";
+                    const result = await sendAgentHostNativeControl({ home, ...request,
+                        control: { protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "native-open", nativeSessionId: request.nativeSessionId } });
+                    if (result.outcome !== "accepted" || !result.snapshot.nativeTui)
+                        throw new Error("Native TUI could not be opened.");
+                    return true;
+                },
+                validateWrite: validateNativeWrite,
                 environment: options.environment ?? process.env, onError: options.onError
             })
         });
@@ -612,6 +694,12 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 throw applicationError("INVALID_PARAMS", error instanceof Error ? error.message : String(error));
             }
         }
+        if (method === "runtime.native-steer-prepare") {
+            const value = providerTurnControlParams(params);
+            return prepareNativeHostSteer(store, { ...value,
+                nativeTurnId: requiredParam(params.nativeTurnId),
+                boundedText: requiredParam(value.boundedText) });
+        }
         if (method === "runtime.provider-turn-begin") {
             const value = providerTurnControlParams(params);
             try {
@@ -927,6 +1015,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
 function resolveRuntimeDesiredEffective(store, request, role) {
     if (request.scope === "global") {
         return resolveEffectiveLaunch({
+            store,
             role: role,
             purpose: "execution"
         });
@@ -940,6 +1029,7 @@ function resolveRuntimeDesiredEffective(store, request, role) {
         ?? store.getTaskWorkspace(request.taskId)
         ?? undefined;
     return resolveEffectiveLaunch({
+        store,
         role: taskRole,
         purpose: store.getTask(request.taskId)?.status === "draft" && request.roleName === "leader"
             ? "planning" : "execution",
@@ -1018,7 +1108,7 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
 }
 function currentDesiredEffective(store, request, role) {
     if (request.owner.scope === "global") {
-        return resolveEffectiveLaunch({ role: role, purpose: "execution" });
+        return resolveEffectiveLaunch({ store, role: role, purpose: "execution" });
     }
     const item = store.listWorkItems(request.owner.taskId).find((candidate) => (candidate.assignee === request.owner.roleName
         && !["accepted", "retired"].includes(candidate.status))) ?? null;
@@ -1028,6 +1118,7 @@ function currentDesiredEffective(store, request, role) {
         ?? store.getTaskWorkspace(request.owner.taskId)
         ?? undefined;
     return resolveEffectiveLaunch({
+        store,
         role: role,
         purpose: store.getTask(request.owner.taskId)?.status === "draft" && request.owner.roleName === "leader"
             ? "planning" : "execution",

package/dist/controller/runtimeEventInbox.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { closeSync, constants, existsSync, fchmodSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { createRuntimeObservation, isRuntimeTokenEvidence } from "../runtime/runtimeObservation.js";
+import { createRuntimeObservation, isRuntimeUsageEvidence } from "../runtime/runtimeObservation.js";
 import { boundedRunFailureDiagnostic, transportAgentResult } from "../domain/agentResultTransport.js";
 import { readAgentHostObservationSource } from "../runtime/agentHostProtocol.js";
 export const MAX_RUNTIME_EVENT_FILE_BYTES = 16 * 1024 * 1024;
@@ -174,7 +174,7 @@ export class FileRuntimeEventInbox {
     publish(event) {
         this.hooks.afterAdmission?.();
         if (event.type === "runtime-observation"
-            && isRuntimeTokenEvidence(event.observation)) {
+            && isRuntimeUsageEvidence(event.observation)) {
             const existing = this.list().find((candidate) => (candidate.type === "runtime-observation"
                 && candidate.taskId === event.taskId
                 && candidate.observation.eventId === event.observation.eventId));

package/dist/controller/runtimeEventProcessor.js

@@ -1,4 +1,4 @@
-import { isRuntimeTokenEvidence } from "../runtime/runtimeObservation.js";
+import { isRuntimeUsageEvidence } from "../runtime/runtimeObservation.js";
 const DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN = 64;
 /** Folds immutable Hook facts in one bounded transaction before acknowledging them. */
 export class FileRuntimeEventProcessor {
@@ -299,7 +299,7 @@ export function coalesceRuntimeProgress(events, instrumentation = {}) {
         }
         const representedByIndex = new Map();
         for (const indices of indicesByStream.values()) {
-            const hasUsage = isRuntimeTokenEvidence(segment[indices[0]].observation);
+            const hasUsage = isRuntimeUsageEvidence(segment[indices[0]].observation);
             // Usage facts and incomplete boundaries are authoritative history for
             // read-only Session token projection, so ingress never coalesces them.
             const retainedPositions = hasUsage ? indices.map((_, position) => position) : [];
@@ -403,7 +403,7 @@ function progressStreamKey(event) {
         fence.nativeTurnId ?? null,
         event.host ?? null,
         payload.activity,
-        isRuntimeTokenEvidence(event.observation) ? "usage" : "signal"
+        isRuntimeUsageEvidence(event.observation) ? "usage" : "signal"
     ]);
 }
 function isRuntimeActivityEvent(event) {

package/dist/doctor/doctor.js

@@ -2,6 +2,8 @@ import { accessSync, constants, existsSync, lstatSync, realpathSync } from "node
 import { isAbsolute, join } from "node:path";
 import Database from "better-sqlite3";
 import { inspectPty } from "./ptyProbe.js";
+import { gitVersionSupport } from "../repository/gitCompatibility.js";
+import { resolveExecutable } from "../external/pinnedCommandRunner.js";
 import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
 import { operationalAgentEnvironment } from "../agent/launchEnvironment.js";
 import { resolveTmuxBin } from "../config/yuiConfig.js";
@@ -684,6 +686,14 @@ function checkReviewerDispatch(_policy, role, binding, agent, launch, command, c
 function checkExecutable(name, command, args, executor) {
     try {
         const output = firstLine(executor.run(command, args));
+        if (name === "git") {
+            const support = gitVersionSupport(output);
+            return {
+                name, status: support.supported ? "ok" : "invalid",
+                detail: `${resolveExecutable(command, process.env.PATH) ?? command}: ${support.detail}`
+                    + (support.supported ? "" : " Select a supported Git in PATH and rerun doctor; no upgrade was performed.")
+            };
+        }
         return {
             name,
             status: "ok",

package/dist/execution/reviewMainRun.js

@@ -65,6 +65,7 @@ export function dispatchReviewSynthesis(store, taskId, reviewRoundId, sourceRunI
         throw new Error(`Review main workspace is missing: ${taskId}/${round.id}.`);
     }
     const effective = resolveEffectiveLaunch({
+        store,
         role,
         purpose: "review",
         workspace,

package/dist/execution/workItemMainRun.js

@@ -78,6 +78,7 @@ export function dispatchWorkItemSynthesis(store, taskId, workItemId, sourceRunId
         throw new Error(`WorkItem main workspace does not match its approved scope: ${item.id}.`);
     }
     const effective = resolveEffectiveLaunch({
+        store,
         role,
         purpose: "execution",
         workspace,

package/dist/executor/agentAdapter.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
+import { sessionContextInstructions } from "../context/sessionBootstrapManifest.js";
 import { isAgentAdapterId, supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
 import { ownedArgumentsForAdapter, validateAgentAdvancedArguments, validateAgentBaseArguments } from "../agent/argumentPolicy.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
@@ -434,10 +435,7 @@ function acpSessionBootstrap(input) {
             ])
         ]
         : [
-            `Yui managed Session. Read and follow the Session Manifest at `
-                + `${input.sessionManifestPath} (digest ${input.sessionManifestDigest ?? "unknown"}). `
-                + "Load each Skill and Role Profile by its manifest path before acting; Task "
-                + "content is available only through the manifest's exact Context API."
+            sessionContextInstructions(input.sessionManifestPath, input.sessionManifestDigest)
         ];
     const bootstrap = sections
         .filter((value) => value !== undefined && value.trim().length > 0)
@@ -500,7 +498,7 @@ function codexThreadOptions(input, config) {
 }
 function codexSessionInstructions(input) {
     if (input.sessionManifestPath !== undefined) {
-        return `Yui managed Session. Read and follow the Session Manifest at ${input.sessionManifestPath} (digest ${input.sessionManifestDigest ?? "unknown"}). Load each Skill and Role Profile by its manifest path before acting; Task content is available only through the manifest's exact Context API.`;
+        return sessionContextInstructions(input.sessionManifestPath, input.sessionManifestDigest);
     }
     const instructions = [
         input.developerInstructions,

package/dist/executor/codexConfigConflict.js

@@ -196,13 +196,15 @@ function exactTrust(directory, configured) {
     return undefined;
 }
 function resolveRepositoryRootForTrust(workspace) {
-    const result = spawnSync("git", ["-C", workspace, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", timeout: 1_000, windowsHide: true });
+    const result = spawnSync("git", ["-C", workspace, "rev-parse", "--git-common-dir"], { encoding: "utf8", timeout: 1_000, windowsHide: true });
     if (result.status !== 0 || result.error !== undefined)
         return undefined;
-    const commonDirectory = result.stdout.trim();
-    if (!isAbsolute(commonDirectory) || commonDirectory.includes("\0"))
+    if (!result.stdout.endsWith("\n"))
         return undefined;
-    const normalized = resolve(commonDirectory);
+    const commonDirectory = result.stdout.slice(0, -1);
+    if (commonDirectory.length === 0 || commonDirectory.includes("\0"))
+        return undefined;
+    const normalized = resolve(workspace, commonDirectory);
     return basename(normalized) === ".git" ? dirname(normalized) : undefined;
 }
 function inspectProjectDiscovery(contents) {

package/dist/executor/effectiveLaunch.js

@@ -2,7 +2,8 @@ import { isDeepStrictEqual } from "node:util";
 import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { roleSessionKind } from "../context/roleSessionContext.js";
+import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
+import { validateSkillPackageRef } from "../context/skillPackage.js";
 import { isAgentAdapterId } from "../agent/adapterCatalog.js";
 import { adapterIdForExecutionComponent, isAgentExecutionComponentId, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, sessionManifestCompatibilityDigest } from "../context/sessionProtocolIdentity.js";
@@ -15,6 +16,15 @@ export function resolveEffectiveLaunch(input) {
     const workspace = snapshotWorkspace(input.role.workspace, input.workspace);
     const writeProjectIds = effectiveWriteProjects(input, workspace);
     const config = resolveAgentAdapter(binding.adapterId).canonicalizeConfig(clone(binding.config));
+    const home = input.store?.rootDirectory() ?? input.yuiHome;
+    const sessions = "taskId" in input.role
+        ? input.store?.getTaskRoleSessionSet(input.role.taskId, input.role.name)
+        : input.store?.getGlobalRoleSessionSet(input.role.name);
+    const existing = sessions?.sessions[binding.agentId];
+    const continuing = existing?.status === "active";
+    const skillPackages = continuing ? existing.effective.skillPackages
+        : home === undefined ? undefined
+            : compileRoleSessionContext(home, input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, { purpose: input.purpose }).skills.map(skill => skill.package);
     return snapshotFromConfig({
         executionAuthority: input.executionAuthority ?? (input.purpose === "planning" ? "planning" : "delivery"),
         sourceDesiredRevision: input.role.launchRevision,
@@ -28,6 +38,7 @@ export function resolveEffectiveLaunch(input) {
             ? { executionEnvironment: input.role.executionEnvironment }
             : {}),
         context: snapshotContext(input.role),
+        ...(skillPackages === undefined ? {} : { skillPackages }),
         contextProtocolVersion: SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION,
         sessionManifestCompatibilityDigest: sessionManifestCompatibilityDigest(input.role.name, roleSessionKind(input.role, "taskId" in input.role
             ? { scope: "task", taskId: input.role.taskId }
@@ -216,6 +227,17 @@ export function validateEffectiveLaunchSnapshot(snapshot) {
         throw new Error("Effective launch Session Manifest compatibility digest is invalid.");
     }
     validateWorkspace(snapshot.workspace);
+    if (snapshot.skillPackages !== undefined) {
+        if (!Array.isArray(snapshot.skillPackages))
+            throw new Error("Effective Skill packages must be an array.");
+        const ids = new Set();
+        for (const ref of snapshot.skillPackages) {
+            validateSkillPackageRef(ref);
+            if (ids.has(ref.id))
+                throw new Error("Effective Skill packages must be unique.");
+            ids.add(ref.id);
+        }
+    }
     if (snapshot.executionEnvironment !== undefined) {
         validateExecutionEnvironmentSnapshot(snapshot.executionEnvironment);
         if (snapshot.executionEnvironment.access === "read") {
@@ -299,6 +321,7 @@ function snapshotFromConfig(input) {
             ? {}
             : { executionEnvironment: clone(input.executionEnvironment) }),
         context: cloneContext(input.context),
+        ...(input.skillPackages === undefined ? {} : { skillPackages: clone(input.skillPackages) }),
         contextProtocolVersion: input.contextProtocolVersion,
         sessionManifestCompatibilityDigest: input.sessionManifestCompatibilityDigest,
         ...review