@xfey/tutti 0.1.0

package/dist/run-pipeline/promotion-reconcile.js

@@ -0,0 +1,138 @@
+import { dirname, join } from "node:path";
+import { createNodeNpmCheckPlan, executeCheckPlan } from "../checks/index.js";
+import { applyRunResultToMergeWorkspace, cleanupMergeWorkspace, collectMergeDiff, createMergeCandidateCommit, prepareMergeWorkspace, promoteMergeCandidate, WorkspaceOpsError, } from "../workspace-ops/index.js";
+import { candidateChangedAfterChecks } from "./candidate-diff.js";
+import { checkSkipFields, checkStatus, checksSummary, docsStatusForChangedPaths, failedBeforeChecks, failedFinishedResult, promotionNotPromoted, successfulRunSummary, } from "./result-projections.js";
+function withPromotionReconcileEvent(result, event) {
+    return {
+        ...result,
+        timeline_events: [...(result.timeline_events ?? []), event],
+    };
+}
+function promotionReconcileMeta(changedPaths) {
+    return [`changed paths: ${changedPaths.length}`];
+}
+function failedPromotionReconcileEvent(input) {
+    return {
+        event_kind: "promotion_reconcile",
+        status: "failed",
+        summary: input.summary,
+        meta: promotionReconcileMeta(input.changedPaths),
+    };
+}
+function mergeWorkspaceRootForOptions(options) {
+    return options.mergeWorkspaceRoot ?? join(dirname(options.runWorkspaceRoot), "merge-workspaces");
+}
+export async function runPromotionReconcile(input) {
+    let handle;
+    let changedPaths = input.changedPaths;
+    try {
+        handle = prepareMergeWorkspace({
+            workspaceRoot: input.options.workspaceRoot,
+            mergeWorkspaceRoot: mergeWorkspaceRootForOptions(input.options),
+            taskId: input.pipelineInput.task.id,
+            activityRef: input.pipelineInput.activity_ref,
+            sourceBaseRef: input.runHandle.base_ref,
+            sourceCommit: input.sourceCommit,
+        });
+        applyRunResultToMergeWorkspace(handle);
+        const diff = collectMergeDiff(handle);
+        changedPaths = diff.changed_paths;
+        if (changedPaths.length === 0) {
+            const summary = "Promotion reconcile produced no candidate changes.";
+            return withPromotionReconcileEvent(failedBeforeChecks({
+                summary,
+                errorCode: "promotion_reconcile_no_candidate_changes",
+                retryable: false,
+                changedPaths,
+                promotion: promotionNotPromoted("promotion_reconcile_no_candidate_changes", "No reconciled candidate changes were available for promotion."),
+            }), failedPromotionReconcileEvent({ summary, changedPaths }));
+        }
+        let docs = docsStatusForChangedPaths(changedPaths);
+        const checkPlan = createNodeNpmCheckPlan({ workspaceRoot: handle.repo_root });
+        const checks = await executeCheckPlan({
+            workspaceRoot: handle.repo_root,
+            plan: checkPlan,
+            ...(input.options.checkTimeoutMs === undefined
+                ? {}
+                : { timeoutMs: input.options.checkTimeoutMs }),
+        });
+        if (checks.status === "failed") {
+            const summary = checksSummary(checks);
+            return withPromotionReconcileEvent(failedFinishedResult({
+                summary,
+                checks,
+                docs,
+                changedPaths,
+                promotion: promotionNotPromoted("promotion_reconcile_checks_failed", "Reconciled candidate checks failed, so promotion failed."),
+            }), failedPromotionReconcileEvent({ summary, changedPaths }));
+        }
+        const postChecksDiff = collectMergeDiff(handle);
+        changedPaths = postChecksDiff.changed_paths;
+        docs = docsStatusForChangedPaths(changedPaths);
+        if (candidateChangedAfterChecks(diff, postChecksDiff)) {
+            const summary = "Checks modified the reconciled candidate workspace; promotion failed.";
+            return withPromotionReconcileEvent(failedFinishedResult({
+                summary,
+                checks: {
+                    status: "failed",
+                    commands: checks.commands,
+                },
+                docs,
+                changedPaths,
+                promotion: promotionNotPromoted("promotion_reconcile_checks_modified_candidate", "Checks changed tracked reconciled candidate files, so promotion failed."),
+            }), failedPromotionReconcileEvent({ summary, changedPaths }));
+        }
+        const commit = createMergeCandidateCommit(handle, `Reconcile Tutti task: ${input.pipelineInput.task.title}`);
+        const promotion = promoteMergeCandidate(handle, commit);
+        return withPromotionReconcileEvent({
+            result_kind: "finished",
+            outcome: "completed",
+            summary: successfulRunSummary({
+                implementation: input.taskOutput.summary,
+                checks,
+                completion: "Promotion reconciled and complete.",
+            }),
+            checks: checkStatus(checks),
+            docs,
+            ...checkSkipFields(checks),
+            changed_paths: changedPaths,
+            promotion: {
+                status: "promoted",
+                commit_oid: promotion.promoted_commit_oid,
+                summary: "Promoted reconciled candidate by fast-forward after checks.",
+            },
+        }, {
+            event_kind: "promotion_reconcile",
+            status: "completed",
+            summary: "Promotion reconciled and promoted.",
+            commit_oid: promotion.promoted_commit_oid,
+            meta: promotionReconcileMeta(changedPaths),
+        });
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError) {
+            return withPromotionReconcileEvent(failedBeforeChecks({
+                summary: error.message,
+                errorCode: `workspace_ops_${error.code}`,
+                retryable: error.code === "conflict",
+                changedPaths,
+                promotion: promotionNotPromoted("promotion_reconcile_failed", error.message),
+            }), failedPromotionReconcileEvent({ summary: error.message, changedPaths }));
+        }
+        const summary = error instanceof Error ? error.message : "Promotion reconcile failed";
+        return withPromotionReconcileEvent(failedBeforeChecks({
+            summary,
+            errorCode: "promotion_reconcile_failed",
+            retryable: false,
+            changedPaths,
+            promotion: promotionNotPromoted("promotion_reconcile_failed", summary),
+        }), failedPromotionReconcileEvent({ summary, changedPaths }));
+    }
+    finally {
+        if (handle !== undefined) {
+            cleanupMergeWorkspace(handle);
+        }
+    }
+}
+//# sourceMappingURL=promotion-reconcile.js.map

