@zq-silk/yui 0.15.11 → 0.16.0

package/dist/commands/taskOverviewCommand.js

@@ -1,376 +0,0 @@
-import { usageError } from "../errors/cliError.js";
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
-import { formatTimestamp } from "../output/timePresentation.js";
-import { pendingWakeupProjection } from "../storage/taskStore.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProjection.js";
-import { resolveRuntimeHealth } from "../config/yuiConfig.js";
-import { projectNextAction } from "../task/nextAction.js";
-import { projectTaskRemoteDeliveryFromStore } from "./taskRemoteDeliveryCommand.js";
-export function parseTaskListOptions(args) {
-    const allowed = new Set(["--all", "--verbose"]);
-    if (args.some((argument) => !allowed.has(argument))
-        || new Set(args).size !== args.length) {
-        throw usageError("Task list usage: yui task list [--all] [--verbose].");
-    }
-    return {
-        all: args.includes("--all"),
-        verbose: args.includes("--verbose")
-    };
-}
-export function buildTaskOverview(store, options, now = new Date()) {
-    const runtimeHealthPolicy = resolveRuntimeHealth(store.getConfig().runtimeHealth);
-    const tasks = store.listTasks()
-        .filter((task) => options.all || task.status !== "archived")
-        .map((task) => buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy));
-    return { tasks };
-}
-export function renderTaskOverview(result, options, timeZone, width = defaultTableWidth()) {
-    if (result.tasks.length === 0)
-        return "No tasks found.\n";
-    const title = options.all ? "Tasks (all)" : "Tasks (unarchived)";
-    const output = renderTable(title, [
-        { header: "Task", minWidth: 8, maxWidth: 20 },
-        { header: "Title", minWidth: 10, maxWidth: 46 },
-        { header: "Lifecycle", minWidth: 9, maxWidth: 14 },
-        { header: "Leader", minWidth: 12, maxWidth: 48 },
-        { header: "Summary updated", minWidth: 16, maxWidth: 28 },
-        { header: "Work", minWidth: 8, maxWidth: 38 },
-        { header: "Blockers", minWidth: 9, maxWidth: 42 },
-        { header: "Execution", minWidth: 14, maxWidth: 34 },
-        { header: "Delivery", minWidth: 12, maxWidth: 28 },
-        { header: "Next action / owner", minWidth: 16, maxWidth: 42 }
-    ], result.tasks.map((task) => [
-        task.id,
-        task.title,
-        task.status,
-        leaderCell(task),
-        task.summaryUpdatedAt === null
-            ? "missing"
-            : formatTimestamp(task.summaryUpdatedAt, timeZone),
-        workCell(task.work.counts),
-        blockersCell(task.blockers),
-        `${task.execution.status} / ${task.execution.owner}`,
-        deliveryCell(task.remoteDelivery),
-        nextCell(task.next)
-    ]), width);
-    if (!options.verbose)
-        return `${output}\n`;
-    return `${output}\n\n${renderVerboseDetails(result.tasks, timeZone)}\n`;
-}
-function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
-    const brief = store.getTaskBrief(task.id);
-    const roles = store.listRoles(task.id);
-    const leaderRole = roles.find((role) => role.name === "leader") ?? null;
-    const workItems = store.listWorkItems(task.id);
-    const inputRequests = store.listInputRequests(task.id);
-    const openInputRequests = inputRequests.filter((request) => request.status === "open");
-    const runs = store.listRuns(task.id);
-    const events = store.listEvents(task.id);
-    const leaderFailure = store.getLeaderFailure(task.id);
-    const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: "leader" });
-    const pendingWakeup = pendingWakeupProjection(leaderMailbox);
-    const reviewRounds = store.listReviewRounds(task.id);
-    const changeSets = store.listChangeSets(task.id);
-    const integrations = store.listIntegrationAttempts(task.id);
-    const roleSessions = roles.flatMap((role) => {
-        const session = store.getRoleSession(task.id, role.name);
-        return session === null ? [] : [{ roleName: role.name, ...session }];
-    });
-    const providerRuns = new Map(roles.map((role) => [role.name, store.getTaskRoleSessionSet(task.id, role.name)?.providerBinding?.run]));
-    const runDelivery = Object.fromEntries(runs.map((run) => {
-        const native = providerRuns.get(run.roleName);
-        return [run.id, native?.runId === run.id ? native.status : "unobserved"];
-    }));
-    const attention = collectAttention(task, runs, events, leaderFailure);
-    const blockers = collectBlockers(workItems, openInputRequests, attention);
-    const leader = {
-        role: "leader",
-        roleStatus: leaderRole === null
-            ? "missing"
-            : providerRuns.get("leader")?.status === "accepted" ? "running"
-                : roleSessions.some((session) => session.roleName === "leader") ? "unknown" : "idle",
-        summary: brief?.leaderSummary ?? null,
-        currentFocus: brief?.currentFocus ?? null,
-        updatedAt: brief?.updatedAt ?? null,
-        updatedBy: brief?.updatedBy ?? null,
-        summaryStatus: brief === null ? "missing" : "available"
-    };
-    const counts = countWorkItems(workItems);
-    const runtimeRuns = runs
-        .filter((run) => run.status === "active")
-        .map((run) => ({
-        id: run.id,
-        roleName: run.roleName,
-        status: run.status,
-        runtime: runDelivery[run.id],
-        createdAt: run.createdAt,
-        updatedAt: run.updatedAt
-    }));
-    const runtime = {
-        activeRuns: runtimeRuns,
-        activeRunCount: runtimeRuns.length,
-        pendingDeliveryCount: runtimeRuns.filter((run) => run.runtime !== "accepted").length
-    };
-    // Fold the execution projection from the facts already read above instead of
-    // reading the store a second time for the same unchanged revision.
-    const execution = projectTaskExecutionFromFacts({
-        task,
-        roles,
-        runs,
-        runDelivery,
-        workItems,
-        inputRequests,
-        reviewRounds,
-        changeSets,
-        integrations,
-        events,
-        brief,
-        pendingWakeup,
-        leaderMailbox,
-        leaderFailure,
-        roleSessions,
-        contextSnapshots: store.listContextSnapshots(task.id),
-        now,
-        runtimeHealthPolicy
-    });
-    const nextActionFacts = store.readNextActionFacts(task.id);
-    if (nextActionFacts === null) {
-        throw new Error(`Task disappeared while building its overview: ${task.id}.`);
-    }
-    const next = overviewNextAction(task, workItems, execution, projectNextAction({
-        ...nextActionFacts,
-        currentTaskReviewCandidate: null,
-        executionGroups: execution.executionGroups
-    }));
-    const persistedCandidate = task.status === "active" || task.status === "cancelled"
-        ? taskRemoteDeliveryCandidate(task)
-        : null;
-    const remoteDelivery = projectTaskRemoteDeliveryFromStore(store, task, persistedCandidate);
-    return {
-        ...task,
-        brief,
-        leader,
-        leaderSummary: leader.summary,
-        currentFocus: leader.currentFocus,
-        summaryUpdatedAt: leader.updatedAt,
-        summaryUpdatedBy: leader.updatedBy,
-        summaryStatus: leader.summaryStatus,
-        work: { counts, items: workItems },
-        input: { open: openInputRequests, openCount: openInputRequests.length },
-        attention,
-        attentionCount: attention.length,
-        blockers,
-        next,
-        nextAction: next?.action ?? null,
-        nextOwner: next?.owner ?? null,
-        runtime,
-        execution,
-        remoteDelivery
-    };
-}
-function collectAttention(task, runs, events, failure) {
-    const items = [];
-    if (failure !== null) {
-        items.push({
-            kind: "leader-recovery",
-            id: `leader-recovery:${task.id}`,
-            status: "failed",
-            owner: "operator",
-            summary: failure.message,
-            updatedAt: failure.lastFailedAt
-        });
-    }
-    for (const run of runs) {
-        if (run.roleName !== "leader"
-            || run.status !== "active"
-            || !isRoleRunStalled(events, run.id))
-            continue;
-        const progressAt = latestStallProgressAt(events, run.id) ?? run.updatedAt;
-        items.push({
-            kind: "leader-stalled",
-            id: `leader-stall:${run.id}:${progressAt}`,
-            status: "needs-attention",
-            owner: "operator",
-            summary: `AgentRun ${run.id} for ${run.roleName} has no durable progress after ${progressAt}.`,
-            updatedAt: progressAt,
-            runId: run.id,
-            roleName: run.roleName
-        });
-    }
-    return items.sort((left, right) => (Date.parse(left.updatedAt) - Date.parse(right.updatedAt)
-        || left.id.localeCompare(right.id)));
-}
-function collectBlockers(workItems, openInputRequests, attention) {
-    const blockers = [];
-    const workById = new Map(workItems.map((item) => [item.id, item]));
-    for (const item of workItems) {
-        if ((item.status === "open" && item.currentCandidateId !== undefined)) {
-            blockers.push({
-                kind: "work",
-                type: "work",
-                id: item.id,
-                status: item.status,
-                owner: "leader",
-                action: "accept-work-item",
-                summary: `Work Item ${item.id} is awaiting Leader acceptance.`
-            });
-            continue;
-        }
-        if (item.status !== "open")
-            continue;
-        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "accepted"));
-        if (dependencies.length === 0)
-            continue;
-        blockers.push({
-            kind: "work",
-            type: "work",
-            id: item.id,
-            status: item.status,
-            owner: item.assignee ?? "leader",
-            action: "unblock-work-item",
-            summary: `Work Item ${item.id} is waiting on ${dependencies.join(", ")}.`
-        });
-    }
-    for (const request of openInputRequests) {
-        blockers.push({
-            kind: "input",
-            type: "input",
-            id: request.id,
-            status: request.status,
-            owner: "user",
-            action: "answer-input",
-            summary: request.question,
-            blockedRefs: request.blockedRefs
-        });
-    }
-    for (const item of attention) {
-        blockers.push({
-            kind: "attention",
-            type: "attention",
-            id: item.id,
-            status: item.status,
-            owner: item.owner,
-            action: item.kind === "leader-recovery"
-                ? "inspect-leader-recovery"
-                : "inspect-leader-stall",
-            summary: item.summary
-        });
-    }
-    return blockers;
-}
-function overviewNextAction(task, workItems, execution, action) {
-    if (task.status !== "active" && task.status !== "draft")
-        return null;
-    const primary = action.refs[0];
-    const workItem = action.refs
-        .filter(({ kind }) => kind === "work-item")
-        .map(({ id }) => workItems.find((item) => item.id === id))
-        .find((item) => item !== undefined);
-    const kind = primary?.kind === "input-request"
-        ? "input"
-        : primary?.kind === "work-item"
-            ? "work"
-            : action.kind.includes("attention") || action.kind.includes("inconsistency")
-                ? "attention"
-                : "execution";
-    return {
-        action: action.kind,
-        owner: action.kind === "resolve-input"
-            ? "user"
-            : workItem?.assignee ?? execution.owner,
-        kind,
-        ...(primary === undefined ? {} : { id: primary.id }),
-        summary: action.reason
-    };
-}
-function countWorkItems(items) {
-    const counts = {
-        total: items.length,
-        open: 0,
-        accepted: 0,
-        retired: 0
-    };
-    for (const item of items)
-        counts[item.status] += 1;
-    return counts;
-}
-function leaderCell(task) {
-    const status = task.leader.roleStatus;
-    if (task.leader.summaryStatus === "missing")
-        return `${status} · missing summary`;
-    const values = [task.leader.summary, task.leader.currentFocus]
-        .filter((value) => value !== null && value.length > 0);
-    return values.length === 0
-        ? `${status} · summary unavailable`
-        : compactText(`${status} · ${values.join(" · ")}`);
-}
-function workCell(counts) {
-    if (counts.total === 0)
-        return "none";
-    const details = Object.keys(counts)
-        .filter((status) => status !== "total" && counts[status] > 0)
-        .map((status) => `${status}:${counts[status]}`);
-    return `${counts.total} total${details.length === 0 ? "" : ` (${details.join(", ")})`}`;
-}
-function blockersCell(blockers) {
-    if (blockers.length === 0)
-        return "none";
-    return blockers.map((blocker) => `${blocker.kind}:${blocker.id}`).join(", ");
-}
-function nextCell(next) {
-    return next === null ? "—" : `${next.action} / ${next.owner}`;
-}
-function deliveryCell(delivery) {
-    if (delivery.status === "none")
-        return "none";
-    return `${delivery.status} · ${delivery.mergedProjectCount}/${delivery.codeProjectCount} merged`
-        + (delivery.allMerged
-            ? ` · ${delivery.verifiedProjectCount}/${delivery.codeProjectCount} verified`
-            : "");
-}
-function taskRemoteDeliveryCandidate(task) {
-    const projects = task.projectBindings.flatMap(({ projectId, currentCommit }) => (currentCommit === undefined ? [] : [{ projectId, commit: currentCommit }]));
-    return projects.length === task.projectBindings.length
-        ? { projects }
-        : null;
-}
-function compactText(value) {
-    const oneLine = value.replace(/\s+/g, " ").trim();
-    return oneLine.length <= 240 ? oneLine : `${oneLine.slice(0, 237)}...`;
-}
-function renderVerboseDetails(tasks, timeZone) {
-    return [
-        "Task details",
-        ...tasks.flatMap((task) => [
-            `${task.id}: ${task.title}`,
-            `  Description: ${task.description ?? "—"}`,
-            `  Current focus: ${task.currentFocus ?? "missing"}`,
-            `  Leader summary: ${task.leaderSummary ?? "missing"}`,
-            `  Summary updated by: ${task.summaryUpdatedBy ?? "unknown"}`,
-            `  Summary updated at: ${task.summaryUpdatedAt === null
-                ? "missing"
-                : formatTimestamp(task.summaryUpdatedAt, timeZone)}`,
-            `  Execution: ${task.execution.status} (${task.execution.owner}); ${task.execution.summary}`,
-            `  Remote delivery: ${deliveryCell(task.remoteDelivery)}; source=${task.remoteDelivery.source}${task.remoteDelivery.provisional ? " (provisional)" : ""}`,
-            `  Monitoring: ${task.execution.monitoring}; attention: ${task.execution.attention.length}`,
-            `  DAG: ${task.execution.observability.dag.nodes.length} nodes, ${task.execution.observability.dag.edges.length} edges; ready=${task.execution.observability.dag.readyIds.join(", ") || "none"}; blocked=${task.execution.observability.dag.blockedIds.join(", ") || "none"}`,
-            `  Cost: tokens=${task.execution.observability.cost.tokens}${task.execution.observability.cost.tokensObservable ? "" : " (partial)"}; tools=${task.execution.observability.cost.toolCalls}${task.execution.observability.cost.toolCallsObservable ? "" : " (partial)"}; wall=${task.execution.observability.cost.wallClockSeconds}s; retries=${task.execution.observability.cost.retryCount}`,
-            `  Context: snapshots=${task.execution.observability.context.snapshotCount}; bytes=${task.execution.observability.context.totalBytes ?? "partial"}; compression=unavailable`,
-            `  Session tokens: ${task.execution.observability.sessionTokens.length === 0
-                ? "unobserved"
-                : task.execution.observability.sessionTokens.map(({ roleName, metrics }) => {
-                    const total = metrics.cumulativeTotal.status === "observed"
-                        ? metrics.cumulativeTotal.totalTokens
-                        : "unobserved";
-                    const maximum = metrics.maximumRequestInput.status === "observed"
-                        ? metrics.maximumRequestInput.inputTokens
-                        : "unobserved";
-                    return `${roleName}: total=${total}, max-request-input=${maximum}`;
-                }).join("; ")}`,
-            `  Projects: ${task.projectBindings.length === 0
-                ? "none"
-                : task.projectBindings.map(({ directory, projectId, baseRef }) => (`${directory} (${projectId} @ ${baseRef})`)).join(", ")}`
-        ])
-    ].join("\n");
-}

