@zq-silk/yui 0.8.2 → 0.8.6

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
@@ -36,8 +36,9 @@ import { runResourcesCommand } from "./commands/resourcesCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
 import { runProfileCommand } from "./commands/profileCommands.js";
-import { dispatchPreparedReviewRound, failPendingReviewRound, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, validateTaskArchiveRequest } from "./commands/taskCommands.js";
+import { dispatchPreparedReviewRound, failPendingReviewRound, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, parseTaskFinalReviewContractRebindRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, validateTaskArchiveRequest } from "./commands/taskCommands.js";
 import { taskActor } from "./commands/taskActor.js";
+import { isCurrentGlobalOperator } from "./commands/taskInputCommands.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
 import { runTaskChangeSetCommand } from "./commands/taskChangeSetCommands.js";
 import { runTaskOverlapCommand } from "./commands/taskOverlapCommands.js";
@@ -46,9 +47,9 @@ import { runTaskWorkspaceCommand } from "./commands/taskWorkspaceCommands.js";
 import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { createUpdatePorts } from "./cli/updatePorts.js";
 import { createReleaseWorkflowPorts } from "./release/releaseWorkflowPorts.js";
-import { readRuntimeIdentity } from "./release/runtimeRelease.js";
+import { acquireHandoverLock, readRuntimeIdentity } from "./release/runtimeRelease.js";
 import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
-import { reconcileTaskRemoteBaselines } from "./commands/taskCompletionGate.js";
+import { reconcileTaskRemoteBaselines, verifyTaskCompletionPublishedTree } from "./commands/taskCompletionGate.js";
 import { runTaskBaseStatusCommand } from "./commands/taskBaseCommands.js";
 import { assertTaskBaseFreshnessForCompletion, inspectTaskBaseFreshness } from "./repository/taskBaseFreshness.js";
 import { FileCompletionManager, resolveCliIdentity } from "./completion/fileCompletionManager.js";
@@ -81,8 +82,10 @@ import { TmuxWebTerminalService } from "./web/tmuxWebTerminal.js";
 import { listOperatorSessions, operatorSessionRef } from "./operator/operatorSessionHistory.js";
 import { YUI_VERSION, yuiVersionIdentity } from "./version.js";
 import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactControlPlanePreflight, assertExactTaskRuntimeEnvironment, assertExactTaskRuntimeState, exactControlPlaneDigest, extractExactControlArgument, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
+import { readSessionBootstrapManifest } from "./context/sessionBootstrapManifest.js";
 import { builtinAgentDriverRegistry } from "./runtime/builtinAgentDrivers.js";
 import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./review/taskFinalReviewContract.js";
+import { prepareTaskFinalReviewContractRebindProof, resolveRecordedTaskFinalReviewContract } from "./review/taskFinalReviewContractRebind.js";
 import { assessDeltaRecheck } from "./review/deltaRecheck.js";
 import { deltaRecheckEnabled } from "./review/reviewConfig.js";
 import { NodeGitWorkspace } from "./repository/gitWorkspace.js";
@@ -109,7 +112,7 @@ void main().catch((error) => {
     process.exitCode = 5;
 });
 export async function main() {
-    const { contract: taskFinalReviewContract, verifiedStore } = await preflightManagedTaskControlPlane();
+    const { contract: taskFinalReviewContract, verifiedStore, controlPlane: exactCurrentControlPlane } = await preflightManagedTaskControlPlane();
     if (args.length === 0) {
         emit(renderCommandHelp((await import("./cli/commandCatalog.js")).ROOT_COMMAND, VERSION));
         return;
@@ -944,6 +947,7 @@ export async function main() {
             }
         }
         let completionSummary;
+        let completionPublishedTreeProof;
         if (resolved[1] === "base" && resolved[2] === "status") {
             const result = await runTaskBaseStatusCommand(resolved.slice(3), store);
             emit(result.output, false, result.data);
@@ -958,12 +962,26 @@ export async function main() {
                 ...(taskFinalReviewContract === undefined
                     ? {}
                     : { taskFinalReviewContract })
-            });
+            }, completionRequest);
             if (!completion.completed && !completion.activeTaskReview) {
-                const freshness = await inspectTaskBaseFreshness(resolved[2], store, {
-                    refresh: refreshRemote
-                });
-                for (const warning of assertTaskBaseFreshnessForCompletion(freshness)) {
+                // An explicit refresh must fetch the remote object graph before the
+                // Publication proof resolves its exact commit. Without the flag the
+                // command remains offline and preserves the existing proof-first path.
+                const refreshedFreshness = refreshRemote
+                    ? await inspectTaskBaseFreshness(resolved[2], store, { refresh: true })
+                    : undefined;
+                if (completionRequest.acceptedPublishedTreePublicationId !== undefined) {
+                    completionPublishedTreeProof = await verifyTaskCompletionPublishedTree(completionRequest.taskId, completionRequest.acceptedPublishedTreePublicationId, store);
+                }
+                const freshness = refreshedFreshness
+                    ?? await inspectTaskBaseFreshness(resolved[2], store);
+                for (const warning of assertTaskBaseFreshnessForCompletion(freshness, {
+                    ...(completionPublishedTreeProof === undefined
+                        ? {}
+                        : {
+                            acceptedPublishedTreeProjectId: completionPublishedTreeProof.projectId
+                        })
+                })) {
                     process.stderr.write(`Warning: ${warning}\n`);
                 }
                 // Keep completion offline by default. An explicit refresh is the only
@@ -973,6 +991,59 @@ export async function main() {
                 }
             }
         }