package/dist/run-pipeline/result-projections.d.ts

@@ -0,0 +1,39 @@
+import type { CheckSkipReasonCode } from "@tutti/shared/schemas/api";
+import type { ChecksExecutionResult } from "../checks/index.js";
+import type { RunPipelineResult } from "../control-plane/index.js";
+import type { TaskRunDocsStatus } from "./task-run-output.js";
+export type RunPromotionProjection = NonNullable<Extract<RunPipelineResult, {
+    result_kind: "finished";
+}>["promotion"]>;
+export declare function checksSummary(checks: ChecksExecutionResult): string;
+export declare function successfulRunSummary(input: {
+    implementation: string;
+    checks: ChecksExecutionResult;
+    completion: string;
+}): string;
+export declare function checkStatus(checks: ChecksExecutionResult): "passed" | "failed" | "skipped";
+export declare function checkSkipFields(checks: ChecksExecutionResult): {
+    skip_reason_code?: CheckSkipReasonCode;
+    skip_reason_summary?: string;
+};
+export declare function docsStatusForChangedPaths(changedPaths: readonly string[]): TaskRunDocsStatus;
+export declare function promotionNotAttempted(reasonCode: string, summary: string): RunPromotionProjection;
+export declare function promotionNotPromoted(reasonCode: string, summary: string): RunPromotionProjection;
+export declare function failedFinishedResult(input: {
+    summary: string;
+    checks: ChecksExecutionResult;
+    docs: TaskRunDocsStatus;
+    changedPaths: string[];
+    promotion: RunPromotionProjection;
+}): RunPipelineResult;
+export declare function failedBeforeChecks(input: {
+    summary: string;
+    errorCode: string;
+    retryable: boolean;
+    changedPaths?: string[];
+    promotion?: RunPromotionProjection;
+}): RunPipelineResult;
+export declare function completedWithoutRepoChanges(input: {
+    summary: string;
+}): RunPipelineResult;
+//# sourceMappingURL=result-projections.d.ts.map

