@zq-silk/yui 0.15.11 → 0.16.0

package/skills/yui-operator/SKILL.md

@@ -38,11 +38,21 @@ Inspect current Projects, Tasks, and relevant Task context before routing:
 
 ```sh
 yui project list
-yui task list
-yui task input list
+yui task list --json
 yui task context <candidate-task-id>
 ```
 
+Task listing is a bounded catalog. Do not unconditionally traverse every page.
+Filter by Project/status/search when
+useful; follow `nextCursor` with the same filters only when more candidates
+are needed. Attention counts cover the authorized catalog before ordinary
+filters and pagination. Follow a category's `--attention` query to enumerate
+its affected Tasks, clearing ordinary filters and retaining its `all` flag.
+`executionSignals` are conservative raw inspection
+candidates (including live Runs and open work), not a computed failure or
+execution status. Inspect the selected Task's Context and original Messages
+before routing or deciding; a summary/ref is not the requirement or report.
+
 Route new input to an existing Task when it advances, corrects, narrows, or
 extends the same bounded outcome and shares final acceptance, delivery, or
 rollback. Create a new Task only when the new outcome can succeed, fail,
@@ -64,14 +74,18 @@ yui operator submit "<related request and delta>" --task <task-id> --intent disc
 yui task create "<independent outcome>" \
   --project <project> --base <project>=<ref>
 yui operator submit "<request and routing context>" --task <new-task-id> --intent develop
-yui task activate <new-task-id>
+yui task activation request <new-task-id> --request-id <id> --environment <plan>
 ```
 
+Inspect an existing request before creating another. `task activate <task-id>`
+can adopt an eligible request in the foreground; it never activates a Draft
+without a recorded request and environment plan.
+
 Choose the submission intent explicitly; it is never inferred from the message
-text. `discuss` (the default, and what an old client sends) routes the Draft to
+text. `discuss` (the default) routes the Draft to
 planning; `record` saves the message without waking the Leader; `develop` asks an
 unplanned Draft to activate now, and reports the exact next step when it cannot
-(already planned → activate manually; execution stopped → start it first). Pass
+(already planned → request activation explicitly; execution stopped → start it first). Pass
 `--request-id <key>` to make a submission idempotent: retrying the same key
 returns the original message and routing instead of creating a duplicate, and the
 same key with different text is refused as a conflict.
@@ -128,9 +142,11 @@ For Agent-dependent settings, also read:
 yui --json config agent capabilities <agent-id>
 ```
 