+        let taskFinalReviewRebindProof;
+        let taskFinalReviewRebindRequest;
+        let releaseTaskFinalReviewHandoverLock;
+        if (resolved[1] === "review" && resolved[2] === "rebind") {
+            if (!isCurrentGlobalOperator(store, process.env)) {
+                throw usageError("Task-final Review contract rebind requires the authenticated global Operator session.");
+            }
+            if (exactCurrentControlPlane === undefined) {
+                throw usageError("Task-final Review contract rebind requires the exact current global Session CLI.");
+            }
+            taskFinalReviewRebindRequest = parseTaskFinalReviewContractRebindRequest(resolved.slice(3));
+        }
+        if ((resolved[1] === "review"
+            && ["request", "force-fresh", "retry", "rebind"].includes(resolved[2] ?? ""))
+            || resolved[1] === "complete") {
+            const handoverLock = acquireHandoverLock(home);
+            releaseTaskFinalReviewHandoverLock = handoverLock.release;
+        }
+        if (taskFinalReviewRebindRequest !== undefined) {
+            const request = taskFinalReviewRebindRequest;
+            try {
+                taskFinalReviewRebindProof = prepareTaskFinalReviewContractRebindProof({
+                    home,
+                    taskId: request.taskId,
+                    fromControlPlaneDigest: request.fromControlPlaneDigest,
+                    toControlPlaneDigest: request.toControlPlaneDigest,
+                    fromReleaseId: request.fromReleaseId,
+                    toReleaseId: request.toReleaseId,
+                    currentControlPlane: exactCurrentControlPlane.descriptor
+                });
+                const workItems = store.listWorkItems(request.taskId);
+                const reviewRounds = store.listReviewRounds(request.taskId);
+                const resolution = resolveRecordedTaskFinalReviewContract(request.taskId, workItems, reviewRounds, store.listEvents(request.taskId));
+                const activeRound = reviewRounds.find((round) => ((round.scope ?? "work-item") === "task"
+                    && (round.status === "pending" || round.status === "running")));
+                // An exact replay is a true no-op, even when the target Leader is live.
+                // Invalid/stale source tuples also reach the command unchanged so its
+                // transactional diagnosis cannot stop a healthy target runtime.
+                if (resolution?.effective.controlPlaneDigest === request.fromControlPlaneDigest
+                    && activeRound === undefined) {
+                    // The contract event and wake must never target a Provider
+                    // Conversation launched by the source release. Active Runs fail
+                    // closed; otherwise stop and retire that runtime under the handover
+                    // lock before the transactional event+wake commit.
+                    await workspaceCoordinator.cleanupTaskRoleRuntime(request.taskId, "leader");
+                }
+            }
+            catch (error) {
+                releaseTaskFinalReviewHandoverLock();
+                releaseTaskFinalReviewHandoverLock = undefined;
+                throw error;
+            }
+        }
         let candidateMaterialization;
         let candidateMaterializationCommitted = false;
         try {
@@ -987,7 +1058,7 @@ export async function main() {
                 ? await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract)
                 : candidateMaterialization.snapshot;
             const directTaskMainSnapshot = await directTaskMainSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
-            const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
+            const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env);
             const deltaRecheckPreflight = await deltaRecheckPreflightForTaskCommand(resolved.slice(1), store, actualTaskReviewCandidate);
             const reviewWorkspaceResult = await reviewWorkspaceResultForTaskCommand(resolved, store, workspacePreparer, process.env);
             const executionLaneGitSnapshot = await executionLaneGitSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env);