package/dist/run-pipeline/result-projections.js

@@ -0,0 +1,115 @@
+export function checksSummary(checks) {
+    if (checks.status === "skipped") {
+        return `Checks skipped: ${checks.skip_reason_summary}`;
+    }
+    const labels = checks.commands.map((command) => command.label).join(", ");
+    if (checks.status === "passed") {
+        return labels.length === 0 ? "Checks passed." : `Checks passed: ${labels}.`;
+    }
+    const failed = checks.commands
+        .filter((command) => command.status !== "passed")
+        .map((command) => `${command.label} (${command.status})`)
+        .join(", ");
+    return failed.length === 0 ? "Checks failed." : `Checks failed: ${failed}.`;
+}
+function splitSummarySentences(summary) {
+    return summary
+        .split(/(?<=[.!?])\s+|\n+/u)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+}
+function describesValidationLimitation(sentence) {
+    return (/\bTutti checks still need to run\b/iu.test(sentence) ||
+        (/\b(?:unable|could not|cannot|can't|not able|did not|didn't|blocked|unavailable)\b/iu.test(sentence) &&
+            /\b(?:check|checks|test|tests|build|typecheck|lint|validation|command|commands)\b/iu.test(sentence)) ||
+        (/\b(?:check|checks|test|tests|build|typecheck|lint|validation|command|commands)\b/iu.test(sentence) &&
+            /\b(?:not run|not executed|unavailable|blocked|unable|could not|cannot|can't)\b/iu.test(sentence)));
+}
+function implementationSummary(summary) {
+    const retained = splitSummarySentences(summary).filter((sentence) => !describesValidationLimitation(sentence));
+    const text = retained.join(" ").trim();
+    return text.length === 0 ? "Task implementation completed." : text;
+}
+function sentence(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    return /[.!?]$/u.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+export function successfulRunSummary(input) {
+    void input.checks;
+    void input.completion;
+    return sentence(implementationSummary(input.implementation));
+}
+export function checkStatus(checks) {
+    return checks.status;
+}
+export function checkSkipFields(checks) {
+    if (checks.status !== "skipped") {
+        return {};
+    }
+    return {
+        skip_reason_code: checks.skip_reason_code,
+        skip_reason_summary: checks.skip_reason_summary,
+    };
+}
+function isDocumentationPath(path) {
+    const normalized = path.replace(/\\/gu, "/").toLowerCase();
+    const name = normalized.split("/").at(-1) ?? normalized;
+    return name === "readme.md" || normalized.endsWith(".md") || normalized.endsWith(".mdx");
+}
+export function docsStatusForChangedPaths(changedPaths) {
+    return changedPaths.some(isDocumentationPath) ? "updated" : "sync_deferred";
+}
+export function promotionNotAttempted(reasonCode, summary) {
+    return {
+        status: "not_attempted",
+        reason_code: reasonCode,
+        summary,
+    };
+}
+export function promotionNotPromoted(reasonCode, summary) {
+    return {
+        status: "not_promoted",
+        reason_code: reasonCode,
+        summary,
+    };
+}
+export function failedFinishedResult(input) {
+    return {
+        result_kind: "finished",
+        outcome: "failed",
+        summary: input.summary,
+        checks: checkStatus(input.checks),
+        docs: input.docs,
+        ...checkSkipFields(input.checks),
+        changed_paths: input.changedPaths,
+        promotion: input.promotion,
+    };
+}
+export function failedBeforeChecks(input) {
+    return {
+        result_kind: "failed",
+        summary: input.summary,
+        error_code: input.errorCode,
+        retryable: input.retryable,
+        ...(input.changedPaths === undefined ? {} : { changed_paths: input.changedPaths }),
+        promotion: input.promotion ??
+            promotionNotAttempted("run_failed_before_promotion", "Run failed before promotion."),
+    };
+}
+export function completedWithoutRepoChanges(input) {
+    return {
+        result_kind: "finished",
+        outcome: "completed",
+        summary: input.summary,
+        checks: "skipped",
+        docs: "checked_no_change",
+        skip_reason_code: "validation_not_applicable",
+        skip_reason_summary: "No repository validation was required for this task.",
+        changed_paths: [],
+        promotion: promotionNotAttempted("no_repo_changes_required", "No repository candidate changes were required for this task."),
+    };
+}
+//# sourceMappingURL=result-projections.js.map

package/dist/run-pipeline/task-run-invocation.d.ts

@@ -0,0 +1,6 @@
+import type { RunPipelineInput } from "../control-plane/index.js";
+import type { RunWorkspaceHandle } from "../workspace-ops/index.js";
+import type { OpenAiRunPipelineRunnerOptions } from "./openai.js";
+import { type TaskRunOutput } from "./task-run-output.js";
+export declare function runWorkspaceWriteTask(options: OpenAiRunPipelineRunnerOptions, input: RunPipelineInput, handle: RunWorkspaceHandle): Promise<TaskRunOutput>;
+//# sourceMappingURL=task-run-invocation.d.ts.map

package/dist/run-pipeline/task-run-invocation.js

@@ -0,0 +1,130 @@
+import { renderPromptTemplate } from "../prompt-templates/index.js";
+import { runCodexAppServerWorkspaceWriteRun, } from "../providers/openai/app-server/workspace-write-run.js";
+import { TASK_RUN_OUTPUT_SCHEMA, isInitialTaskRunOutput, normalizeTaskRunOutput, } from "./task-run-output.js";
+function taskContractRunInput(input) {
+    return {
+        title: input.task.title,
+        goal: input.task_detail.detail.contract.goal,
+        scope: input.task_detail.detail.contract.scope,
+    };
+}
+function initialTaskRunInput(input) {
+    return taskContractRunInput(input);
+}
+function continuationTaskRunInput(input) {
+    return {
+        ...taskContractRunInput(input),
+        ...(input.continuation_context === undefined
+            ? {}
+            : { continuation: input.continuation_context }),
+    };
+}
+function retryTaskRunInput(input) {
+    if (input.correction_context === undefined) {
+        throw new Error("Retry task run requires correction context.");
+    }
+    return {
+        ...taskContractRunInput(input),
+        correction: input.correction_context,
+    };
+}
+function createRunPrompt(options, input) {
+    const templateKey = input.run_lineage.kind === "continuation"
+        ? "runs.task_continuation"
+        : input.run_lineage.kind === "retry"
+            ? "runs.task_retry"
+            : "runs.task_run";
+    return renderPromptTemplate({
+        templateKey,
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: {
+            run_input_json: input.run_lineage.kind === "initial"
+                ? initialTaskRunInput(input)
+                : input.run_lineage.kind === "continuation"
+                    ? continuationTaskRunInput(input)
+                    : retryTaskRunInput(input),
+        },
+    });
+}
+function usageSource(input) {
+    switch (input.run_lineage.kind) {
+        case "continuation":
+            return "follow_up_run";
+        case "retry":
+            return "pipeline_self_correction";
+        case "initial":
+            return "workspace_write_run";
+    }
+}
+export async function runWorkspaceWriteTask(options, input, handle) {
+    const manager = options.approvalManager;
+    const approvalHandler = manager === undefined
+        ? undefined
+        : (approvalInput) => manager.awaitApproval({
+            request: approvalInput.request,
+            context: {
+                taskId: input.task.id,
+                activityRef: input.activity_ref,
+                workspaceRoot: approvalInput.context.workspaceRoot,
+                runWorkspaceRoot: approvalInput.context.runWorkspaceRoot,
+                codexHome: approvalInput.context.codexHome,
+                ...(approvalInput.context.tuttiHome === undefined
+                    ? {}
+                    : { tuttiHome: approvalInput.context.tuttiHome }),
+                ...(approvalInput.context.builtInSkillsRoot === undefined
+                    ? {}
+                    : { builtInSkillsRoot: approvalInput.context.builtInSkillsRoot }),
+                sensitiveValues: approvalInput.context.sensitiveValues,
+            },
+            timeoutMs: approvalInput.context.turnTimeoutMs,
+        });
+    let result;
+    try {
+        result = await runCodexAppServerWorkspaceWriteRun({
+            apiKey: options.apiKey,
+            workspaceRoot: handle.repo_root,
+            prompt: createRunPrompt(options, input),
+            outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+            validateOutput: (value) => isInitialTaskRunOutput(value),
+            skillSelectionName: input.run_lineage.kind === "continuation" ? "follow_up_run" : "workspace_write_run",
+            defaultModel: options.config.default_model,
+            approvalContext: {
+                workspaceRoot: options.workspaceRoot,
+                runWorkspaceRoot: handle.repo_root,
+                taskId: input.task.id,
+                activityRef: input.activity_ref,
+            },
+            ...(approvalHandler === undefined ? {} : { approvalHandler }),
+            ...(options.config.api_base_url === undefined
+                ? {}
+                : { apiBaseUrl: options.config.api_base_url }),
+            ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
+            ...(options.builtInSkillsRoot === undefined
+                ? {}
+                : { builtInSkillsRoot: options.builtInSkillsRoot }),
+            ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
+            ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
+            ...(options.requestTimeoutMs === undefined
+                ? {}
+                : { requestTimeoutMs: options.requestTimeoutMs }),
+            ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
+            ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
+        });
+    }
+    finally {
+        options.approvalManager?.clearPending();
+    }
+    if (options.recordUsage !== undefined && result.usage !== undefined) {
+        options.recordUsage({
+            provider: "openai",
+            source: usageSource(input),
+            model: result.model,
+            usage: result.usage,
+            activity_ref: input.activity_ref,
+            task_id: input.task.id,
+            run_lineage_kind: input.run_lineage.kind,
+        });
+    }
+    return normalizeTaskRunOutput(result.output);
+}
+//# sourceMappingURL=task-run-invocation.js.map

package/dist/run-pipeline/task-run-output.d.ts

@@ -0,0 +1,38 @@
+import type { ClarificationRequestPayload } from "@tutti/shared/schemas/api";
+import type { OpenAiJsonSchema } from "../providers/openai/sdk-procedure-runner.js";
+export type TaskRunDocsStatus = "updated" | "checked_no_change" | "not_checked" | "sync_deferred";
+export type InitialTaskRunOutput = {
+    result: {
+        completed: {
+            summary: string;
+        };
+    } | {
+        completed_no_repo_changes: {
+            summary: string;
+        };
+    } | {
+        needs_human: ClarificationRequestPayload;
+    } | {
+        failed: {
+            summary: string;
+        };
+    };
+};
+export type TaskRunOutput = {
+    decision: "completed";
+    summary: string;
+} | {
+    decision: "completed_no_repo_changes";
+    summary: string;
+} | {
+    decision: "needs_human";
+    summary: string;
+    clarification_request_payload: ClarificationRequestPayload;
+} | {
+    decision: "failed";
+    summary: string;
+};
+export declare const TASK_RUN_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare function isInitialTaskRunOutput(value: unknown): value is InitialTaskRunOutput;
+export declare function normalizeTaskRunOutput(output: InitialTaskRunOutput): TaskRunOutput;
+//# sourceMappingURL=task-run-output.d.ts.map

package/dist/run-pipeline/task-run-output.js

@@ -0,0 +1,146 @@
+const TASK_RUN_CLARIFICATION_REQUEST_PAYLOAD_SCHEMA = {
+    type: "object",
+    required: ["title", "summary", "request"],
+    additionalProperties: false,
+    properties: {
+        title: { type: "string" },
+        summary: { type: "string" },
+        request: { type: "string" },
+    },
+};
+export const TASK_RUN_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["result"],
+    additionalProperties: false,
+    properties: {
+        result: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["completed"],
+                    additionalProperties: false,
+                    properties: {
+                        completed: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["completed_no_repo_changes"],
+                    additionalProperties: false,
+                    properties: {
+                        completed_no_repo_changes: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["needs_human"],
+                    additionalProperties: false,
+                    properties: {
+                        needs_human: TASK_RUN_CLARIFICATION_REQUEST_PAYLOAD_SCHEMA,
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["failed"],
+                    additionalProperties: false,
+                    properties: {
+                        failed: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    },
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTaskRunClarificationRequestPayloadShape(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    return (keys.every((key) => key === "title" || key === "summary" || key === "request") &&
+        typeof value.title === "string" &&
+        typeof value.summary === "string" &&
+        typeof value.request === "string");
+}
+function isTaskRunClarificationRequestPayload(value) {
+    if (!isTaskRunClarificationRequestPayloadShape(value)) {
+        return false;
+    }
+    return value.summary.trim().length > 0 && value.request.trim().length > 0;
+}
+function isSummaryRecord(value) {
+    return (isRecord(value) &&
+        Object.keys(value).every((key) => key === "summary") &&
+        typeof value.summary === "string");
+}
+export function isInitialTaskRunOutput(value) {
+    if (!isRecord(value) || !isRecord(value.result) || Object.keys(value).length !== 1) {
+        return false;
+    }
+    const branchKeys = Object.keys(value.result);
+    if (branchKeys.length !== 1) {
+        return false;
+    }
+    if ("completed" in value.result) {
+        return isSummaryRecord(value.result.completed);
+    }
+    if ("completed_no_repo_changes" in value.result) {
+        return isSummaryRecord(value.result.completed_no_repo_changes);
+    }
+    if ("needs_human" in value.result) {
+        return isTaskRunClarificationRequestPayload(value.result.needs_human);
+    }
+    if ("failed" in value.result) {
+        return isSummaryRecord(value.result.failed);
+    }
+    return false;
+}
+export function normalizeTaskRunOutput(output) {
+    if ("completed" in output.result) {
+        return {
+            decision: "completed",
+            summary: output.result.completed.summary,
+        };
+    }
+    if ("completed_no_repo_changes" in output.result) {
+        return {
+            decision: "completed_no_repo_changes",
+            summary: output.result.completed_no_repo_changes.summary,
+        };
+    }
+    if ("needs_human" in output.result) {
+        return {
+            decision: "needs_human",
+            summary: output.result.needs_human.summary,
+            clarification_request_payload: output.result.needs_human,
+        };
+    }
+    return {
+        decision: "failed",
+        summary: output.result.failed.summary,
+    };
+}
+//# sourceMappingURL=task-run-output.js.map

package/dist/server-shell/cli/args.d.ts

@@ -0,0 +1,7 @@
+export type LaunchCliArgs = {
+    command: "launch";
+    workspacePath: string;
+    yes: boolean;
+};
+export declare function parseLaunchCliArgs(argv: readonly string[], cwd?: string): LaunchCliArgs;
+//# sourceMappingURL=args.d.ts.map

package/dist/server-shell/cli/args.js

@@ -0,0 +1,30 @@
+import { resolve } from "node:path";
+import { LaunchError } from "./errors.js";
+export function parseLaunchCliArgs(argv, cwd = process.cwd()) {
+    const args = [...argv];
+    const command = args.shift();
+    if (command !== "launch") {
+        throw new LaunchError("git_bootstrap_failed", "Expected command: launch", "Run `tutti launch [workspace_path] [--yes]`.");
+    }
+    let workspacePath;
+    let yes = false;
+    for (const arg of args) {
+        if (arg === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Use only `--yes` with `tutti launch` in the MVP command surface.");
+        }
+        if (workspacePath !== undefined) {
+            throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti launch [workspace_path] [--yes]`.");
+        }
+        workspacePath = arg;
+    }
+    return {
+        command: "launch",
+        workspacePath: resolve(cwd, workspacePath ?? "."),
+        yes,
+    };
+}
+//# sourceMappingURL=args.js.map

package/dist/server-shell/cli/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map