-Use the live or cached capability catalog as authority for model, effort,
-permission, settings source, search, and service-tier values. Do not invent a
-provider value from memory.
+For a Task Role or a reported launch failure, use the scoped query from
+[runtime recovery](../yui-runtime/references/recovery.md#configuration-and-model-name-failures)
+instead of the global defaults above. The catalog reports native options and
+whether custom values are allowed; it is not a complete service-side whitelist.
+Distinguish current and cached metadata, and do not invent provider values from memory.
 
 A Profile combines portable behavior with either a dynamic Global Worker
 runtime source or an explicit Agent with optional model and effort. Applying it

package/skills/yui-reviewer/SKILL.md

@@ -60,6 +60,10 @@ binding fails before review begins:
   explicitly so the Leader can judge what remains useful. Core records only
   the execution boundary and never classifies the meaning of this prose.
 
+If the current retry projection says infrastructure recovery is already
+waiting or in flight, report that fact without recommending another dispatch.
+Do not manage the retry yourself or reinterpret its preserved candidate.
+
 The Review scope remains the current AgentRun's frozen candidate even if the Leader
 handles new user input or advances Task main while this Review is running. Do
 not switch to the newer head, cancel the current inspection, or claim the

package/skills/yui-runtime/SKILL.md

@@ -92,8 +92,15 @@ the Operator has routed to its public/task-authorized context command; never
 invent a Task AgentRun identity for a GlobalRole.
 
 A GlobalRole's durable input uses the same three actions as a Task Role,
-addressed by the Role's own name instead of a Task: `yui role message
-queue|steer <global-role>` and `yui role interrupt <global-role>`. Queue and steer
+addressed by the Role's own name instead of a Task. The local-user Web surface
+exposes this contract. Use `yui role message queue|steer <role> <text>` or
+`yui role interrupt <role>` through the public CLI. Queue/steer require a stable
+`--request-id`; steer/interrupt require the exact `--expected-target`.
+Configuration remains under `config role` and lifecycle under `session`.
+Do not fabricate Task/Run ownership or borrow the browser's user authority to
+bypass a managed Session boundary.
+
+Queue and steer
 save an owned Message; bare interrupt records a control request, not a new
 Message. Each uses a stable request id and that Role's own Session; none fabricates a Task or
 runId to reuse Task-scoped delivery. `queue` delivers at the Role's next legal
@@ -174,6 +181,14 @@ runtime identity and workspace progress; never edit Run status or substitute
 a native Session behind Yui's back. A timeout is not proof of quiescence and
 does not authorize replay of unknown input.
 
+Qualifying transient Provider failures have bounded Controller-owned recovery.
+Read the current `providerRetry`/`retry` projection before dispatching a manual
+successor. `waiting` and `in-flight` mean infrastructure recovery is already
+owned; do not add a private retry loop or resend the input. Only a proven native
+success resets that chain, and it never accepts a WorkItem or completes a Task.
+After recovery, inspect existing work and external receipts before continuing;
+the system's recovery instruction supplies no new user authority.
+
 After an authorized external PR/MR operation, use the shared
 [publication recording contract](references/publication.md). Recording delivery
 facts does not authorize the external operation, imply acceptance, or grant

package/skills/yui-runtime/references/publication.md

@@ -13,6 +13,26 @@ deployment status. After merge, use `yui task publication verify` only when
 current authorization covers that external provider read. Otherwise retain
 reported evidence and state the verification gap.
 
+Keep the completion head as the original acceptance evidence. If an authorized
+post-completion integration produced a different publication candidate, record
+its exact local commit, then read `task publication diff <task>/<publication>`.
+Inspect the complete delta against the original acceptance, including removals,
+conflict resolutions and additional changes. Only when that candidate still
+satisfies the result and its relevant increments are accepted, record
+`task publication adopt <task>/<publication> --reviewed-diff <sha256> --acceptance <text>`.
+Explain the semantic judgment and verification/review evidence in the acceptance.
+When an existing Task Integration produced that exact candidate, include
+`--integration <id>` in diff and adopt to bind its committed evidence.
+Ancestry or Integration success alone is not acceptance; do not reopen the Task,
+rewrite completion, or mark a merge verified to bridge an evidence gap.
+
+Adoption records a fixed decision, not remote verification or publication
+authority. The verify operation observes the exact Publication candidate through
+its provider and records contrary head/state facts as reported successors,
+invalidating previous verification. Metadata and verification updates may retain
+adoption while the candidate is unchanged; a changed candidate needs a new
+decision. Archived history is read-only to these adopt/verify operations.
+
 Use `yui task remote-delivery <task>` to explain external delivery. Publication
 is not Candidate acceptance, Review, Integration or Task completion.
 
@@ -21,7 +41,7 @@ the exact Task, checks archive eligibility, then uses `--integrated` for verifie
 merged delivery or `--abandon` for deliberate non-delivery. General archive
 approval never implies `--force` authority. Preserve the Task record.
 
-With explicit force authorization for a completed or retired Task, use
+With explicit force authorization for a completed or cancelled (retired) Task, use
 `yui task archive <task> (--integrated|--abandon) --force`. Force commits the
 archive and stops new Task scheduling before attempting safe foreground cleanup.
 Missing/stale delivery evidence, unresolved execution and cleanup errors become
@@ -34,9 +54,11 @@ Publication/completion evidence. Unverified local commits and resources that
 cannot be safely released stay owned and traceable. Late runtime events remain
 source evidence, not authority to resume or settle unknown input.
 
-Read `task show <task> --json` for `archive.warnings`, `retainedResources` and
-cleanup events; `task context` also retains the original records/events. A
-successful archive exit means `archived=true`, not that cleanup fully succeeded.
+Read `task show <task> --json` for `data.archive.warnings`,
+`data.archive.retainedResources` and `data.archive.cleanupEvents`;
+`task context` also retains the original records/events. A successful archive
+exit means `archived=true`, not that cleanup fully succeeded. `cleanupFinished`
+means the foreground pass finished, not that every resource was removed.
 If cleanup was interrupted, the Task stays archived. Repeating archive only
 reports current facts; use explicit, exact-owner resource operations after
 inspection instead of re-running broad cleanup. No background retry is implied.

package/skills/yui-runtime/references/recovery.md

@@ -12,6 +12,77 @@ affected WorkItem, ReviewRound or Integration. Use `task next-action` and
 `execution audit` as decision support, not as an automatic plan.
 Active or quiet observations are not a Task-wide lock or proof of failure.
 
+### Configuration and model-name failures
+
+The already-running caller handles a failed launch: Worker/Reviewer failures
+go to their Leader, and an unavailable Leader's failure goes to the existing
+Operator channel. A target that did not start cannot repair itself. Read the
+referenced error once; do not create a recovery Agent, a polling loop or a new
+Task merely to handle it.
+
+Use the error's capability-query pointer to inspect native metadata with the
+recorded failed configuration:
+
+```sh
+yui task event show <task> <error-event>
+yui task role capabilities <task> <role> --error <error-event> --refresh
+```
+
+The query uses the Controller's Provider environment, not your own Agent's
+possibly different account variables, and requires that Controller to be running.
+It preserves the requested model, workspace, profile/settings selection and
+configured Agent identity. Native settings files and credentials are still read
+currently, not copied into error history. A historical error without a recorded
+configuration, or a changed Agent command/bindings, returns a diagnosis instead
+of borrowing today's Role configuration. To inspect the desired next launch
+explicitly, omit `--error`. Distinguish live, cached and unavailable metadata.
+Do not treat an alias list as a complete Provider whitelist.
+
+Reconcile the original user requirement with exact native IDs and alias
+mappings. Correcting the name of the same authorized model is routine recovery;
+selecting another model, account, permission or cost boundary is not. If there
+is no proven equivalent, preserve the failure and report the missing choice.
+Do not guess names, select a similarly named variant, or silently fall back.
+
+After correcting only the intended configuration, choose the existing operation
+that matches current facts. A rejected notification retains its input:
+
+```sh
+yui task wake show <task> <wake>
+yui task wake retry <task> <wake> --reason "<correction and evidence>"
+```
+
+Retry does not replace a Session or change its immutable effective configuration.
+If an existing Session must adopt changed settings, use the deliberate Session
+replacement operation below; an assigned Run uses its own legal retry operation.
+Accepted or uncertain input cannot be replayed through notification retry.
+Configuration failure is not transient infrastructure recovery, and unchanged
+configuration does not justify another attempt.
+
+### Bounded infrastructure retry
+
+The Controller, not the Agent, counts and schedules qualifying transient
+Provider retries: at most five automatic executions after the initial failure,
+within one ten-minute recovery window. Native acceptance, activity and partial
+output do not reset that count. Unknown delivery remains fenced for exact
+readback; it is never replayed.
+
+Inspect the current projection in Context, or use
+`task role session retry <task> <role> show`; Global Sessions use
+`session retry <role> show`. While `waiting` or `in-flight`, do not dispatch a
+duplicate. A readable failed Run remains immutable evidence while its recovery
+successor handles the same responsibility and frozen Review boundary.
+
+`cancel` withdraws pending automatic recovery; `disable` additionally disables
+future automatic chains on that Provider binding. Neither stops an admitted
+native Turn. `enable` permits future failures to qualify, without replaying
+old failures. These controls require the existing user/supervisor authority.
+
+`exhausted`, `cancelled` and `needs-attention` preserve the error, input and
+work. Read their exact reason, then choose an authorized next action. Unsupported
+Hosts/Adapters or unprovable Session/background state do not trigger automatic
+replacement, cleanup, model switching or a new grant.
+
 A failed AgentRun is immutable; retry creates a new attempt. Reuse a recoverable
 Session when useful and load the new attempt's current context, not an old
 Assignment from memory. A new Host process need not mean a new native Session.

package/dist/agent/agentRegistry.js

@@ -1,10 +0,0 @@
-import { configuredAgentToDefinition } from "./agent.js";
-export function resolveAgent(id, agents = []) {
-    return listAgentDefinitions(agents).find((agent) => agent.id === id) ?? null;
-}
-export function listAgentDefinitions(agents = []) {
-    return agents.map(configuredAgentToDefinition);
-}
-export function supportedAgentIds(agents = []) {
-    return listAgentDefinitions(agents).map((agent) => agent.id);
-}

package/dist/agentRun/runIdentity.js

@@ -1,22 +0,0 @@
-import { MAX_SESSION_TITLE_LENGTH } from "../runtime/sessionTitle.js";
-/**
- * Prefixes managed launch input with its session title. The bootstrap body
- * exposes the exact current AgentRun identity to the Agent, while structured
- * delivery metadata and control hooks retain the delivery fence.
- */
-export function prefixYuiTitleInput(input, title) {
-    const text = input.replace(/\r/g, "").trim();
-    if (text.length === 0)
-        throw new Error("Managed input body is required.");
-    return `${requireRunTitle(title)}\n\n${text}`;
-}
-function requireRunTitle(value) {
-    const title = value.trim();
-    if (title.length === 0
-        || title.length > MAX_SESSION_TITLE_LENGTH
-        || /[\r\n\0]/u.test(title)
-        || !title.startsWith("Yui ")) {
-        throw new Error("AgentRun title is invalid.");
-    }
-    return title;
-}

package/dist/commands/deliveryGuardPreflight.js

@@ -1,30 +0,0 @@
-import { resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns } from "../config/yuiConfig.js";
-import { usageError } from "../errors/cliError.js";
-import { detectDeliveryDuplicates, evaluateDeliveryGuard, evaluateSemanticBudget, formatDeliveryDuplicate } from "../task/deliveryGuard.js";
-export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
-    const mode = resolveLeaderNextActionMode(store.getConfig().leaderNextActionMode);
-    if (mode === "display")
-        return { warnings: [] };
-    const facts = store.readNextActionFacts(taskId);
-    if (facts === null)
-        return { warnings: [] };
-    const outcome = evaluateDeliveryGuard(detectDeliveryDuplicates(facts, intent), mode);
-    const warnings = outcome.warnings.map(formatDeliveryDuplicate);
-    if (outcome.blocked !== null) {
-        throw usageError(`${formatDeliveryDuplicate(outcome.blocked)} `
-            + "Reuse the existing proof, or set leader.nextActionMode=warn to proceed with a warning.");
-    }
-    if (options.budget === true) {
-        const budget = evaluateSemanticBudget(facts, resolveLeaderSemanticBudgetRuns(store.getConfig().leaderSemanticBudgetRuns));
-        if (budget.exhausted) {
-            warnings.push(`Semantic progress budget: ${budget.reason}`);
-        }
-    }
-    return { warnings };
-}
-/** Prepend guard warnings to a command's normal output. */
-export function withGuardWarnings(preflight, output) {
-    if (preflight.warnings.length === 0)
-        return output;
-    return `${preflight.warnings.map((warning) => `Warning: ${warning}\n`).join("")}${output}`;
-}

package/dist/commands/taskIntegrationQueueCommands.js

@@ -1,226 +0,0 @@
-import { usageError } from "../errors/cliError.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { resolveProject } from "../repository/project.js";
-import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
-import { assertTaskDeliveryAuthority as taskLocalActor } from "./taskActor.js";
-import { parseRepeatable } from "./taskIntegrationCommands.js";
-import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-/**
- * `yui task integration queue` — the serialized merge queue.  Only terminal
- * Candidates explicitly enqueued enter the queue; the queue never blocks
- * parallel development, it orders exact-commit integration.
- */
-export async function runTaskIntegrationQueueCommand(args, store, home, options = {}) {
-    const [command, ...rest] = args;
-    if (command === "enqueue")
-        return enqueue(rest, store, options, home);
-    if (command === "list")
-        return list(rest, store);
-    if (command === "show")
-        return show(rest, store, options.environment);
-    if (command === "process")
-        return process(rest, store, home, options);
-    if (command === "supersede")
-        return supersede(rest, store, options, home);
-    if (command === "requeue")
-        return requeue(rest, store, options, home);
-    if (command === "reconcile")
-        return reconcile(rest, store, options, home);
-    throw usageError(command === undefined
-        ? "Task Integration queue command is required."
-        : `Unknown command: task integration queue ${command}`);
-}
-async function enqueue(args, store, options, home) {
-    const usage = "Task Integration queue enqueue usage: yui task integration queue enqueue <task> --project <project> --change-set <id> [--target <ref>] [--check <command> ...].";
-    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--project", "--change-set", "--target"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    requireTaskControlActor(store, options.environment, task.id, home);
-    const projectRef = parsed.one.get("--project");
-    const changeSetId = parsed.one.get("--change-set");
-    if (projectRef === undefined || changeSetId === undefined)
-        throw usageError(usage);
-    const projectId = resolveProjectId(store, projectRef);
-    const result = await enqueueIntegrationQueueEntry({
-        store,
-        taskId: task.id,
-        projectId,
-        changeSetId,
-        targetRef: parsed.one.get("--target"),
-        checkCommands: parsed.many.get("--check") ?? [],
-        now: options.now
-    });
-    const label = {
-        queued: "Enqueued",
-        "already-queued": "Already queued",
-        "already-committed": "Already committed",
-        converged: "Converged"
-    }[result.outcome];
-    return {
-        output: `${label} ${result.entry.changeSetId} as ${result.entry.id} (${result.entry.status})\n`,
-        data: result
-    };
-}
-function list(args, store) {
-    const usage = "Task Integration queue list usage: yui task integration queue list <task> [--project <project>].";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--project"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    const projectRef = parsed.one.get("--project");
-    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
-    // The store already returns entries in numeric id order; trust it instead of
-    // re-sorting with a lexicographic compare (which yields 1, 10, 2, ...).
-    const entries = store.listIntegrationQueueEntries(task.id)
-        .filter((entry) => projectId === undefined || entry.projectId === projectId);
-    const output = entries.length === 0
-        ? "Integration queue is empty.\n"
-        : `${renderTable(`Integration queue: ${task.id}`, [
-            { header: "Entry", minWidth: 12, maxWidth: 24 },
-            { header: "Project", minWidth: 8, maxWidth: 20 },
-            { header: "ChangeSet", minWidth: 10, maxWidth: 20 },
-            { header: "Target", minWidth: 8, maxWidth: 30 },
-            { header: "Status", minWidth: 8, maxWidth: 16 }
-        ], entries.map((entry) => [
-            entry.id,
-            entry.projectId,
-            entry.changeSetId,
-            entry.targetRef,
-            entry.status
-        ]), defaultTableWidth())}\n`;
-    return { output, data: { entries } };
-}
-function show(args, store, environment) {
-    const usage = "Task Integration queue show usage: yui task integration queue show <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], environment);
-    const lines = [
-        `Integration queue entry: ${entry.id}`,
-        `Task: ${entry.taskId}`,
-        `Project: ${entry.projectId}`,
-        `ChangeSet: ${entry.changeSetId}`,
-        `Target: ${entry.targetRef}`,
-        `Status: ${entry.status}`,
-        `Target before: ${entry.targetBefore ?? "-"}`,
-        `Target after: ${entry.targetAfter ?? "-"}`,
-        `Integration: ${entry.integrationAttemptId ?? "-"}`,
-        `Affected paths: ${entry.affectedPaths === undefined ? "-" : entry.affectedPaths.join(", ")}`,
-        `Evidence: ${entry.evidenceRefs.length === 0 ? "-" : entry.evidenceRefs.join(", ")}`,
-        `Conflict: ${entry.conflictSummary ?? "-"}`,
-        `Superseded: ${entry.supersedeReason ?? "-"}`
-    ];
-    return { output: `${lines.join("\n")}\n`, data: { entry } };
-}
-async function process(args, store, home, options) {
-    const usage = "Task Integration queue process usage: yui task integration queue process <task> [--project <project>] [--limit <n>].";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--project", "--limit"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    requireTaskControlActor(store, options.environment, task.id, home);
-    const limitValue = parsed.one.get("--limit");
-    const limit = limitValue === undefined ? undefined : Number.parseInt(limitValue, 10);
-    if (limitValue !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
-        throw usageError(`--limit must be a positive integer: ${limitValue}.`);
-    }
-    const projectRef = parsed.one.get("--project");
-    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
-    const processed = await processIntegrationQueue(store, home, task.id, {
-        projectId,
-        limit,
-        now: options.now,
-        environment: options.environment
-    });
-    const lines = processed.map(({ entry, result }) => {
-        if (result.status === "committed") {
-            return `${entry.id} committed ${entry.changeSetId} -> ${entry.targetAfter ?? "-"}`;
-        }
-        if (result.status === "blocked" || result.status === "conflicted") {
-            return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "blocked"}`;
-        }
-        return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "gate failure"}`;
-    });
-    const output = processed.length === 0
-        ? "Integration queue: nothing to process.\n"
-        : `${lines.join("\n")}\n`;
-    return { output, data: { processed } };
-}
-function supersede(args, store, options, home) {
-    const usage = "Task Integration queue supersede usage: yui task integration queue supersede <task>/<entry> --reason <text>.";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
-    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const reason = parsed.one.get("--reason");
-    if (reason === undefined)
-        throw usageError(usage);
-    const superseded = supersedeIntegrationQueueEntry(store, entry.taskId, entry.id, reason, actor, options.now ?? (() => new Date()));
-    return {
-        output: `Superseded ${superseded.id}: ${reason}\n`,
-        data: { entry: superseded }
-    };
-}
-function requeue(args, store, options, home) {
-    const usage = "Task Integration queue requeue usage: yui task integration queue requeue <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], options.environment);
-    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, actor, options.now ?? (() => new Date()));
-    return {
-        output: `Requeued ${waiting.id}; it will be processed again on the next queue run\n`,
-        data: { entry: waiting }
-    };
-}
-async function reconcile(args, store, options, home) {
-    const usage = "Task Integration queue reconcile usage: yui task integration queue reconcile <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], options.environment);
-    requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const committed = await reconcileIntegrationQueueEntry(store, entry.taskId, entry.id, new NodeGitWorkspace(), options.now ?? (() => new Date()));
-    return {
-        output: `Reconciled ${committed.id} as committed -> ${committed.targetAfter ?? "-"}\n`,
-        data: { entry: committed }
-    };
-}
-function requireActiveTask(store, taskId) {
-    const task = store.getTask(taskId);
-    if (task === null)
-        throw usageError(`Task not found: ${taskId}.`);
-    if (task.status !== "active") {
-        throw usageError(`Task is not active: ${task.id}/${task.status}.`);
-    }
-    return task;
-}
-function resolveProjectId(store, reference) {
-    const project = resolveProject(store.listProjects(), reference);
-    if (project === null)
-        throw usageError(`Project not found: ${reference}.`);
-    return project.id;
-}
-function requireQueueEntry(store, value, environment) {
-    let reference;
-    try {
-        reference = resolveTaskRecordReference(value, {
-            kind: "integrationQueue",
-            contextTaskId: environment?.YUI_TASK_ID,
-            label: "Integration queue entry"
-        });
-    }
-    catch (error) {
-        throw usageError(error instanceof Error ? error.message : String(error));
-    }
-    const entry = store.getIntegrationQueueEntry(reference.taskId, reference.localId);
-    if (entry === null) {
-        throw usageError(`Integration queue entry not found: ${reference.taskId}/${reference.localId}.`);
-    }
-    return entry;
-}
-function requireTaskControlActor(store, environment, taskId, home) {
-    return taskLocalActor(store, environment, taskId);
-}