@xfey/tutti 0.1.15 → 0.1.17

package/dist/collaboration-state/index.d.ts

@@ -1,7 +1,7 @@
 export { CollaborationStateCursorError } from "./serialization.js";
 export { createIdleExecutionStatusProjection } from "./execution-status.js";
 export { createMainChatAgentMessage, createMainChatMessage, createMainChatSystemMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readMessageProjectionById, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, } from "./messages.js";
-export { clearScratchpadProjection, createEmptyScratchpadProjection, readScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
+export { createEmptyScratchpadProjection, readScratchpadProjection, submitScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
 export { advanceScratchpadTaskCompileSourceCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, readScratchpadSourceState, } from "./scratchpad-source-state.js";
 export { deleteStaleClarificationSubmitReplayHints, readActiveClarificationProjection, readClarificationRoundProjection, readClarificationRoundsForThread, readClarificationThreadResponse, readSealedClarificationRoundsWithoutSuccessor, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } from "./clarification-records.js";
 export { createClarificationRoundAgentMessage, createClarificationRoundMessage, readClarificationRoundMessagesWindow, } from "./clarification-messages.js";
@@ -13,5 +13,5 @@ export { recoverStaleRunningTasksAsFailed } from "./recovery.js";
 export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
 export { readTaskDetailProjection } from "./task-details.js";
 export { applyTaskCompileProposal, markTaskRunStarted, readNextRunnableTask, readRecoverableScheduledRun, readTaskProjection, readWorklistProjection, } from "./worklist.js";
-export type { ApplyTaskCompileProposalResult, CloseTaskBoundClarificationRetaskingRequiredInput, CloseTaskBoundClarificationRetaskingRequiredResult, CreateClarificationRoundAgentMessageInput, CreateClarificationRoundMessageInput, CreateMainChatAgentMessageInput, CreateMainChatMessageInput, CreateMainChatSystemMessageInput, CursorPageOptions, MarkReadStateScopeInput, MarkReadStateScopeResult, MarkTaskRunStartedInput, MarkTaskRunStartedResult, MaterializeClarificationSuccessorInput, MaterializeTaskBoundRunSuccessorInput, MaterializeTaskBoundRunSuccessorResult, MessageAuthorInput, NextRunnableTaskResult, OpenNextTaskBoundClarificationRoundInput, OpenNextTaskBoundClarificationRoundResult, OpenNextTaskCompileClarificationRoundInput, OpenNextTaskCompileClarificationRoundResult, OpenTaskCompileClarificationRoundInput, OpenTaskCompileClarificationRoundResult, ReadMainChatMessagesAfterOptions, ReadMessageWindowOptions, ReadReadStateSummaryInput, RecoverStaleRunningTasksResult, RecoverableScheduledRun, RecordReadNotificationEventInput, RecordRecoverySummaryInput, RecordRecoverySummaryResult, RecordRunNeedsHumanResultInput, RecordRunNeedsHumanResultResult, RecordRunResultInput, RecordRunResultResult, RunResultPromotionProjection, ScratchpadSnapshotInput, SealedClarificationRoundWithoutSuccessor, SubmitClarificationRoundInput, TaskCompileProposalInput, TaskCompileProposalModuleInput, TaskCompileProposalTaskInput, } from "./types.js";
+export type { ApplyTaskCompileProposalResult, CloseTaskBoundClarificationRetaskingRequiredInput, CloseTaskBoundClarificationRetaskingRequiredResult, CreateClarificationRoundAgentMessageInput, CreateClarificationRoundMessageInput, CreateMainChatAgentMessageInput, CreateMainChatMessageInput, CreateMainChatSystemMessageInput, CursorPageOptions, MarkReadStateScopeInput, MarkReadStateScopeResult, MarkTaskRunStartedInput, MarkTaskRunStartedResult, MaterializeClarificationSuccessorInput, MaterializeTaskBoundRunSuccessorInput, MaterializeTaskBoundRunSuccessorResult, MessageAuthorInput, NextRunnableTaskResult, OpenNextTaskBoundClarificationRoundInput, OpenNextTaskBoundClarificationRoundResult, OpenNextTaskCompileClarificationRoundInput, OpenNextTaskCompileClarificationRoundResult, OpenTaskCompileClarificationRoundInput, OpenTaskCompileClarificationRoundResult, ReadMainChatMessagesAfterOptions, ReadMessageWindowOptions, ReadReadStateSummaryInput, RecoverStaleRunningTasksResult, RecoverableScheduledRun, RecordReadNotificationEventInput, RecordRecoverySummaryInput, RecordRecoverySummaryResult, RecordRunNeedsHumanResultInput, RecordRunNeedsHumanResultResult, RecordRunResultInput, RecordRunResultResult, RunResultPromotionProjection, ScratchpadSnapshotInput, SubmitScratchpadInput, SubmitScratchpadResult, SealedClarificationRoundWithoutSuccessor, SubmitClarificationRoundInput, TaskCompileProposalInput, TaskCompileProposalModuleInput, TaskCompileProposalTaskInput, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/collaboration-state/index.js

@@ -1,7 +1,7 @@
 export { CollaborationStateCursorError } from "./serialization.js";
 export { createIdleExecutionStatusProjection } from "./execution-status.js";
 export { createMainChatAgentMessage, createMainChatMessage, createMainChatSystemMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readMessageProjectionById, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, } from "./messages.js";
-export { clearScratchpadProjection, createEmptyScratchpadProjection, readScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
+export { createEmptyScratchpadProjection, readScratchpadProjection, submitScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
 export { advanceScratchpadTaskCompileSourceCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, readScratchpadSourceState, } from "./scratchpad-source-state.js";
 export { deleteStaleClarificationSubmitReplayHints, readActiveClarificationProjection, readClarificationRoundProjection, readClarificationRoundsForThread, readClarificationThreadResponse, readSealedClarificationRoundsWithoutSuccessor, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } from "./clarification-records.js";
 export { createClarificationRoundAgentMessage, createClarificationRoundMessage, readClarificationRoundMessagesWindow, } from "./clarification-messages.js";

package/dist/collaboration-state/scratchpad.d.ts

@@ -1,8 +1,8 @@
 import type { ScratchpadProjection } from "@tutti/shared/schemas/api";
 import type { SqliteDatabase } from "../store/index.js";
-import type { ScratchpadSnapshotInput } from "./types.js";
+import type { ScratchpadSnapshotInput, SubmitScratchpadInput } from "./types.js";
 export declare function createEmptyScratchpadProjection(): ScratchpadProjection;
 export declare function upsertScratchpadProjection(db: SqliteDatabase, input: ScratchpadSnapshotInput): ScratchpadProjection;
-export declare function clearScratchpadProjection(db: SqliteDatabase): ScratchpadProjection;
+export declare function submitScratchpadProjection(db: SqliteDatabase, input: SubmitScratchpadInput): ScratchpadProjection;
 export declare function readScratchpadProjection(db: SqliteDatabase): ScratchpadProjection;
 //# sourceMappingURL=scratchpad.d.ts.map

package/dist/collaboration-state/scratchpad.js

@@ -1,4 +1,5 @@
 import { nowIso, parseJson, stringifyJson } from "./serialization.js";
+const SCRATCHPAD_RECEIPT_LIMIT = 100;
 export function createEmptyScratchpadProjection() {
     return {
         id: "current",
@@ -8,8 +9,37 @@ export function createEmptyScratchpadProjection() {
         current_consensus: [],
         open_questions: [],
         task_changes: [],
+        receipts: [],
     };
 }
+function readScratchpadReceipts(db) {
+    const rows = db
+        .prepare(`
+        SELECT
+          workflow_ref,
+          activity_ref,
+          topic,
+          background_summary,
+          current_consensus_json,
+          open_questions_json,
+          task_changes_json,
+          submitted_at
+        FROM scratchpad_receipts
+        ORDER BY submitted_at DESC, workflow_ref DESC
+        LIMIT ${SCRATCHPAD_RECEIPT_LIMIT}
+      `)
+        .all();
+    return rows.map((row) => ({
+        workflow_ref: row.workflow_ref,
+        activity_ref: row.activity_ref,
+        topic: row.topic,
+        background_summary: row.background_summary,
+        current_consensus: parseJson(row.current_consensus_json, []),
+        open_questions: parseJson(row.open_questions_json, []),
+        task_changes: parseJson(row.task_changes_json, []),
+        submitted_at: row.submitted_at,
+    }));
+}
 export function upsertScratchpadProjection(db, input) {
     const updatedAt = nowIso(input.now);
     db.prepare(`
@@ -34,51 +64,108 @@ export function upsertScratchpadProjection(db, input) {
         ?
       )
       ON CONFLICT(id) DO UPDATE SET
+        state = 'ready',
         topic = excluded.topic,
         background_summary = excluded.background_summary,
         current_consensus_json = excluded.current_consensus_json,
         open_questions_json = excluded.open_questions_json,
         task_changes_json = excluded.task_changes_json,
         updated_by_activity_ref = excluded.updated_by_activity_ref,
-        updated_at = excluded.updated_at
+        updated_at = excluded.updated_at,
+        submitted_by_activity_ref = NULL,
+        submitted_by_workflow_ref = NULL,
+        submitted_at = NULL
     `).run(input.topic, input.background_summary, stringifyJson(input.current_consensus), stringifyJson(input.open_questions), stringifyJson(input.task_changes), input.updated_by_activity_ref ?? null, updatedAt);
     return readScratchpadProjection(db);
 }
-export function clearScratchpadProjection(db) {
-    db.prepare("DELETE FROM scratchpad WHERE id = 'current'").run();
-    return createEmptyScratchpadProjection();
+export function submitScratchpadProjection(db, input) {
+    const submittedAt = nowIso(input.now);
+    const scratchpad = readScratchpadProjection(db);
+    if (scratchpad.state === "empty") {
+        return scratchpad;
+    }
+    db.prepare(`
+      INSERT INTO scratchpad_receipts (
+        workflow_ref,
+        activity_ref,
+        topic,
+        background_summary,
+        current_consensus_json,
+        open_questions_json,
+        task_changes_json,
+        submitted_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workflow_ref) DO UPDATE SET
+        activity_ref = excluded.activity_ref,
+        topic = excluded.topic,
+        background_summary = excluded.background_summary,
+        current_consensus_json = excluded.current_consensus_json,
+        open_questions_json = excluded.open_questions_json,
+        task_changes_json = excluded.task_changes_json,
+        submitted_at = excluded.submitted_at
+    `).run(input.workflow_ref, input.activity_ref, scratchpad.topic, scratchpad.background_summary, stringifyJson(scratchpad.current_consensus), stringifyJson(scratchpad.open_questions), stringifyJson(scratchpad.task_changes), submittedAt);
+    db.prepare(`
+      UPDATE scratchpad
+      SET
+        state = 'submitted',
+        submitted_by_activity_ref = ?,
+        submitted_by_workflow_ref = ?,
+        submitted_at = ?,
+        updated_at = ?
+      WHERE id = 'current'
+    `).run(input.activity_ref, input.workflow_ref, submittedAt, submittedAt);
+    return readScratchpadProjection(db);
 }
 export function readScratchpadProjection(db) {
+    const receipts = readScratchpadReceipts(db);
     const row = db
         .prepare(`
         SELECT
+          state,
           topic,
           background_summary,
           current_consensus_json,
           open_questions_json,
           task_changes_json,
           updated_by_activity_ref,
-          updated_at
+          updated_at,
+          submitted_by_activity_ref,
+          submitted_by_workflow_ref,
+          submitted_at
         FROM scratchpad
         WHERE id = 'current'
       `)
         .get();
     if (row === undefined) {
-        return createEmptyScratchpadProjection();
+        return {
+            ...createEmptyScratchpadProjection(),
+            receipts,
+        };
     }
     const scratchpad = {
         id: "current",
-        state: "ready",
+        state: row.state,
         topic: row.topic,
         background_summary: row.background_summary,
         current_consensus: parseJson(row.current_consensus_json, []),
         open_questions: parseJson(row.open_questions_json, []),
         task_changes: parseJson(row.task_changes_json, []),
         updated_at: row.updated_at,
+        receipts,
     };
     if (row.updated_by_activity_ref !== null) {
         scratchpad.updated_by_activity_ref = row.updated_by_activity_ref;
     }
+    if (row.submitted_by_activity_ref !== null) {
+        scratchpad.submitted_by_activity_ref = row.submitted_by_activity_ref;
+    }
+    if (row.submitted_by_workflow_ref !== null) {
+        scratchpad.submitted_by_workflow_ref = row.submitted_by_workflow_ref;
+    }
+    if (row.submitted_at !== null) {
+        scratchpad.submitted_at = row.submitted_at;
+    }
     return scratchpad;
 }
 //# sourceMappingURL=scratchpad.js.map

package/dist/collaboration-state/storage-types.d.ts

@@ -13,6 +13,7 @@ export type MessageRow = {
     created_at: string;
 };
 export type ScratchpadRow = {
+    state: "ready" | "submitted";
     topic: string;
     background_summary: string;
     current_consensus_json: string;
@@ -20,6 +21,19 @@ export type ScratchpadRow = {
     task_changes_json: string;
     updated_by_activity_ref: string | null;
     updated_at: string;
+    submitted_by_activity_ref: string | null;
+    submitted_by_workflow_ref: string | null;
+    submitted_at: string | null;
+};
+export type ScratchpadReceiptRow = {
+    workflow_ref: string;
+    activity_ref: string;
+    topic: string;
+    background_summary: string;
+    current_consensus_json: string;
+    open_questions_json: string;
+    task_changes_json: string;
+    submitted_at: string;
 };
 export type ScratchpadSourceStateRow = {
     main_chat_cursor_created_at: string | null;

package/dist/collaboration-state/types.d.ts

@@ -1,7 +1,7 @@
 import type { RunLineage } from "@tutti/shared/domain";
 import type { AccountAvatarProjection } from "@tutti/shared/domain";
 import type { ActivityRef, ClarificationRoundRef, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
-import type { ClarificationRequestPayload, ClarificationRoundProjection, ClarificationSuccessorRef, ClarificationThreadProjection, MessageProjection, ReadStateScope, ReadStateSummaryProjection, RecoverySummaryProjection, RunResultProjection, TaskContractProjection, TaskDetailProjection, TaskDetailResultProjection, TaskProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ClarificationRequestPayload, ClarificationRoundProjection, ClarificationSuccessorRef, ClarificationThreadProjection, MessageProjection, ReadStateScope, ReadStateSummaryProjection, RecoverySummaryProjection, RunResultProjection, ScratchpadProjection, TaskContractProjection, TaskDetailProjection, TaskDetailResultProjection, TaskProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 export type MessageAuthorInput = {
     kind: "human" | "system" | "agent";
     ref?: string;
@@ -56,6 +56,14 @@ export type ScratchpadSnapshotInput = {
     updated_by_activity_ref?: ActivityRef;
     now?: () => Date;
 };
+export type SubmitScratchpadInput = {
+    workflow_ref: WorkflowInvocationRef;
+    activity_ref: ActivityRef;
+    now?: () => Date;
+};
+export type SubmitScratchpadResult = {
+    scratchpad: ScratchpadProjection;
+};
 export type TaskCompileProposalInput = {
     workflow_ref: WorkflowInvocationRef;
     proposal: {

package/dist/control-plane/task-compile-output.js

@@ -1,4 +1,4 @@
-import { applyTaskCompileProposal, clearScratchpadProjection, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readWorklistProjection, } from "../collaboration-state/index.js";
+import { applyTaskCompileProposal, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readWorklistProjection, submitScratchpadProjection, } from "../collaboration-state/index.js";
 import { clarificationInvalidates, taskCompileInvalidates, } from "./invalidations.js";
 import { normalizeTaskCompileProposal } from "./task-proposal.js";
 const EMPTY_INITIAL_WORKLIST_CLARIFICATION = {
@@ -86,7 +86,11 @@ export function applyTaskCompileProcedureOutput(input) {
     if (applied.changed_task_ids.length > 0) {
         input.onTasksAdded?.();
     }
-    const clearedScratchpad = clearScratchpadProjection(input.store.db);
+    const submittedScratchpad = submitScratchpadProjection(input.store.db, {
+        workflow_ref: input.workflowRef,
+        activity_ref: input.activityRef,
+        now: input.now,
+    });
     input.events.publish({
         event_type: "worklist.changed",
         payload: {
@@ -101,7 +105,7 @@ export function applyTaskCompileProcedureOutput(input) {
     input.events.publish({
         event_type: "scratchpad.updated",
         payload: {
-            scratchpad: clearedScratchpad,
+            scratchpad: submittedScratchpad,
             activity_ref: input.activityRef,
         },
         invalidates: taskCompileInvalidates(),

package/dist/control-plane/task-compile-start.d.ts

@@ -40,5 +40,8 @@ export declare function runControlPlaneTaskCompileProcedure(options: {
         kind: "workflow";
         workflow_ref: `wf_${string}`;
     };
+} | {
+    kind: "failed";
+    summary: string;
 }>;
 //# sourceMappingURL=task-compile-start.d.ts.map

package/dist/control-plane/task-compile-start.js

@@ -51,7 +51,7 @@ export function startControlPlaneTaskCompile(options) {
             sourceBatch,
         });
     }
-    if (scratchpad.state === "empty") {
+    if (!scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
     if (shouldInitializeProjectContext) {
@@ -66,6 +66,10 @@ export function startControlPlaneTaskCompile(options) {
     });
 }
 function startControlPlaneTaskCompileActivity(options) {
+    const scratchpad = readScratchpadProjection(options.store.db);
+    if (!scratchpadHasSubmittableContent(scratchpad)) {
+        return { disposition: { kind: "scratchpad_empty" } };
+    }
     const workflowRef = createWorkflowInvocationRef();
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
@@ -120,13 +124,18 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.activity.status === "finished") {
-                if (shouldInitializeControlPlaneProjectContext(options)) {
-                    void startProjectContextBootstrapActivity(options);
-                }
-                else {
-                    void startControlPlaneTaskCompileActivity(options);
-                }
+            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+                return;
+            }
+            const scratchpad = readScratchpadProjection(options.store.db);
+            if (!scratchpadHasSubmittableContent(scratchpad)) {
+                return;
+            }
+            if (shouldInitializeControlPlaneProjectContext(options)) {
+                void startProjectContextBootstrapActivity(options);
+            }
+            else {
+                void startControlPlaneTaskCompileActivity(options);
             }
         },
         onError: ({ context, error }) => logProcedureExecutionError({
@@ -186,9 +195,17 @@ function startProjectContextBootstrapActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.activity.status === "finished") {
-                void startControlPlaneTaskCompileActivity(options);
+            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+                return;
+            }
+            if (shouldInitializeControlPlaneProjectContext(options)) {
+                return;
             }
+            const scratchpad = readScratchpadProjection(options.store.db);
+            if (!scratchpadHasSubmittableContent(scratchpad)) {
+                return;
+            }
+            void startControlPlaneTaskCompileActivity(options);
         },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
@@ -261,9 +278,16 @@ function startProjectContextBootstrapActivity(options) {
     };
 }
 export async function runControlPlaneTaskCompileProcedure(options) {
+    const scratchpad = readScratchpadProjection(options.store.db);
+    if (!scratchpadHasSubmittableContent(scratchpad)) {
+        return {
+            kind: "failed",
+            summary: "Scratchpad is empty. Discuss more before running.",
+        };
+    }
     const output = await options.runner.runTaskCompile({
         workflow_ref: options.workflowRef,
-        scratchpad: readScratchpadProjection(options.store.db),
+        scratchpad,
         worklist: readWorklistProjection(options.store.db),
     }, {
         workflow_ref: options.workflowRef,
@@ -282,4 +306,16 @@ export async function runControlPlaneTaskCompileProcedure(options) {
         onTasksAdded: options.onTasksAdded,
     });
 }
+function scratchpadHasSubmittableContent(scratchpad) {
+    if (scratchpad.state !== "ready") {
+        return false;
+    }
+    return [
+        scratchpad.topic,
+        scratchpad.background_summary,
+        ...scratchpad.current_consensus,
+        ...scratchpad.open_questions,
+        ...scratchpad.task_changes,
+    ].some((item) => item.trim().length > 0);
+}
 //# sourceMappingURL=task-compile-start.js.map

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { formatCliError, formatCliErrorReason } from "./errors.js";
+import { formatCliError } from "./errors.js";
 import { parseCliArgs } from "./args.js";
 import { runBackgroundLaunchCommand, runForegroundLaunchCommand, runInternalHostRunCommand, } from "./launch-command.js";
 import { resolveExistingProjectContext } from "./project-resolver.js";
 import { runProviderSetupTui } from "./provider-tui.js";
-import { runInviteCommand, runLogsCommand, runProviderStatusCommand, runPsManageCommand, runPsCommand, runStopCommand, } from "./runtime-commands.js";
+import { runDoctorCommand, runInviteCommand, runLogsCommand, runProviderStatusCommand, runPsManageCommand, runPsCommand, runStopCommand, } from "./runtime-commands.js";
 import { readCliVersion } from "./version.js";
 const HELP_TEXT = `Usage:
   tutti launch [target] [--yes] [--foreground]
@@ -108,25 +108,6 @@ async function runProviderSetupCommand(target) {
     ].join("\n"));
     process.stdout.write("\n");
 }
-function runDoctorCommand(target) {
-    const checks = [];
-    checks.push(`Node: ${process.version}`);
-    checks.push(`Tutti: ${readCliVersion()}`);
-    try {
-        const project = resolveExistingProjectContext({
-            ...(target === undefined ? {} : { target }),
-        });
-        checks.push(`Project: ${project.display_name}`);
-        checks.push(`Project ID: ${project.project_id}`);
-        checks.push(`Provider: ${project.provider_config.status}`);
-        checks.push(`Host: ${project.runtime_endpoint === null ? "not running" : project.runtime_endpoint.base_url}`);
-    }
-    catch (error) {
-        checks.push("Project: unavailable");
-        checks.push(`Project detail: ${formatCliErrorReason(error)}`);
-    }
-    process.stdout.write(`${checks.join("\n")}\n`);
-}
 try {
     const command = parseCliArgs(process.argv.slice(2));
     switch (command.kind) {
@@ -171,7 +152,7 @@ try {
             process.stdout.write(`${runProviderStatusCommand(command.target)}\n`);
             break;
         case "doctor":
-            runDoctorCommand(command.target);
+            process.stdout.write(`${runDoctorCommand(command.target)}\n`);
             break;
     }
 }

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

@@ -61,6 +61,10 @@ export declare function deleteMachineRuntimeEndpoint(options: {
     projectId: ProjectId;
     expectedToken?: string;
 }): boolean;
+export declare function deleteMachineProjectLocalState(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+}): boolean;
 export declare function readHostRegistrationSecret(tuttiHome: string, projectId: ProjectId): HostRegistrationSecretFile;
 export declare function updateMachineProjectRelayBinding(options: {
     tuttiHome: string;

package/dist/server-shell/cli/machine-local.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 import { LaunchError } from "./errors.js";
@@ -150,6 +150,20 @@ export function deleteMachineRuntimeEndpoint(options) {
     unlinkSync(endpointPath);
     return true;
 }
+export function deleteMachineProjectLocalState(options) {
+    let deleted = false;
+    const localStoreRoot = getProjectLocalStoreRoot(options.tuttiHome, options.projectId);
+    if (existsSync(localStoreRoot)) {
+        rmSync(localStoreRoot, { recursive: true, force: true });
+        deleted = true;
+    }
+    const secretPath = getHostRegistrationSecretPath(options.tuttiHome, options.projectId);
+    if (existsSync(secretPath)) {
+        unlinkSync(secretPath);
+        deleted = true;
+    }
+    return deleted;
+}
 export function readHostRegistrationSecret(tuttiHome, projectId) {
     const readResult = readJsonFile(getHostRegistrationSecretPath(tuttiHome, projectId));
     if (readResult.kind === "missing") {

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

@@ -11,6 +11,9 @@ export type ExistingProjectContext = {
     provider_config: OpenAiProviderConfigProjection;
     provider_base_url?: string;
 };
+export type ManagedProjectContext = ExistingProjectContext & {
+    workspace_exists: boolean;
+};
 export declare function resolveLaunchWorkspacePath(options: {
     target?: string;
     cwd?: string;
@@ -22,4 +25,9 @@ export declare function resolveExistingProjectContext(options: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
 }): ExistingProjectContext;
+export declare function resolveManagedProjectContext(options: {
+    target?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ManagedProjectContext;
 //# sourceMappingURL=project-resolver.d.ts.map

package/dist/server-shell/cli/project-resolver.js

@@ -70,28 +70,50 @@ function resolveSingleTargetMatch(target, matches) {
     throw new LaunchError("project_target_not_found", `Project target was not found: ${target}`, "Run `tutti ps` to list known projects, or pass a project workspace path.");
 }
 function resolveProjectTargetWorkspaceRoot(options) {
+    return resolveProjectTargetEntry(options).workspace_root;
+}
+function resolveProjectTargetEntry(options) {
     const target = options.target.trim();
     if (target === "") {
-        return resolve(options.cwd, ".");
+        return readProjectTargetEntryFromWorkspace(resolve(options.cwd, "."));
     }
     const pathCandidate = resolve(options.cwd, target);
     if (existsSync(pathCandidate)) {
-        return pathCandidate;
+        return readProjectTargetEntryFromWorkspace(pathCandidate);
     }
     const entries = listProjectTargetEntries(options.tuttiHome);
+    const pathMatches = entries.filter((entry) => resolve(entry.workspace_root) === pathCandidate);
+    if (pathMatches.length > 0) {
+        return resolveSingleTargetMatch(target, pathMatches);
+    }
     const exactId = entries.filter((entry) => entry.project_id === target);
     if (exactId.length > 0) {
-        return resolveSingleTargetMatch(target, exactId).workspace_root;
+        return resolveSingleTargetMatch(target, exactId);
     }
     if (target.startsWith(ID_PREFIXES.project)) {
         const idPrefix = entries.filter((entry) => entry.project_id.startsWith(target));
         if (idPrefix.length > 0) {
-            return resolveSingleTargetMatch(target, idPrefix).workspace_root;
+            return resolveSingleTargetMatch(target, idPrefix);
         }
     }
     const normalizedTarget = normalizeTargetName(target);
     const nameMatches = entries.filter((entry) => entry.aliases.some((alias) => normalizeTargetName(alias) === normalizedTarget));
-    return resolveSingleTargetMatch(target, nameMatches).workspace_root;
+    return resolveSingleTargetMatch(target, nameMatches);
+}
+function readProjectTargetEntryFromWorkspace(workspaceRoot) {
+    assertSafeProjectRoot(workspaceRoot);
+    const identity = readProjectIdentity(workspaceRoot);
+    if (identity.kind !== "present") {
+        throw new LaunchError("project_identity_conflict", "Current directory is not a Tutti project", "Run `tutti launch` from a project root first.");
+    }
+    const workspaceName = basename(workspaceRoot) || identity.project_id;
+    const displayName = readProjectDisplayName(workspaceRoot) ?? workspaceName;
+    return {
+        project_id: identity.project_id,
+        workspace_root: workspaceRoot,
+        display_name: displayName,
+        aliases: Array.from(new Set([displayName, workspaceName].filter((alias) => alias.trim() !== ""))),
+    };
 }
 export function resolveLaunchWorkspacePath(options) {
     const cwd = options.cwd ?? process.cwd();
@@ -154,4 +176,44 @@ export function resolveExistingProjectContext(options) {
             : {}),
     };
 }
+export function resolveManagedProjectContext(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    if (options.target === undefined || existsSync(resolve(cwd, options.target))) {
+        const existing = resolveExistingProjectContext({
+            ...(options.target === undefined ? {} : { target: options.target }),
+            cwd,
+            env,
+        });
+        return {
+            ...existing,
+            workspace_exists: true,
+        };
+    }
+    const entry = resolveProjectTargetEntry({
+        target: options.target,
+        cwd,
+        tuttiHome,
+    });
+    const binding = readBinding(tuttiHome, entry.project_id);
+    const runtimeEndpoint = readRuntimeEndpoint(tuttiHome, entry.project_id);
+    const projectConfig = readProjectOpenAiProviderConfig(tuttiHome, entry.project_id);
+    return {
+        workspace_root: entry.workspace_root,
+        workspace_exists: existsSync(entry.workspace_root),
+        tutti_home: tuttiHome,
+        project_id: entry.project_id,
+        display_name: entry.display_name,
+        binding,
+        runtime_endpoint: runtimeEndpoint,
+        provider_config: readOpenAiProviderConfigProjection({
+            tuttiHome,
+            projectId: entry.project_id,
+        }),
+        ...(projectConfig.kind === "ok" && projectConfig.config.api_base_url !== undefined
+            ? { provider_base_url: projectConfig.config.api_base_url }
+            : {}),
+    };
+}
 //# sourceMappingURL=project-resolver.js.map

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

@@ -1,5 +1,12 @@
 import { type ConfigureProjectOpenAiProviderResult } from "../../providers/openai/index.js";
 import type { ProjectId } from "@tutti/shared/ids";
+type ProviderSetupStep = "base-url" | "api-key";
+type ProviderFormState = {
+    step: ProviderSetupStep;
+    baseUrl: string;
+    apiKey: string;
+    error: string | undefined;
+};
 type ProviderSetupLogEvent = {
     ts: string;
     level: "error";
@@ -17,6 +24,11 @@ export type ProviderSetupResult = {
     default_model: string;
     validated_at: string;
 };
+export declare function renderProviderForm(options: {
+    state: ProviderFormState;
+    footer?: string;
+    tty?: boolean;
+}): string;
 export declare function providerValidationFailureMessage(result: ConfigureProjectOpenAiProviderResult): string;
 export declare function writeProviderSetupValidationLog(options: {
     tuttiHome: string;