@@ -1001,7 +1072,13 @@ export async function main() {
                 ...(taskFinalReviewContract === undefined
                     ? {}
                     : { taskFinalReviewContract }),
+                ...(taskFinalReviewRebindProof === undefined
+                    ? {}
+                    : { taskFinalReviewRebindProof }),
                 ...(completionSummary === undefined ? {} : { completionSummary }),
+                ...(completionPublishedTreeProof === undefined
+                    ? {}
+                    : { completionPublishedTreeProof }),
                 ...(workItemIntegrationProof === undefined ? {} : { workItemIntegrationProof }),
                 ...(candidateGitSnapshot === undefined ? {} : { candidateGitSnapshot }),
                 ...(candidateMaterialization === undefined
@@ -1242,6 +1319,12 @@ export async function main() {
             }
             throw error;
         }
+        finally {
+            if (releaseTaskFinalReviewHandoverLock !== undefined) {
+                releaseTaskFinalReviewHandoverLock();
+                releaseTaskFinalReviewHandoverLock = undefined;
+            }
+        }
     }
     if (resolved[0] === "jobs") {
         emit(runJobCommand(resolved.slice(1), store, { runtime }));
@@ -1282,12 +1365,12 @@ async function preflightManagedTaskControlPlane() {
     }
     if (!exactRuntime) {
         if (exactControlInvocation.digest !== undefined) {
-            throw new Error("Exact Task control-plane invocation requires its frozen runtime descriptors.");
+            return await preflightManagedGlobalControlPlane(exactControlInvocation.digest);
         }
         if (taskFinalReviewInvocation.request !== undefined) {
             throw new Error("Task final-review contract requires a verified exact Task control-plane invocation.");
         }
-        return { contract: undefined, verifiedStore: undefined };
+        return { contract: undefined, controlPlane: undefined, verifiedStore: undefined };
     }
     if (process.env.YUI_SESSION_SCOPE !== "task") {
         throw new Error("Exact Task control-plane invocation requires a managed Task runtime.");
@@ -1331,8 +1414,13 @@ async function preflightManagedTaskControlPlane() {
         }
         : {});
     const request = taskFinalReviewInvocation.request;
-    if (request === undefined)
-        return { contract: undefined, verifiedStore };
+    if (request === undefined) {
+        return {
+            contract: undefined,
+            controlPlane: { digest, descriptor: control },
+            verifiedStore
+        };
+    }
     if (runtime.roleName !== "leader") {
         throw new Error("Only the exact Task Leader invocation may establish a final-review contract.");
     }
@@ -1345,9 +1433,50 @@ async function preflightManagedTaskControlPlane() {
             reviewerRoleName: request.reviewerRoleName,
             controlPlaneDigest: digest
         }),
+        controlPlane: { digest, descriptor: control },
         verifiedStore
     };
 }
