@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,3 +1,6 @@
+import { isDeepStrictEqual } from "node:util";
+import { hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -12,13 +15,16 @@ export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes) {
 export function renderTaskRoleRuntimeStatus(status) {
     const activeRun = status.activeRun === null
         ? "-"
-        : `${status.activeRun.id} (${status.activeRun.deliveredAt === undefined ? "queued" : "delivered"})`;
+        : `${status.activeRun.id} (${activeRunDeliveryLabel(status.activeRun)})`;
     const activeWork = status.activeWork === null
         ? "-"
         : `${status.activeWork.id} (${status.activeWork.status}) ${status.activeWork.title}`;
     const nativeSession = status.nativeSession === null
         ? "not recorded"
-        : `${status.nativeSession.nativeSessionId} (${status.nativeSession.status}, ${status.nativeSession.adapterId})`;
+        : `${status.nativeSession.nativeSessionId} (${status.nativeSession.status}, ${status.nativeSession.adapterId}, effective r${status.nativeSession.effective.sourceDesiredRevision})`;
+    const effectiveLaunch = status.effectiveLaunch === null
+        ? "not started"
+        : `${status.effectiveLaunch.agentId}/${status.effectiveLaunch.adapterId}; r${status.effectiveLaunch.sourceDesiredRevision}; Profile intent=${status.effectiveLaunch.profileAccess}; permission=${status.effectiveLaunch.permission.strategy}`;
     const tmux = status.tmux.state === "missing"
         ? "missing"
         : [
@@ -28,11 +34,7 @@ export function renderTaskRoleRuntimeStatus(status) {
             status.tmux.target
         ].filter((value) => value !== undefined).join(", ");
     const workspaceDetails = status.workspace.managed
-        ? [
-            `  Repository       ${status.workspace.repositoryId}`,
-            `  Branch           ${status.workspace.branch}`,
-            `  Base             ${status.workspace.baseRef} (${status.workspace.baseCommit})`
-        ]
+        ? status.workspace.entries.map((entry) => (`  Project          ${entry.directory} (${entry.access}) ${entry.branch} @ ${entry.baseCommit}`))
         : [];
     return [
         `Task Role status: ${status.taskId}/${status.roleName}`,
@@ -41,12 +43,23 @@ export function renderTaskRoleRuntimeStatus(status) {
         `  Reason           ${status.healthReason}`,
         `  Open inputs      ${status.openInputRequestCount}`,
         `  Agent            ${status.agentId}`,
+        `  Desired launch   r${status.desiredRevision}; Profile intent=${status.role.defaultAccess}`,
+        `  Effective launch ${effectiveLaunch}`,
+        `  Desired drift    ${status.effectiveLaunch === null
+            ? "-"
+            : status.launchDrift ? "pending next launch" : "none"}`,
+        `  Run/session      ${status.runSessionDrift ? "snapshot mismatch" : "snapshot consistent"}`,
         `  Role state       ${status.role.status}`,
         `  Active work      ${activeWork}`,
         `  Active run       ${activeRun}`,
+        `  Run attention    ${status.stall.active
+            ? `needs-attention (${status.stall.kind ?? "execution-stalled"}; no durable progress since ${status.stall.progressAt ?? "unknown"})`
+            : "none"}`,
         `  Native session   ${nativeSession}`,
+        `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
+        `  Fresh launch     ${status.freshLaunchAllowed ? "allowed" : "blocked"}`,
         `  tmux pane        ${tmux}`,
-        `  Workspace        ${status.workspace.path}`,
+        `  Workspace        ${status.workspace.managed ? status.workspace.root : status.workspace.path}`,
         ...workspaceDetails
     ].join("\n").concat("\n");
 }
@@ -56,8 +69,22 @@ export function taskRoleActiveWorkLabel(status) {
     return status.activeRun === null ? "-" : status.activeRun.id;
 }
 export function taskRoleNativeSessionLabel(status) {
+    if (status.runtimeCleanupPending && status.nativeSession === null)
+        return "reset (cleanup-pending)";
     return status.nativeSession?.status ?? "unbound";
 }
+export function inspectTaskRoleSessionRecovery(taskId, roleName, store) {
+    const sessions = store.getTaskRoleSessionSet(taskId, roleName);
+    const target = runtimeLifecycleTarget({ scope: "task", taskId, roleName });
+    const runtimeMailbox = store.getWorkMailbox(target);
+    return {
+        taskId,
+        roleName,
+        runtimeCleanupPending: hasRuntimeCleanupObligation(runtimeMailbox),
+        freshLaunchAllowed: (sessions === null
+            || sessions.sessions[sessions.activeAgentId] === undefined) && !hasRuntimeLifecycleWork(runtimeMailbox)
+    };
+}
 export function taskRoleOpenInputLabel(status) {
     return status.roleName === "leader" && status.openInputRequestCount > 0
         ? String(status.openInputRequestCount)
@@ -76,7 +103,15 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? null
         : store.getWorkItem(taskId, activeRun.workItemId);
     const sessions = store.getTaskRoleSessionSet(taskId, role.name);
-    const nativeSession = sessions?.sessions[role.activeAgentId] ?? null;
+    const effectiveAgentId = activeRun?.effective.agentId ?? sessions?.activeAgentId;
+    const nativeSession = effectiveAgentId === undefined
+        ? null
+        : sessions?.sessions[effectiveAgentId] ?? null;
+    const effectiveLaunch = activeRun?.effective ?? nativeSession?.effective ?? null;
+    const runSessionDrift = activeRun !== null
+        && nativeSession !== null
+        && !isDeepStrictEqual(activeRun.effective, nativeSession.effective);
+    const recovery = inspectTaskRoleSessionRecovery(taskId, role.name, store);
     const tmux = pane === undefined
         ? { state: "missing" }
         : {
@@ -86,15 +121,42 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
             ...(pane.pid === undefined ? {} : { pid: pane.pid }),
             currentCommand: pane.currentCommand
         };
-    const managedWorkspace = store.getRoleWorkspace(taskId, role.name);
+    // The active Run snapshot is authoritative for the live Role session.  It
+    // may point at a ReviewRound-owned workspace, which is intentionally
+    // distinct from the WorkItem Develop workspace.
+    const managedWorkspace = activeRun?.workspace
+        ?? (activeRun?.workItemId === undefined
+            ? store.getTaskWorkspace(taskId)
+            : store.getWorkItemWorkspace(taskId, activeRun.workItemId));
     const workspace = managedWorkspace === null
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
-    const health = calculateHealth(role, activeRun, nativeSession, tmux, openInputRequestCount);
+    const events = store.listEvents(taskId);
+    const stalled = activeRun !== null && isRoleRunStalled(events, activeRun.id);
+    const stallProgressAt = activeRun === null
+        ? undefined
+        : latestStallProgressAt(events, activeRun.id);
+    const stallKind = activeRun === null
+        ? undefined
+        : latestStallKind(events, activeRun.id);
+    const health = calculateHealth(role, activeRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled);
+    const stall = activeRun === null
+        ? { active: false }
+        : {
+            active: stalled,
+            ...(stallProgressAt === undefined
+                ? {}
+                : { progressAt: stallProgressAt }),
+            ...(stallKind === undefined ? {} : { kind: stallKind })
+        };
     return {
-        taskId,
-        roleName: role.name,
-        agentId: role.activeAgentId,
+        ...recovery,
+        agentId: effectiveLaunch?.agentId ?? role.activeAgentId,
+        desiredRevision: role.launchRevision,
+        effectiveLaunch,
+        launchDrift: effectiveLaunch !== null
+            && effectiveLaunch.sourceDesiredRevision !== role.launchRevision,
+        runSessionDrift,
         ...health,
         openInputRequestCount,
         role,
@@ -102,16 +164,40 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         activeWork,
         nativeSession,
         tmux,
-        workspace
+        workspace,
+        stall
     };
 }
-function calculateHealth(role, activeRun, nativeSession, tmux, openInputRequestCount) {
+function latestStallKind(events, runId) {
+    const event = [...events]
+        .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+    return event?.payload.kind === "delivery-stalled" || event?.payload.kind === "execution-stalled"
+        ? event.payload.kind
+        : undefined;
+}
+function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled) {
+    if (runtimeCleanupPending && nativeSession === null) {
+        return {
+            health: "needs-attention",
+            healthReason: "the native Session was reset; verified runtime cleanup is pending"
+        };
+    }
     if (role.status === "failed" || role.status === "exited") {
         return { health: "failed", healthReason: `persisted Role state is ${role.status}` };
     }
     if (nativeSession?.status === "broken") {
         return { health: "failed", healthReason: "the active native session is broken" };
     }
+    const awaitingProviderAcceptance = activeRun?.pushedAt !== undefined
+        && activeRun.deliveredAt === undefined;
+    if (awaitingProviderAcceptance
+        && tmux.state !== "running") {
+        return {
+            health: "needs-attention",
+            healthReason: "the pushed active Run is awaiting provider acceptance and has no live tmux pane"
+        };
+    }
     if (tmux.state === "exited") {
         return { health: "failed", healthReason: "the tmux pane has exited" };
     }
@@ -125,6 +211,12 @@ function calculateHealth(role, activeRun, nativeSession, tmux, openInputRequestC
         if (activeRun.deliveredAt !== undefined && tmux.state !== "running") {
             return { health: "needs-attention", healthReason: "the delivered active Run has no live tmux pane" };
         }
+        if (stalled) {
+            return {
+                health: "needs-attention",
+                healthReason: "the live active Run has no durable progress in the configured stall window"
+            };
+        }
     }
     if (activeRun === null && role.status === "running") {
         return { health: "needs-attention", healthReason: "the Role is running without an active Run" };
@@ -142,11 +234,25 @@ function calculateHealth(role, activeRun, nativeSession, tmux, openInputRequestC
         };
     }
     if (activeRun !== null) {
-        return activeRun.deliveredAt === undefined
-            ? { health: "starting", healthReason: "the active Run is awaiting tmux delivery" }
-            : { health: "running", healthReason: "the active Run has a live tmux pane" };
+        if (activeRun.deliveredAt !== undefined) {
+            return { health: "running", healthReason: "the active Run has a live tmux pane" };
+        }
+        if (activeRun.pushedAt !== undefined) {
+            return {
+                health: "awaiting-provider-acceptance",
+                healthReason: "the pushed active Run is awaiting provider acceptance"
+            };
+        }
+        return { health: "starting", healthReason: "the active Run is awaiting tmux delivery" };
     }
     return tmux.state === "running"
         ? { health: "ready", healthReason: "the native Agent pane is ready without active work" }
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
+function activeRunDeliveryLabel(run) {
+    if (run.deliveredAt !== undefined)
+        return "delivered";
+    if (run.pushedAt !== undefined)
+        return "pushed (awaiting provider acceptance)";
+    return "queued";
+}

package/dist/commands/textInput.js

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { usageError } from "../errors/cliError.js";
+export function readCommandText(inline, file, label, usage) {
+    if ((inline === undefined) === (file === undefined)) {
+        throw usageError(`Specify exactly one of ${label} or ${label}-file.`, usage);
+    }
+    const value = file === undefined
+        ? inline
+        : readFileSync(file === "-" ? 0 : file, "utf8");
+    const normalized = value.trim();
+    if (normalized.length === 0 || normalized.includes("\0")) {
+        throw usageError(`${label} is required.`, usage);
+    }
+    return normalized;
+}

package/dist/completion/completionInstaller.js

@@ -6,34 +6,38 @@ import { activationBlock, activationEnd, activationIsAutomatic, activationStart,
 export function installCompletion(store, shell, installation, env, identity, activate) {
     validateInstallation(installation);
     writeManagedScript(shell, installation.scriptPath, identity);
-    const config = store.getConfig();
-    store.saveConfig({
-        ...config,
-        completionInstallations: {
-            ...config.completionInstallations,
-            [shell]: installation
-        }
+    store.transaction((tx) => {
+        const config = tx.getConfig();
+        tx.saveConfig({
+            ...config,
+            completionInstallations: {
+                ...config.completionInstallations,
+                [shell]: installation
+            }
+        });
     });
     if (!activationIsAutomatic(shell, installation, env, identity) && activate) {
         writeActivationBlock(shell, installation, identity);
     }
 }
 export function uninstallCompletion(store, shell, identity) {
-    const config = store.getConfig();
-    const installation = config.completionInstallations?.[shell];
-    if (installation === undefined)
-        return;
-    assertManagedScriptRemovable(shell, installation.scriptPath, identity);
-    assertActivationRemovable(shell, installation, identity);
-    removeManagedScript(shell, installation.scriptPath, identity);
-    removeActivationBlock(shell, installation, identity);
-    const installations = { ...config.completionInstallations };
-    delete installations[shell];
-    store.saveConfig({
-        ...config,
-        completionInstallations: Object.keys(installations).length === 0
-            ? undefined
-            : installations
+    store.transaction((tx) => {
+        const config = tx.getConfig();
+        const installation = config.completionInstallations?.[shell];
+        if (installation === undefined)
+            return;
+        assertManagedScriptRemovable(shell, installation.scriptPath, identity);
+        assertActivationRemovable(shell, installation, identity);
+        removeManagedScript(shell, installation.scriptPath, identity);
+        removeActivationBlock(shell, installation, identity);
+        const installations = { ...config.completionInstallations };
+        delete installations[shell];
+        if (Object.keys(installations).length > 0) {
+            tx.saveConfig({ ...config, completionInstallations: installations });
+            return;
+        }
+        const { completionInstallations: _removed, ...withoutInstallations } = config;
+        tx.saveConfig(withoutInstallations);
     });
 }
 function assertManagedScriptRemovable(shell, path, identity) {

package/dist/config/yuiConfig.js

@@ -1,9 +1,10 @@
-export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 30;
+export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 120;
 export const MIN_RECONCILIATION_INTERVAL_SECONDS = 5;
 export const MAX_RECONCILIATION_INTERVAL_SECONDS = 300;
 /**
- * Resolves the durable Yui setting used for periodic full reconciliation.
- * Command-triggered scans remain immediate and do not use this interval.
+ * Resolves the durable Yui setting used for low-frequency recovery
+ * reconciliation. Normal durable state changes wake the Controller through
+ * its event queue and do not wait for this interval.
  */
 export function reconciliationIntervalMilliseconds(value) {
     const seconds = value ?? DEFAULT_RECONCILIATION_INTERVAL_SECONDS;

package/dist/context/dispatchContext.js

@@ -1,10 +1,6 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { dataError } from "../errors/cliError.js";
 /** Compatibility entry point used by the restored Task workflow. */
-export function compileDispatchInput(_store, taskId, role, input) {
-    const configuredSkillBodies = readConfiguredSkills(role.skills ?? []);
-    return buildRoleContext({ taskId, role, input, configuredSkillBodies });
+export function compileDispatchInput(_store, taskId, role, input, workContext = {}) {
+    return buildRoleContext({ taskId, role, input, ...workContext });
 }
 export function buildRoleContext(context) {
     return context.role.name === "leader"
@@ -17,53 +13,109 @@ export function buildLeaderContext(context) {
 export function buildWorkerContext(context) {
     return renderDispatchContext("worker", context);
 }
+const WORKER_RUN_COMPLETION_MARKER = "Yui Role Run completion requirement:";
+const WORKER_RUN_COMPLETION_REQUIREMENT = [
+    WORKER_RUN_COMPLETION_MARKER,
+    "Before ending, read the exact current Run ID from the managed first line and execute "
+        + "`yui task run yield <current-run-id> --summary-file - <<'YUI_SUMMARY'` "
+        + "followed by the outcome, evidence, and a closing `YUI_SUMMARY` line, "
+        + "replacing the placeholder with that ID.",
+    "If you cannot finally determine success, failure, completeness, or the correct "
+        + "disposition, do not guess, silently stop, or hide uncertainty behind a success "
+        + "summary. Use this exact yield path and label the handoff uncertain, incomplete, "
+        + "blocked, or requiring Leader judgment.",
+    "Report the most complete truthful evidence available and, when applicable: exact Run, "
+        + "WorkItem, and native Session identity; actions actually performed; changed paths "
+        + "and commit/worktree state; checks actually run and their outcomes; provider, runtime, "
+        + "or permission errors; the last confirmed lifecycle boundary; work not performed; "
+        + "unresolved assumptions or decisions; residual risks; confidence; and bounded next options.",
+    "Yield submits immutable Run evidence and a Candidate, or Review evidence only. It never "
+        + "implies Leader acceptance, WorkItem completion, ChangeSet capture, Integration, or "
+        + "Task completion. Review Runs report findings, verification gaps, and limits; the "
+        + "Leader decides disposition.",
+    "This exact control-plane permission does not grant repository writes, broad Bash, "
+        + "external effects, or cross-Run control.",
+    "If the exact yield is denied, do not retry, broaden permissions, use a wrapper, mutate "
+        + "Yui state, or invent delivery evidence. Truthfully surface the blocker through the "
+        + "supported provider failure boundary; there is no fallback protocol.",
+    "Yielding closes the Run and hands the WorkItem to the Leader for acceptance; "
+        + "a final response alone does neither.",
+    "The yield command must be your final tool action. After it succeeds, stop immediately: "
+        + "do not inspect, poll, accept, or perform any further work in the same native turn."
+].join("\n");
+export function ensureWorkerRunCompletionRequirement(input) {
+    return input.endsWith(`\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`)
+        ? input
+        : `${input}\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`;
+}
 function renderDispatchContext(kind, context) {
     const profile = context.role;
+    const binding = profile.agentBindings[profile.activeAgentId];
     const profileLines = [
         `Task: ${context.taskId}`,
         `Role: ${profile.name}`,
         `Active Agent: ${profile.activeAgentId}`,
+        `Runtime: ${binding.adapterId}; model: ${binding.config.model ?? "CLI default"}; effort: ${binding.config.effort ?? "CLI default"}; permission: ${binding.config.permission.strategy}`,
         profile.description === undefined ? null : `Description: ${profile.description}`,
         ...(profile.responsibilities ?? []).map((item) => `Responsibility: ${item}`),
         ...(profile.constraints ?? []).map((item) => `Constraint: ${item}`),
-        profile.expectedOutput === undefined ? null : `Expected output: ${profile.expectedOutput}`,
-        profile.systemPrompt === undefined ? null : `Role instruction: ${profile.systemPrompt}`,
-        profile.skills === undefined || profile.skills.length === 0
-            ? null
-            : `Configured role skills: ${profile.skills.join(", ")}`
+        profile.expectedOutput === undefined ? null : `Expected output: ${profile.expectedOutput}`
     ].filter((line) => line !== null);
-    return [
-        readSystemSkill(kind),
+    const workLines = kind === "worker"
+        ? renderWorkerScope(context)
+        : [];
+    const rendered = [
+        `Follow the injected yui-${kind} Skill for this Yui dispatch.`,
+        renderContextLayers(context, kind),
         profileLines.join("\n"),
-        ...(context.configuredSkillBodies ?? []).map((body) => body.trim()).filter(Boolean),
+        workLines.length === 0 ? null : workLines.join("\n"),
         "Yui dispatch:",
         requireText(context.input, "dispatch input")
-    ].filter(Boolean).join("\n\n");
+    ].filter((section) => section !== null && section.length > 0)
+        .join("\n\n");
+    return kind === "worker"
+        ? ensureWorkerRunCompletionRequirement(rendered)
+        : rendered;
 }
-function readConfiguredSkills(skills) {
-    const yuiHome = process.env.YUI_HOME;
-    if (skills.length === 0)
-        return [];
-    if (yuiHome === undefined) {
-        throw dataError("YUI_HOME is required to load configured Role skills.");
-    }
-    return skills.map((skill) => {
-        if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(skill)) {
-            throw dataError(`Invalid configured Skill id: ${skill}`);
-        }
-        try {
-            return readFileSync(join(yuiHome, "skills", skill, "SKILL.md"), "utf8").trim();
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-                throw dataError(`Configured Skill not found: ${skill}`);
-            }
-            throw error;
-        }
-    });
+function renderContextLayers(context, kind) {
+    const projects = context.projectPolicy ?? [];
+    const policyLines = projects.length === 0
+        ? ["- none (this Task is not Project-backed)"]
+        : projects.map(({ projectId, directory }) => {
+            const label = directory === undefined ? projectId : `${directory} (${projectId})`;
+            return `- ${label}: \`yui project show ${projectId}\`; then \`yui project knowledge list ${projectId}\` and show the relevant entries`;
+        });
+    return [
+        "Context layers:",
+        "- Yui Core: durable identity, lifecycle, access, workspace, and exact handoff safety.",
+        `- Generic ${kind} Skill: reusable role behavior and evidence discipline.`,
+        "- Project Policy: project-owned build, test, migration, release, and review rules; it is not a Yui Core default.",
+        ...["Project Policy references:", ...policyLines],
+        "- Task Contract: the current Task brief, WorkItem objective, acceptance criteria, and dispatch input.",
+        "Do not import rules from another Project or Task, and do not infer Project Policy from repository files alone."
+    ].join("\n");
 }
-function readSystemSkill(kind) {
-    return readFileSync(new URL(`../../skills/yui-${kind}/SKILL.md`, import.meta.url), "utf8").trim();
+function renderWorkerScope(context) {
+    if (context.workItem === undefined || context.workspace === undefined)
+        return [];
+    const writable = context.workspace.entries.filter(({ access }) => access === "write");
+    const contextOnly = context.workspace.entries.filter(({ access }) => access === "read");
+    const projectLines = (label, entries) => [
+        `${label}:`,
+        ...(entries.length === 0
+            ? ["- none"]
+            : entries.map(({ directory, projectId }) => `- ${directory} (${projectId})`))
+    ];
+    return [
+        `WorkItem: ${context.workItem.id}`,
+        `Workspace root: ${context.workspace.root}`,
+        ...projectLines("Writable Projects", writable),
+        ...projectLines("Context-only Projects", contextOnly),
+        `Read the full Task state with \`yui task context ${context.taskId}\`.`,
+        `Read the current WorkItem scope with \`yui task work list ${context.taskId}\`.`,
+        "Modify only Writable Projects. If another Project must change, stop and ask "
+            + "the Task Leader to expand this WorkItem scope before continuing."
+    ];
 }
 function requireText(value, label) {
     const normalized = value.trim();

package/dist/context/roleSessionContext.js

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
+const BUILTIN_YUI_SKILLS = new Set([
+    "yui-operator",
+    "yui-leader",
+    "yui-worker",
+    "yui-reviewer"
+]);
+/**
+ * Compiles stable Role policy for an Agent-native instruction channel.
+ * Dynamic wakeups and Run assignments deliberately remain outside this value.
+ */
+export function compileRoleSessionContext(yuiHome, role, owner, options = {}) {
+    const kind = roleSessionKind(role, owner, options.purpose ?? "execution");
+    const builtInSkillId = kind === "global" ? undefined : `yui-${kind}`;
+    const skillIds = unique([
+        ...(builtInSkillId === undefined ? [] : [builtInSkillId]),
+        ...(role.skills ?? [])
+    ]);
+    const skills = loadYuiSkillContexts(yuiHome, skillIds);
+    return {
+        developerInstructions: renderDeveloperInstructions(kind, role, owner),
+        skills,
+        ...(yuiHome === undefined
+            ? {}
+            : { managedContextFile: roleContextFile(yuiHome, role, owner, kind) })
+    };
+}
+function renderDeveloperInstructions(kind, role, owner) {
+    const core = renderRoleCore(kind, role, owner);
+    const profile = [
+        role.description === undefined ? null : `Role description: ${role.description}`,
+        ...(role.responsibilities ?? []).map((value) => `Role responsibility: ${value}`),
+        ...(role.constraints ?? []).map((value) => `Role constraint: ${value}`),
+        role.expectedOutput === undefined ? null : `Expected output: ${role.expectedOutput}`,
+        role.systemPrompt === undefined ? null : `Additional Role instructions:\n${role.systemPrompt}`
+    ].filter((value) => value !== null);
+    return [...core, ...profile].join("\n");
+}
+function roleSessionKind(role, owner, purpose) {
+    if (owner.scope === "global") {
+        return role.name === SYSTEM_OPERATOR_ROLE ? "operator" : "global";
+    }
+    if (purpose === "review")
+        return "reviewer";
+    return role.name === SYSTEM_LEADER_ROLE ? "leader" : "worker";
+}
+function renderRoleCore(kind, role, owner) {
+    switch (kind) {
+        case "operator":
+            return [
+                "You are the global Yui Operator and the user's CLI proxy.",
+                "Manage Yui through its CLI; do not perform Task implementation work.",
+                "Follow the injected yui-operator Skill when coordinating Yui."
+            ];
+        case "global":
+            return [
+                `You are global Yui Role ${role.name}.`,
+                "Follow the configured Role profile and the user's instructions."
+            ];
+        case "leader":
+            return [
+                `You are the Yui Leader for Task ${owner.scope === "task" ? owner.taskId : role.name}.`,
+                "Own Task stewardship and delegate bounded implementation work.",
+                "Follow the injected yui-leader Skill for Yui coordination."
+            ];
+        case "reviewer":
+            return [
+                `You are Yui review Role ${role.name} for Task ${owner.scope === "task" ? owner.taskId : role.name}.`,
+                "Review only the exact frozen ReviewRound scope assigned to this Run.",
+                "Follow the injected yui-reviewer Skill while reviewing Yui work."
+            ];
+        case "worker":
+            return [
+                `You are Yui Role ${role.name}${owner.scope === "task" ? ` for Task ${owner.taskId}` : ""}.`,
+                "Execute only the work delegated to this Role and report through Yui.",
+                "Follow the injected yui-worker Skill while handling Yui work."
+            ];
+    }
+}
+export function loadYuiSkillContexts(yuiHome, skillIds) {
+    return unique(skillIds).map((id) => loadSkill(yuiHome, id, BUILTIN_YUI_SKILLS.has(id)));
+}
+function loadSkill(yuiHome, id, builtIn) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id)) {
+        throw new Error(`Invalid configured Skill id: ${id}.`);
+    }
+    if (!builtIn && yuiHome === undefined) {
+        throw new Error("YUI_HOME is required to load configured Role skills.");
+    }
+    const path = builtIn
+        ? resolve(fileURLToPath(new URL(`../../skills/${id}/`, import.meta.url)))
+        : resolve(join(yuiHome, "skills", id));
+    try {
+        return { id, path, content: readFileSync(join(path, "SKILL.md"), "utf8").trim() };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            throw new Error(`Configured Skill not found: ${id}.`);
+        }
+        throw error;
+    }
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function roleContextFile(yuiHome, role, owner, kind) {
+    const identity = createHash("sha256").update(JSON.stringify([
+        owner.scope,
+        ...(owner.scope === "task" ? [owner.taskId] : []),
+        kind,
+        role.name,
+        role.activeAgentId
+    ])).digest("hex");
+    return resolve(join(yuiHome, "runtime", "session-contexts", `${identity}.md`));
+}