@zq-silk/yui 0.6.13 → 0.6.14

package/dist/commands/taskContextCommand.js

@@ -44,6 +44,7 @@ export function runTaskContextCommand(args, store) {
         const reviewRounds = chronological(reader.listReviewRounds(task.id));
         const changeSets = chronological(reader.listChangeSets(task.id));
         const integrations = chronological(reader.listIntegrationAttempts(task.id));
+        const publications = chronological(reader.listPublicationReferences(task.id));
         const nextActionFacts = reader.readNextActionFacts(task.id);
         if (nextActionFacts === null) {
             throw new Error(`Task next-action facts disappeared: ${task.id}.`);
@@ -66,6 +67,7 @@ export function runTaskContextCommand(args, store) {
             reviewRounds,
             changeSets,
             integrations,
+            publications,
             messages: reader.listMessages(task.id),
             openInputRequests: inputRequests.filter((request) => request.status === "open"),
             resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
@@ -73,7 +75,7 @@ export function runTaskContextCommand(args, store) {
             nextAction: projectNextAction(nextActionFacts)
         };
     });
-    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
+    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
@@ -283,6 +285,24 @@ export function runTaskContextCommand(args, store) {
             ? ["  None."]
             : integrations.slice(-RECENT_RECORD_LIMIT).map((integration) => (`  ${integration.id} [${integration.status}/${integration.projectId}] — ${integration.targetRef}; ${integration.changeSetIds.join(", ")}`))),
         "",
+        `Publication references (${publications.length}):`,
+        ...(publications.length === 0
+            ? ["  None."]
+            : publications.slice(-RECENT_RECORD_LIMIT).map((reference) => [
+                `  ${reference.id}: ${reference.provider}/${reference.repository}/${reference.externalId}`,
+                ...(reference.title === undefined ? [] : [`    Title: ${reference.title}`]),
+                ...(reference.sourceBranch === undefined && reference.targetBranch === undefined
+                    ? []
+                    : [`    Branches: ${reference.sourceBranch ?? "unknown"} -> ${reference.targetBranch ?? "unknown"}`]),
+                `    ${reference.state}/${reference.verification}; ${reference.localCommit ?? "unknown"} -> ${reference.remoteCommit ?? "unknown"}`,
+                ...(reference.mergedAt === undefined
+                    ? []
+                    : [`    Merged: ${formatTimestamp(reference.mergedAt, timeZone)}`]),
+                ...(reference.supersedes === undefined
+                    ? []
+                    : [`    Supersedes: ${reference.supersedes}`])
+            ]).flat()),
+        "",
         ...recentSection("messages", messages, (message) => [
             `  ${message.id} [${taskMessageAuthorLabel(message.author)}] ${formatTimestamp(message.createdAt, timeZone)}`,
             `    ${compactText(message.body)}`
@@ -342,7 +362,21 @@ function renderWorkItemReviews(rounds) {
             ? [
                 `      Frozen integrated Task heads: ${latest.taskCandidate?.projects
                     .map(({ projectId, commit }) => `${projectId}@${commit}`).join(", ") ?? "unavailable"}`,
-                `      Task-final contract: ${latest.taskFinalReviewContract?.digest ?? "global policy"}`
+                `      Task-final contract: ${latest.taskFinalReviewContract?.digest ?? "global policy"}`,
+                ...(latest.deltaRecheck === undefined
+                    ? [`      Review mode: full`]
+                    : [
+                        `      Review mode: delta-recheck (rechecks ${latest.deltaRecheck.previousReviewRoundId}@${latest.deltaRecheck.previousBaseCommit.slice(0, 12)})`,
+                        `      Delta: ${latest.deltaRecheck.changedFiles.length} file(s), +${latest.deltaRecheck.addedLines}/-${latest.deltaRecheck.deletedLines}, digest ${latest.deltaRecheck.diffDigest.slice(0, 12)}`,
+                        ...(latest.deltaRecheck.disposition === undefined
+                            ? []
+                            : [
+                                `      Delta disposition: ${latest.deltaRecheck.disposition}`,
+                                ...(latest.deltaRecheck.escalatedToReviewRoundId === undefined
+                                    ? []
+                                    : [`      Escalated to: ${latest.deltaRecheck.escalatedToReviewRoundId}`])
+                            ])
+                    ])
             ]
             : []),
         `      Review workspace: ${latest.workspace === undefined

package/dist/commands/taskNextActionCommand.js

@@ -1,5 +1,6 @@
 import { taskNotFound, usageError } from "../errors/cliError.js";
 import { projectNextAction } from "../task/nextAction.js";
+import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
@@ -8,6 +9,10 @@ import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
  * the judgment that remains owned by the Leader.
  * The command never mutates state; when the action is `route-review-findings`
  * it also prints the minimal repair wave for the failing Review.
+ *
+ * Issue 06: when the recommended action is `complete-task`, the output also
+ * carries the full `completionReadiness` blocker list so the Leader sees every
+ * terminalization precondition before attempting `yui task complete`.
  */
 export function runTaskNextActionCommand(args, store) {
     const usage = "Task next-action usage: yui task next-action <task> [--json].";
@@ -18,12 +23,39 @@ export function runTaskNextActionCommand(args, store) {
     }
     const taskId = positionals[0].trim();
     const data = store.transaction((reader) => {
+        // Issue 06: the lightweight facts drive the action on every call; the
+        // heavier readiness facts (full event fold, workspaces, jobs, ledger) are
+        // loaded only when the action is `complete-task`, keeping the per-turn
+        // read path cheap during execution.
         const facts = reader.readNextActionFacts(taskId);
         if (facts === null)
             throw taskNotFound(taskId);
         const action = projectNextAction(facts);
         const repairWave = repairWaveFor(action, facts);
-        return { action, repairWave };
+        // Issue 12: surface pending Knowledge promotion proposals for the Task's
+        // bound Projects as a non-blocking advisory. The proposals are workflow
+        // state, not completion blockers: an Operator reviews them separately.
+        const knowledgeProposals = facts.task.projectBindings.flatMap((binding) => {
+            const project = reader.getProject(binding.projectId);
+            if (project === null)
+                return [];
+            return project.knowledgeProposals
+                .filter((proposal) => proposal.status === "pending")
+                .map((proposal) => ({
+                projectId: binding.projectId,
+                proposalId: proposal.id,
+                title: proposal.title,
+                sourceTaskId: proposal.source.taskId
+            }));
+        });
+        let completionReadiness = null;
+        if (action.kind === "complete-task") {
+            const readinessFacts = reader.readCompletionReadinessFacts(taskId);
+            if (readinessFacts === null)
+                throw taskNotFound(taskId);
+            completionReadiness = projectCompletionReadiness(readinessFacts);
+        }
+        return { action, repairWave, completionReadiness, knowledgeProposals };
     });
     if (asJson) {
         return {
@@ -34,7 +66,7 @@ export function runTaskNextActionCommand(args, store) {
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.repairWave),
+        output: renderNextAction(data.action, data.repairWave, data.completionReadiness, data.knowledgeProposals),
         data
     };
 }
@@ -52,7 +84,7 @@ function repairWaveFor(action, facts) {
         return null;
     return planRepairWave(round.id, findings);
 }
-function renderNextAction(action, repairWave) {
+function renderNextAction(action, repairWave, completionReadiness, knowledgeProposals) {
     const lines = [
         `Task: ${action.taskId}`,
         `Next action: ${action.kind}`,
@@ -91,10 +123,23 @@ function renderNextAction(action, repairWave) {
                 ...action.conflicts.map((conflict) => `  ${conflict.kind}: ${conflict.id}`)
             ])
     ];
+    if (completionReadiness !== null) {
+        if (completionReadiness.ready) {
+            lines.push("Completion readiness: ready (no blockers)");
+        }
+        else {
+            lines.push(`Completion readiness: ${completionReadiness.blockers.length} blocker(s)`, ...completionReadiness.blockers.map((blocker) => `  ${blocker.code} (${blocker.ref.kind} ${blocker.ref.id}): ${blocker.reason}`
+                + ` — fix: ${blocker.fix}`));
+        }
+    }
     if (repairWave !== null) {
         lines.push(`Repair wave (${repairWave.openFindingCount} open finding(s), ${repairWave.groups.length} group(s)):`, ...repairWave.groups.map((group) => `  ${group.id}: findings ${group.findingIds.join(", ")}`
             + ` — paths ${group.paths.length === 0 ? "none" : group.paths.join(", ")}`
             + ` — ${group.reason}`));
     }
+    if (knowledgeProposals.length > 0) {
+        lines.push(`Knowledge proposals (non-blocking): ${knowledgeProposals.length} pending`, ...knowledgeProposals.map((proposal) => `  ${proposal.projectId}/${proposal.proposalId}: ${proposal.title}`
+            + ` — review: yui project knowledge proposals list ${proposal.projectId}`));
+    }
     return `${lines.join("\n")}\n`;
 }

package/dist/commands/taskPublicationCommands.js

@@ -0,0 +1,319 @@
+import { isDeepStrictEqual } from "node:util";
+import { taskActor } from "./taskActor.js";
+import { dataError, taskNotFound, usageError } from "../errors/cliError.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { formatTimestamp } from "../output/timePresentation.js";
+import { resolveProject } from "../repository/project.js";
+import { createPublicationReference } from "../task/publicationReference.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+const PROVIDERS = new Set(["github", "gitlab"]);
+const EXTERNAL_KINDS = new Set(["pull-request", "merge-request"]);
+const STATES = new Set(["open", "merged", "closed"]);
+export function runPublicationCommand(args, store, options) {
+    const [command, ...rest] = args;
+    switch (command) {
+        case "add": return addPublication(rest, store, options);
+        case "list": return listPublications(rest, store);
+        case "show": return showPublication(rest, store);
+        default:
+            throw usageError(command === undefined
+                ? "Task publication command is required."
+                : `Unknown command: task publication ${command}`);
+    }
+}
+function addPublication(args, store, options) {
+    const usage = "Task publication add usage: yui task publication add <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--supersede <publication-id>] [--merged-at <iso-timestamp>].";
+    const parsed = parseAddArgs(args, usage);
+    const task = requireTask(store, parsed.positionals[0]);
+    const projectReference = requiredOption(parsed.options, "--project");
+    const project = resolveProject(store.listProjects(), projectReference);
+    if (project === null)
+        throw usageError(`Project not found: ${projectReference}.`, usage);
+    if (!task.projectBindings.some((binding) => binding.projectId === project.id)) {
+        throw usageError(`Project is not bound to Task ${task.id}: ${projectReference}.`, usage);
+    }
+    const actor = taskActor(options.environment, task.id);
+    if (actor === "leader") {
+        throw usageError("A managed Task Leader cannot record external publication evidence; "
+            + "use a user or global Operator session.", usage);
+    }
+    const state = enumOption(parsed.options, "--state", STATES, usage) ?? "open";
+    const verification = parseVerification(parsed, usage);
+    const input = {
+        projectId: project.id,
+        provider: enumOption(parsed.options, "--provider", PROVIDERS, usage),
+        repository: requiredOption(parsed.options, "--repository"),
+        externalKind: enumOption(parsed.options, "--kind", EXTERNAL_KINDS, usage),
+        externalId: requiredOption(parsed.options, "--id"),
+        ...(parsed.options.has("--url") ? { externalUrl: requiredOption(parsed.options, "--url") } : {}),
+        ...(parsed.options.has("--title") ? { title: requiredOption(parsed.options, "--title") } : {}),
+        ...(parsed.options.has("--source-branch")
+            ? { sourceBranch: requiredOption(parsed.options, "--source-branch") }
+            : {}),
+        ...(parsed.options.has("--target-branch")
+            ? { targetBranch: requiredOption(parsed.options, "--target-branch") }
+            : {}),
+        ...(parsed.options.has("--local-commit")
+            ? { localCommit: requiredOption(parsed.options, "--local-commit") }
+            : {}),
+        ...(parsed.options.has("--remote-commit")
+            ? { remoteCommit: requiredOption(parsed.options, "--remote-commit") }
+            : {}),
+        state,
+        verification,
+        ...(parsed.options.has("--evidence")
+            ? { evidence: requiredOption(parsed.options, "--evidence") }
+            : {}),
+        ...(parsed.options.has("--supersede")
+            ? { supersedes: requiredOption(parsed.options, "--supersede") }
+            : {}),
+        ...(parsed.options.has("--merged-at")
+            ? { mergedAt: requiredOption(parsed.options, "--merged-at") }
+            : {}),
+        recordedBy: actor,
+        source: "manual"
+    };
+    const externalKey = `${input.provider}/${input.repository}/${input.externalId}`;
+    const now = clock(options);
+    const result = store.transaction((tx) => {
+        const existing = tx.findPublicationReferenceByExternalKey(externalKey);
+        if (existing !== null) {
+            if (existing.taskId !== task.id) {
+                throw dataError(`Publication external identity already belongs to Task ${existing.taskId}: ${externalKey}.`);
+            }
+            const semantic = createPublicationReference(existing.id, task.id, input.supersedes === existing.id
+                ? {
+                    projectId: input.projectId,
+                    provider: input.provider,
+                    repository: input.repository,
+                    externalKind: input.externalKind,
+                    externalId: input.externalId,
+                    ...(input.externalUrl === undefined ? {} : { externalUrl: input.externalUrl }),
+                    ...(input.title === undefined ? {} : { title: input.title }),
+                    ...(input.sourceBranch === undefined ? {} : { sourceBranch: input.sourceBranch }),
+                    ...(input.targetBranch === undefined ? {} : { targetBranch: input.targetBranch }),
+                    ...(input.localCommit === undefined ? {} : { localCommit: input.localCommit }),
+                    ...(input.remoteCommit === undefined ? {} : { remoteCommit: input.remoteCommit }),
+                    state: input.state,
+                    verification: input.verification,
+                    ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
+                    ...(input.mergedAt === undefined ? {} : { mergedAt: input.mergedAt }),
+                    recordedBy: input.recordedBy,
+                    source: input.source
+                }
+                : input, new Date(existing.createdAt));
+            if (isDeepStrictEqual(semantic, existing)) {
+                return { reference: existing, idempotent: true };
+            }
+            if (input.supersedes === undefined || input.supersedes !== existing.id) {
+                throw usageError(`Publication ${externalKey} conflicts with current record ${existing.id}; `
+                    + "use --supersede with that id to append corrected evidence.", usage);
+            }
+        }
+        else if (input.supersedes !== undefined) {
+            throw usageError(`Publication supersede target has a different external identity: ${input.supersedes}.`, usage);
+        }
+        const reference = createPublicationReference(tx.nextPublicationReferenceId(task.id), task.id, input, now);
+        tx.savePublicationReference(task.id, reference);
+        recordTaskEvent(tx, task.id, "publication.recorded", {
+            publicationId: reference.id,
+            provider: reference.provider,
+            repository: reference.repository,
+            externalKind: reference.externalKind,
+            externalId: reference.externalId,
+            state: reference.state,
+            verification: reference.verification
+        }, now);
+        return { reference, idempotent: false };
+    });
+    return output(result.idempotent
+        ? `Publication reference already recorded: ${result.reference.id}.\n`
+        : `Recorded publication ${result.reference.id} (${result.reference.provider}/${result.reference.repository}/${result.reference.externalKind}/${result.reference.externalId}) for ${result.reference.taskId}.\n`, result.reference);
+}
+function listPublications(args, store) {
+    const usage = "Task publication list usage: yui task publication list <task>.";
+    const parsed = parseTail(args, new Set(), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const task = requireTask(store, parsed.positionals[0]);
+    const references = store.listPublicationReferences(task.id);
+    if (references.length === 0) {
+        return output("No publication references found.\n", []);
+    }
+    const rendered = `${renderTable(`Publication references: ${task.id}`, [
+        { header: "ID", minWidth: 12, maxWidth: 22 },
+        { header: "External", minWidth: 16, maxWidth: 40 },
+        { header: "Title", minWidth: 16, maxWidth: 40 },
+        { header: "State", minWidth: 7, maxWidth: 10 },
+        { header: "Verification", minWidth: 11, maxWidth: 14 },
+        { header: "Lineage", minWidth: 18, maxWidth: 58 },
+        { header: "Supersedes", minWidth: 12, maxWidth: 22 }
+    ], references.map((reference) => [
+        reference.id,
+        `${reference.provider}/${reference.repository}/${reference.externalId}`,
+        reference.title ?? "-",
+        reference.state,
+        reference.verification,
+        lineageSummary(reference),
+        reference.supersedes ?? "-"
+    ]), defaultTableWidth())}\n`;
+    return output(rendered, references);
+}
+function showPublication(args, store) {
+    const usage = "Task publication show usage: yui task publication show (<task>/<publication-id> | <task> <publication-id>).";
+    const parsed = parseTail(args, new Set(), usage);
+    if (parsed.positionals.length !== 1 && parsed.positionals.length !== 2) {
+        throw usageError(usage);
+    }
+    const referenceId = parsed.positionals.length === 1
+        ? resolveTaskRecordReference(parsed.positionals[0], {
+            kind: "publicationReference",
+            label: "Publication reference"
+        })
+        : resolveTaskRecordReference(`${parsed.positionals[0]}/${parsed.positionals[1]}`, { kind: "publicationReference", label: "Publication reference" });
+    requireTask(store, referenceId.taskId);
+    const reference = store.getPublicationReference(referenceId.taskId, referenceId.localId);
+    if (reference === null) {
+        throw dataError(`Publication reference not found: ${referenceId.taskId}/${referenceId.localId}.`);
+    }
+    return output(renderPublication(reference, store.getConfig().timeZone), reference);
+}
+function renderPublication(reference, timeZone) {
+    return [
+        `Publication: ${reference.id}`,
+        `Task: ${reference.taskId}`,
+        `Project: ${reference.projectId}`,
+        `External: ${reference.provider}/${reference.repository}/${reference.externalId} (${reference.externalKind})`,
+        ...(reference.externalUrl === undefined ? [] : [`URL: ${reference.externalUrl}`]),
+        ...(reference.title === undefined ? [] : [`Title: ${reference.title}`]),
+        ...(reference.sourceBranch === undefined && reference.targetBranch === undefined
+            ? []
+            : [`Branches: ${reference.sourceBranch ?? "unknown"} -> ${reference.targetBranch ?? "unknown"}`]),
+        `State: ${reference.state}`,
+        `Verification: ${reference.verification}`,
+        `Lineage: ${reference.localCommit ?? "unknown"} -> ${reference.externalId} -> ${reference.remoteCommit ?? "unknown"}`,
+        ...(reference.mergedAt === undefined
+            ? []
+            : [`Merged: ${formatTimestamp(reference.mergedAt, timeZone)}`]),
+        ...(reference.evidence === undefined ? [] : [`Evidence: ${reference.evidence}`]),
+        ...(reference.supersedes === undefined ? [] : [`Supersedes: ${reference.supersedes}`]),
+        `Recorded by: ${reference.recordedBy}`,
+        `Source: ${reference.source}`,
+        `Created: ${formatTimestamp(reference.createdAt, timeZone)}`
+    ].join("\n").concat("\n");
+}
+function lineageSummary(reference) {
+    const local = reference.localCommit ?? "unknown";
+    const remote = reference.remoteCommit ?? "unknown";
+    return `${local.slice(0, 12)} -> ${reference.externalId} -> ${remote.slice(0, 12)}`;
+}
+function parseVerification(parsed, usage) {
+    if (parsed.flags.has("--reported") && parsed.flags.has("--verified")) {
+        throw usageError("--reported and --verified are mutually exclusive.", usage);
+    }
+    return parsed.flags.has("--verified") ? "verified" : "reported";
+}
+function enumOption(options, name, allowed, usage) {
+    if (!options.has(name))
+        return undefined;
+    const value = requiredOption(options, name);
+    if (!allowed.has(value)) {
+        throw usageError(`${name} must be one of: ${[...allowed].join(", ")}.`, usage);
+    }
+    return value;
+}
+function requireTask(store, taskId) {
+    const id = requiredText(taskId, "Task id");
+    const task = store.getTask(id);
+    if (task === null)
+        throw taskNotFound(id);
+    return task;
+}
+function recordTaskEvent(store, taskId, type, payload, now) {
+    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now));
+}
+function requiredOption(options, name) {
+    return requiredText(options.get(name), name);
+}
+function requiredText(value, label) {
+    const normalized = value?.trim();
+    if (normalized === undefined || normalized.length === 0) {
+        throw usageError(`${label} is required.`);
+    }
+    return normalized;
+}
+function clock(options) {
+    return options.now?.() ?? new Date();
+}
+function output(value, data) {
+    return data === undefined
+        ? { kind: "output", output: value }
+        : { kind: "output", output: value, data };
+}
+function exactPositionals(values, count, usage) {
+    if (values.length !== count || values.some((value) => value.trim().length === 0)) {
+        throw usageError(usage);
+    }
+}
+function parseAddArgs(args, usage) {
+    const valueOptions = new Set([
+        "--project", "--provider", "--repository", "--kind", "--id", "--url",
+        "--title", "--source-branch", "--target-branch", "--local-commit",
+        "--remote-commit", "--state", "--evidence", "--supersede", "--merged-at"
+    ]);
+    const flags = new Set(["--reported", "--verified"]);
+    const positionals = [];
+    const options = new Map();
+    const seenFlags = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (flags.has(value)) {
+            if (seenFlags.has(value)) {
+                throw usageError(`Flag may only be specified once: ${value}.`, usage);
+            }
+            seenFlags.add(value);
+            continue;
+        }
+        if (!valueOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (options.has(value)) {
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options, flags: seenFlags };
+}
+function parseTail(args, valueOptions, usage) {
+    const positionals = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!valueOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (options.has(value)) {
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options };
+}