package/dist/completion/completionWizard.js

@@ -1,125 +0,0 @@
-import { resolve } from "node:path";
-import { usageError } from "../errors/cliError.js";
-import { installCompletion, uninstallCompletion } from "./completionInstaller.js";
-import { COMPLETION_SHELLS, activationBlock, activationIsAutomatic, currentCompletionShell, inspectCompletionStates, renderCompletionStateTable, shellQuote, suggestedCompletionInstallation } from "./completionState.js";
-export async function runCompletionWizard(operation, store, env, identity, question, options = {}) {
-    const states = inspectCompletionStates(store.getConfig(), env, identity);
-    const current = currentCompletionShell(env);
-    let shell;
-    if (options.shell === undefined) {
-        const defaultSelection = options.defaultSelection ?? "current-shell";
-        const defaultHint = defaultSelection === "skip"
-            ? " [skip]"
-            : current === undefined ? "" : ` [${current}]`;
-        const skipHint = defaultSelection === "skip" ? "" : " (or skip)";
-        const answer = await question(`${renderCompletionStateTable(states, options.width)}\n`
-            + `Choose shell by number or name${defaultHint}${skipHint}: `);
-        const normalized = answer.trim().toLowerCase();
-        if (normalized === "skip" || (normalized.length === 0 && defaultSelection === "skip")) {
-            return `Completion ${operation} skipped.\n`;
-        }
-        shell = parseSelection(answer, current);
-    }
-    else {
-        shell = options.shell;
-    }
-    const state = states.find((candidate) => candidate.shell === shell);
-    if (state === undefined)
-        throw usageError("Completion shell selection is invalid.");
-    if (operation === "uninstall") {
-        if (state.installation === undefined) {
-            return `Completion ${shell} is not installed.\n`;
-        }
-        const confirm = normalize(await question(`Remove managed ${shell} completion?\n`
-            + `Script: ${state.installation.scriptPath}\n`
-            + `Activation: ${state.installation.activationPath}\n`
-            + "Remove now? [y/N]: "));
-        if (confirm !== "y" && confirm !== "yes") {
-            return `Completion ${shell} uninstall skipped.\n`;
-        }
-        uninstallCompletion(store, shell, identity);
-        return `Completion ${shell} uninstalled.\n`;
-    }
-    const suggested = state.installation
-        ?? suggestedCompletionInstallation(shell, env, identity);
-    const automatic = activationIsAutomatic(shell, suggested, env, identity);
-    const decision = normalize(await question(`Selected: ${shell} (${state.action})\n`
-        + `Script: ${suggested.scriptPath}\n`
-        + `Activation: ${suggested.activationPath}`
-        + `${automatic ? " (automatic)" : " (managed startup block)"}\n`
-        + "Install using these paths? [Y/n/customize]: "));
-    if (decision === "n" || decision === "no") {
-        return `Completion ${shell} installation skipped.\n`;
-    }
-    let installation = suggested;
-    let customized = false;
-    if (decision === "customize") {
-        const scriptPath = resolve((await question(`Completion script path [${suggested.scriptPath}]: `)).trim()
-            || suggested.scriptPath);
-        const activationPath = resolve((await question(`Activation file path [${suggested.activationPath}]: `)).trim()
-            || suggested.activationPath);
-        installation = { scriptPath, activationPath };
-        customized = true;
-    }
-    else if (decision !== "" && decision !== "y" && decision !== "yes") {
-        throw usageError("Choose Y, n, or customize.");
-    }
-    const needsActivation = !activationIsAutomatic(shell, installation, env, identity);
-    let activate = false;
-    let activationReady = !needsActivation;
-    if (needsActivation) {
-        const activationAnswer = normalize(await question(`${activationBlock(shell, installation, identity)}\n`
-            + `Update ${installation.activationPath} with the managed Yui block? [Y/n]: `));
-        if (activationAnswer !== ""
-            && activationAnswer !== "y"
-            && activationAnswer !== "yes"
-            && activationAnswer !== "n"
-            && activationAnswer !== "no") {
-            throw usageError("Choose Y or n.");
-        }
-        activate = activationAnswer === ""
-            || activationAnswer === "y"
-            || activationAnswer === "yes";
-        activationReady = activate || (!customized && state.status === "Installed");
-    }
-    installCompletion(store, shell, installation, env, identity, activate);
-    if (!activationReady) {
-        return `Completion ${shell} script installed; activation still required.\n`;
-    }
-    const result = `Completion ${shell} ${pastTense(state.action)}.\n`;
-    return needsActivation
-        ? `${result}${activationGuidance(shell, installation, env, identity)}`
-        : result;
-}
-function activationGuidance(shell, installation, env, identity) {
-    const unchanged = "The current shell is unchanged.\n";
-    const defaultActivationPath = suggestedCompletionInstallation(shell, env, identity).activationPath;
-    if (installation.activationPath !== defaultActivationPath) {
-        return `${unchanged}From a ${shell} session, load the custom activation file: source ${shellQuote(installation.activationPath)}\n`;
-    }
-    return currentCompletionShell(env) === shell
-        ? `${unchanged}Restart the current shell to activate completion: exec ${shell}\n`
-        : `${unchanged}Switch this terminal to ${shell} to activate completion: exec ${shell}\n`;
-}
-function parseSelection(value, current) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0 && current !== undefined)
-        return current;
-    if (/^[1-3]$/.test(normalized)) {
-        return COMPLETION_SHELLS[Number.parseInt(normalized, 10) - 1];
-    }
-    if (COMPLETION_SHELLS.includes(normalized)) {
-        return normalized;
-    }
-    throw usageError("Choose Bash, Zsh, or Fish by number or name.");
-}
-function pastTense(action) {
-    switch (action) {
-        case "Install": return "installed";
-        case "Refresh": return "refreshed";
-        case "Repair": return "repaired";
-    }
-}
-function normalize(value) {
-    return value?.trim().toLowerCase() ?? "";
-}