+async function preflightManagedGlobalControlPlane(digest) {
+    if (process.env.YUI_SESSION_SCOPE !== "global") {
+        throw new Error("Exact Task control-plane invocation requires its frozen runtime descriptors.");
+    }
+    if (taskFinalReviewInvocation.request !== undefined) {
+        throw new Error("Task final-review contract establishment requires a verified exact Task control-plane invocation.");
+    }
+    const manifestPath = process.env.YUI_SESSION_MANIFEST;
+    const sessionCliPath = process.env.YUI_SESSION_CLI;
+    if (manifestPath === undefined || sessionCliPath === undefined) {
+        throw new Error("Exact global control-plane invocation requires its Session Manifest and CLI.");
+    }
+    const manifest = readSessionBootstrapManifest(manifestPath);
+    const expectedRoleKind = process.env.YUI_ROLE === "operator" ? "operator" : "global";
+    if (manifest.owner.scope !== "global"
+        || manifest.roleKind !== expectedRoleKind
+        || resolve(manifest.controlPlane.sessionCliPath) !== resolve(sessionCliPath)
+        || manifest.controlPlane.digest !== digest) {
+        throw new Error("Exact global control-plane invocation does not match its Session Manifest.");
+    }
+    const serializedDescriptor = readFileSync(manifest.controlPlane.descriptorPath, "utf8");
+    const descriptor = parseExactControlPlaneDescriptor(serializedDescriptor);
+    if (exactControlPlaneDigest(descriptor) !== digest
+        || resolve(manifest.controlPlane.descriptorPath) !== resolve(join(descriptor.yuiHome, "runtime", "control-plane", `${digest}.json`))
+        || resolve(manifestPath) !== resolve(join(descriptor.yuiHome, "runtime", "session-manifests", `${manifest.digest}.json`))) {
+        throw new Error("Exact global Session Manifest does not match its control-plane descriptor.");
+    }
+    await assertExactControlPlanePreflight({
+        serializedDescriptor,
+        digest,
+        actualExecutable: process.execPath,
+        actualCliEntry: fileURLToPath(import.meta.url),
+        actualHome: resolveYuiHome(process.env)
+    });
+    return {
+        contract: undefined,
+        controlPlane: { digest, descriptor },
+        verifiedStore: openCompatibleFileTaskStore(descriptor.yuiHome)
+    };
+}
 function cleanupCliError(error, fallbackResource) {
     if (error instanceof WorkspaceCleanupBlockedError) {
         return usageError(error.message, undefined, cleanupBlockedDetails(error.reason, error.resource, error.retryable));
@@ -1612,6 +1741,36 @@ async function prepareReviewLaneWorkspaces(taskId, reviewRoundId, store, prepare
     return map;
 }
 async function directTaskMainSnapshotForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
+    const deliveryOption = args.indexOf("--delivery", 3);
+    const deliveryPromotion = args[0] === "task"
+        && args[1] === "update"
+        && args[2] !== undefined
+        && (args.includes("--require-integration", 3)
+            || (deliveryOption >= 0 && args[deliveryOption + 1] === "integrated"));
+    if (deliveryPromotion) {
+        const task = store.getTask(args[2]);
+        if (task === null
+            || (task.status !== "active" && task.status !== "draft")
+            || task.requireIntegration === true
+            || task.projectBindings.length === 0) {
+            return undefined;
+        }
+        const workspace = store.getTaskWorkspace(task.id);
+        if (task.status === "draft" && workspace === null)
+            return undefined;
+        if (workspace === null
+            || workspace.owner.type !== "task"
+            || workspace.owner.taskId !== task.id) {
+            throw usageError(`Task has no authoritative main workspace: ${task.id}.`);
+        }
+        try {
+            return await preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(({ projectId }) => projectId));
+        }
+        catch (error) {
+            throw usageError(`Delivery promotion Task-main verification failed for ${task.id}: `
+                + `${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     if (taskFinalReviewContract === undefined
         || args[0] !== "task"
         || args[1] !== "work"
@@ -1642,7 +1801,7 @@ async function directTaskMainSnapshotForTaskCommand(args, store, preparer, envir
         throw usageError(error instanceof Error ? error.message : String(error));
     }
 }
-async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
+async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, environment) {
     if (args[0] !== "task")
         return undefined;
     let taskId;
@@ -1651,12 +1810,9 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
         if (task === null || task.status !== "active" || task.projectBindings.length === 0) {
             return undefined;
         }
-        const establishedFinalRound = store.listReviewRounds(task.id).some((round) => ((round.scope ?? "work-item") === "task"));
-        if (taskFinalReviewContract === undefined
-            && store.getReviewConfig()?.trigger !== "final"
-            && !establishedFinalRound) {
-            return undefined;
-        }
+        // Every Project-backed completion, including direct delivery, must freeze
+        // a clean committed Task-main snapshot. Review policy only decides whether
+        // that head also needs an independent ReviewRound.
         taskId = task.id;
     }
     else if (args[1] === "review"
@@ -1673,6 +1829,15 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
             taskId = reference.taskId;
         }
     }
+    else if (args[1] === "review"
+        && args[2] === "force-fresh"
+        && args[3] !== undefined) {
+        const reference = cliTaskRecordReference(args[3], "reviewRound", environment);
+        const round = store.getReviewRound(reference.taskId, reference.localId);
+        if (round !== null && (round.scope ?? "work-item") === "task") {
+            taskId = reference.taskId;
+        }
+    }
     else if (args[1] === "work"
         && args[2] === "review"
         && args[3] === "retry"

package/dist/commands/executionAuditCommands.js

@@ -213,6 +213,36 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("workItems", report));
     }
+    if (report.orchestration.status === "ok" && report.orchestration.data !== undefined) {
+        const orchestration = report.orchestration.data;
+        lines.push("", `Orchestration: ${orchestration.tasks.length} Task(s) · ${orchestration.advisoryCount} advisory finding(s)`);
+        if (orchestration.tasks.length > 0) {
+            lines.push(renderTable("Task orchestration metrics", [
+                { header: "Task", minWidth: 7, maxWidth: 14 },
+                { header: "Delivery", minWidth: 8, maxWidth: 10 },
+                { header: "Runs", minWidth: 4, maxWidth: 6 },
+                { header: "WIs", minWidth: 3, maxWidth: 5 },
+                { header: "Review F/D/N", minWidth: 12, maxWidth: 16 },
+                { header: "Integration A/F/R", minWidth: 17, maxWidth: 20 },
+                { header: "Pre-progress gen", minWidth: 12, maxWidth: 16 },
+                { header: "Terminal ws", minWidth: 10, maxWidth: 12 },
+                { header: "Advice", minWidth: 6, maxWidth: 8 }
+            ], orchestration.tasks.map((task) => [
+                task.taskId,
+                task.deliveryPath,
+                String(task.runs.total),
+                String(task.workItems),
+                `${task.reviews.full}/${task.reviews.delta}/${task.reviews.nonSemantic}`,
+                `${task.integrations.attempts}/${task.integrations.failed}/${task.integrations.repeatedIdentities}`,
+                String(task.providerGenerationsBeforeFirstProgress),
+                String(task.terminalWorkspaceCount),
+                String(task.advisories.length)
+            ]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("orchestration", report));
+    }
     if (report.storage.status === "ok" && report.storage.data !== undefined) {
         const storage = report.storage.data;
         lines.push("", `Storage: backend ${storage.backend} · state.json ${formatBytes(storage.stateJsonBytes)} · yui.db ${formatBytes(storage.databaseBytes)}`

package/dist/commands/operatorCommands.js

@@ -1,6 +1,6 @@
 import { usageError } from "../errors/cliError.js";
 import { createRoleSessionSet } from "../executor/agentExecutor.js";
-import { listOperatorSessions, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
+import { listOperatorSessions, projectOperatorStatus, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatRelativeTimestamp } from "../output/timePresentation.js";
 import { updateGlobalRole } from "../role/role.js";
@@ -11,6 +11,7 @@ export function runOperatorCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     switch (command) {
         case "list": return listSessions(rest, store, options);
+        case "status": return status(rest, store, options);
         case "new": return newSession(rest, store);
         case "resume": return resumeSession(rest, store);
         case "submit": return submit(rest, store, options);
@@ -20,6 +21,46 @@ export function runOperatorCommand(args, store, options = {}) {
                 : `Unknown command: operator ${command}`);
     }
 }
+function status(args, store, options) {
+    if (args.length !== 0)
+        throw usageError("Operator status usage: yui operator status.");
+    const role = requireOperator(store);
+    const activeBinding = role.agentBindings[role.activeAgentId];
+    if (activeBinding === undefined) {
+        throw usageError(`Operator active Agent is not bound: ${role.activeAgentId}.`);
+    }
+    const projection = projectOperatorStatus(store.getGlobalRoleSessionSet(role.name), role.activeAgentId, activeBinding.adapterId);
+    const writer = projection.writer;
+    const writerLines = [
+        "Operator status",
+        "Active writer:",
+        `  State: ${writer.state}`,
+        `  Agent: ${writer.agentId}`,
+        `  Adapter: ${adapterLabel(writer.adapterId)}`,
+        `  Conversation: ${writer.sessionRef ?? "-"}`,
+        `  Native session: ${writer.nativeSessionId ?? "-"}`,
+        `  Session state: ${writer.sessionStatus ?? "-"}`
+    ];
+    const history = projection.historicalConversations;
+    const historyOutput = history.length === 0
+        ? "Historical conversations: none"
+        : renderTable("Historical conversations", [
+            { header: "Updated", minWidth: 7, maxWidth: 12 },
+            { header: "Agent", minWidth: 6, maxWidth: 16 },
+            { header: "Conversation", minWidth: 20, maxWidth: 72 },
+            { header: "State", minWidth: 7, maxWidth: 10 }
+        ], history.map((session) => [
+            formatRelativeTimestamp(session.updatedAt, options.now?.() ?? new Date()),
+            adapterLabel(session.adapterId),
+            session.displayTitle,
+            session.state
+        ]), options.width ?? defaultTableWidth());
+    return {
+        kind: "output",
+        output: `${writerLines.join("\n")}\n\n${historyOutput}\n`,
+        data: projection
+    };
+}
 function submit(rest, store, options) {
     const usage = "Operator submit usage: yui operator submit (<body>|--body-file <path|->) [--task <id>].";
     const positionals = [];