package/dist/context/dispatchContext.js

@@ -1,110 +0,0 @@
-export function buildRoleContext(context) {
-    return context.role.name === "leader"
-        ? buildLeaderContext(context)
-        : buildWorkerContext(context);
-}
-export function buildLeaderContext(context) {
-    return renderDispatchContext("leader", context);
-}
-export function buildWorkerContext(context) {
-    return renderDispatchContext("worker", context);
-}
-const WORKER_RUN_COMPLETION_MARKER = "Yui Role AgentRun result requirement:";
-const WORKER_RUN_COMPLETION_REQUIREMENT = [
-    WORKER_RUN_COMPLETION_MARKER,
-    "End the Provider turn with a truthful final report. Yui records that native turn result "
-        + "for the current AgentRun automatically; no completion command is required.",
-    "If you cannot finally determine success, failure, completeness, or the correct "
-        + "disposition, do not guess, silently stop, or hide uncertainty behind a success "
-        + "summary. Label the final report uncertain, incomplete, "
-        + "blocked, or requiring Leader judgment.",
-    "Report the most complete truthful evidence available and, when applicable: exact AgentRun, "
-        + "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.",
-    "The Provider turn ending closes only this AgentRun. It does not imply Leader acceptance, "
-        + "WorkItem completion, ChangeSet capture, Integration, or Task completion. Review AgentRuns "
-        + "report findings, verification gaps, and limits; the Leader decides disposition."
-].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}`
-    ].filter((line) => line !== null);
-    const workLines = kind === "worker"
-        ? renderWorkerScope(context)
-        : [];
-    const rendered = [
-        `Follow the injected yui-${kind} Skill for this Yui dispatch.`,
-        renderContextLayers(context, kind),
-        profileLines.join("\n"),
-        workLines.length === 0 ? null : workLines.join("\n"),
-        "Yui dispatch:",
-        requireText(context.input, "dispatch input")
-    ].filter((section) => section !== null && section.length > 0)
-        .join("\n\n");
-    return kind === "worker"
-        ? ensureWorkerRunCompletionRequirement(rendered)
-        : rendered;
-}
-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 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();
-    if (normalized.length === 0 || normalized.includes("\0")) {
-        throw new Error(`${label} is required.`);
-    }
-    return normalized;
-}