@xfey/tutti 0.1.60 → 0.1.62

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

@@ -1,4 +1,5 @@
-import { applyTaskCompileProposal, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readWorklistProjection, submitScratchpadProjection, } from "../collaboration-state/index.js";
+import { applyTaskCompileProposal, completeTaskCompileContext, materializeClarificationSuccessor, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readClarificationRoundProjection, readWorklistProjection, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { clarificationInvalidates, taskCompileInvalidates, } from "./invalidations.js";
 import { normalizeTaskCompileProposal } from "./task-proposal.js";
 const EMPTY_INITIAL_WORKLIST_CLARIFICATION = {
@@ -72,25 +73,45 @@ export function applyTaskCompileProcedureOutput(input) {
     }
     const currentWorklist = readWorklistProjection(input.store.db);
     const proposal = normalizeTaskCompileProposal(input.output.proposal);
-    if (proposal.tasks.length === 0 && countWorklistTasks(currentWorklist) === 0) {
+    if (input.continueFromRoundId === undefined &&
+        proposal.tasks.length === 0 &&
+        countWorklistTasks(currentWorklist) === 0) {
         return openTaskCompileNeedsHuman({
             ...input,
             requestPayload: EMPTY_INITIAL_WORKLIST_CLARIFICATION,
         });
     }
-    const applied = applyTaskCompileProposal(input.store.db, {
-        workflow_ref: input.workflowRef,
-        proposal,
-        now: input.now,
+    const continuationRound = input.continueFromRoundId === undefined
+        ? null
+        : readClarificationRoundProjection(input.store.db, input.continueFromRoundId);
+    const committed = withHostStoreTransaction(input.store.db, (tx) => {
+        const applied = applyTaskCompileProposal(tx, {
+            workflow_ref: input.workflowRef,
+            proposal,
+            now: input.now,
+        });
+        const scratchpad = completeTaskCompileContext(tx, {
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            now: input.now,
+        });
+        if (input.continueFromRoundId !== undefined) {
+            materializeClarificationSuccessor(tx, {
+                round_id: input.continueFromRoundId,
+                successor_ref: {
+                    kind: "proposal_applied",
+                    workflow_ref: input.workflowRef,
+                },
+                close_thread: true,
+                now: input.now,
+            });
+        }
+        return { applied, scratchpad };
     });
+    const { applied } = committed;
     if (applied.changed_task_ids.length > 0) {
         input.onTasksAdded?.();
     }
-    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: {
@@ -105,21 +126,36 @@ export function applyTaskCompileProcedureOutput(input) {
     input.events.publish({
         event_type: "scratchpad.updated",
         payload: {
-            scratchpad: submittedScratchpad,
+            scratchpad: committed.scratchpad,
             activity_ref: input.activityRef,
         },
         invalidates: taskCompileInvalidates(),
     });
+    if (input.continueFromRoundId !== undefined && continuationRound !== null) {
+        input.events.publish({
+            event_type: "clarification.changed",
+            payload: {
+                reason: "successor_materialized",
+                thread_id: continuationRound.thread_id,
+                round_id: input.continueFromRoundId,
+                successor_ref: {
+                    kind: "proposal_applied",
+                    workflow_ref: input.workflowRef,
+                },
+            },
+            invalidates: clarificationInvalidates(input.continueFromRoundId, continuationRound.thread_id),
+        });
+    }
     if (input.continueFromRoundId !== undefined) {
         return {
             kind: "completed",
-            summary: "Worklist compiled.",
+            summary: proposal.tasks.length === 0 ? "No new task created." : "Worklist compiled.",
             result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
         };
     }
     return {
         kind: "completed",
-        summary: "Worklist compiled.",
+        summary: proposal.tasks.length === 0 ? "No new task created." : "Worklist compiled.",
         result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
     };
 }

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

@@ -1,5 +1,5 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
-import { readScratchpadProjection, readWorklistProjection } from "../collaboration-state/index.js";
+import { captureTaskCompileContext, readActiveTaskCompileContext, readScratchpadProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
 import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
@@ -7,6 +7,15 @@ import { applyProjectDocsInitializationResult, buildProjectDocsInitializationCon
 import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
 export function startControlPlaneTaskCompile(options) {
+    const activeContext = readActiveTaskCompileContext(options.store.db);
+    if (activeContext !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeContext.captured_by_activity_ref,
+            },
+        };
+    }
     const scratchpad = readScratchpadProjection(options.store.db);
     if (options.payload.expected_scratchpad_updated_at !== undefined &&
         options.payload.expected_scratchpad_updated_at !== scratchpad.updated_at) {
@@ -31,6 +40,7 @@ export function startControlPlaneTaskCompile(options) {
             },
         };
     }
+    const taskCompileWorkflowRef = createWorkflowInvocationRef();
     const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store);
     if (sourceBatch.source_message_count > 0) {
         const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef({
@@ -49,6 +59,7 @@ export function startControlPlaneTaskCompile(options) {
             ...options,
             runner: runnerResolution.runner,
             sourceBatch,
+            taskCompileWorkflowRef,
         });
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
@@ -58,19 +69,23 @@ export function startControlPlaneTaskCompile(options) {
         return startProjectContextBootstrapActivity({
             ...options,
             runner: runnerResolution.runner,
+            taskCompileWorkflowRef,
         });
     }
     return startControlPlaneTaskCompileActivity({
         ...options,
         runner: runnerResolution.runner,
+        taskCompileWorkflowRef,
     });
 }
 function startControlPlaneTaskCompileActivity(options) {
+    const activeContext = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef);
     const scratchpad = readScratchpadProjection(options.store.db);
-    if (!scratchpadHasSubmittableContent(scratchpad)) {
+    if (activeContext === null &&
+        !scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
-    const workflowRef = createWorkflowInvocationRef();
+    const workflowRef = options.taskCompileWorkflowRef;
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
         workflow_kind: "task_compile",
@@ -201,8 +216,7 @@ function startProjectContextBootstrapActivity(options) {
             if (shouldInitializeControlPlaneProjectContext(options)) {
                 return;
             }
-            const scratchpad = readScratchpadProjection(options.store.db);
-            if (!scratchpadHasSubmittableContent(scratchpad)) {
+            if (readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef) === null) {
                 return;
             }
             void startControlPlaneTaskCompileActivity(options);
@@ -221,44 +235,59 @@ function startProjectContextBootstrapActivity(options) {
                     summary: "Project context is unavailable.",
                 };
             }
-            const initializationContext = buildProjectDocsInitializationContext(readScratchpadProjection(options.store.db));
-            const modelDocuments = await tryProjectContextBootstrapDocuments({
-                runner: options.runner,
-                projectContext: options.projectContext,
-                scratchpad: readScratchpadProjection(options.store.db),
-                projectName: options.projectContext.projectName,
-                workflowRef,
+            const taskCompileContext = readOrCaptureTaskCompileContext({
+                store: options.store,
+                workflowRef: options.taskCompileWorkflowRef,
                 activityRef: context.activity_ref,
-                logger: options.logger,
-                reportProgress: context.reportProgress,
-                now: options.now,
-            });
-            const initialized = initializeProjectDocs({
-                workspaceRoot: options.projectContext.workspaceRoot,
-                projectName: options.projectContext.projectName,
-                context: initializationContext,
-                ...(modelDocuments === undefined ? {} : { documents: modelDocuments }),
                 now: options.now,
             });
-            if (projectBriefShouldRefreshForUpdatedPaths(initialized.created_paths)) {
-                await refreshProjectBriefProjection({
-                    store: options.store,
-                    projectContext: options.projectContext,
-                    reason: "project_context_bootstrap",
+            try {
+                const initializationContext = buildProjectDocsInitializationContext(taskCompileContext.scratchpad_snapshot);
+                const modelDocuments = await tryProjectContextBootstrapDocuments({
                     runner: options.runner,
+                    projectContext: options.projectContext,
+                    scratchpad: taskCompileContext.scratchpad_snapshot,
+                    projectName: options.projectContext.projectName,
                     workflowRef,
                     activityRef: context.activity_ref,
                     logger: options.logger,
+                    reportProgress: context.reportProgress,
+                    now: options.now,
+                });
+                const initialized = initializeProjectDocs({
+                    workspaceRoot: options.projectContext.workspaceRoot,
+                    projectName: options.projectContext.projectName,
+                    context: initializationContext,
+                    ...(modelDocuments === undefined ? {} : { documents: modelDocuments }),
+                    now: options.now,
+                });
+                if (projectBriefShouldRefreshForUpdatedPaths(initialized.created_paths)) {
+                    await refreshProjectBriefProjection({
+                        store: options.store,
+                        projectContext: options.projectContext,
+                        reason: "project_context_bootstrap",
+                        runner: options.runner,
+                        workflowRef,
+                        activityRef: context.activity_ref,
+                        logger: options.logger,
+                        now: options.now,
+                    });
+                }
+                return applyProjectDocsInitializationResult({
+                    events: options.events,
+                    logger: options.logger,
+                    result: initialized,
+                    workflowRef,
+                    activityRef: context.activity_ref,
+                });
+            }
+            catch (error) {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
                     now: options.now,
                 });
+                throw error;
             }
-            return applyProjectDocsInitializationResult({
-                events: options.events,
-                logger: options.logger,
-                result: initialized,
-                workflowRef,
-                activityRef: context.activity_ref,
-            });
         },
     });
     if (start.kind === "already_running") {
@@ -278,33 +307,59 @@ 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,
-        worklist: readWorklistProjection(options.store.db),
-    }, {
-        workflow_ref: options.workflowRef,
-        activity_ref: options.activityRef,
-        ...(options.reportProgress === undefined
-            ? {}
-            : { reportProgress: options.reportProgress }),
-    });
-    return applyTaskCompileProcedureOutput({
+    const context = readOrCaptureTaskCompileContext({
         store: options.store,
-        events: options.events,
-        output,
         workflowRef: options.workflowRef,
         activityRef: options.activityRef,
         now: options.now,
-        onTasksAdded: options.onTasksAdded,
     });
+    if (!scratchpadSnapshotHasSubmittableContent(context.scratchpad_snapshot)) {
+        rollbackTaskCompileContext(options.store.db, {
+            workflow_ref: options.workflowRef,
+            now: options.now,
+        });
+        return {
+            kind: "failed",
+            summary: "Scratchpad is empty. Discuss more before running.",
+        };
+    }
+    try {
+        const output = await options.runner.runTaskCompile({
+            workflow_ref: options.workflowRef,
+            scratchpad: context.scratchpad_snapshot,
+            worklist: readWorklistProjection(options.store.db),
+        }, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+            ...(options.reportProgress === undefined
+                ? {}
+                : { reportProgress: options.reportProgress }),
+        });
+        return applyTaskCompileProcedureOutput({
+            store: options.store,
+            events: options.events,
+            output,
+            workflowRef: options.workflowRef,
+            activityRef: options.activityRef,
+            now: options.now,
+            onTasksAdded: options.onTasksAdded,
+        });
+    }
+    catch (error) {
+        rollbackTaskCompileContext(options.store.db, {
+            workflow_ref: options.workflowRef,
+            now: options.now,
+        });
+        throw error;
+    }
+}
+function readOrCaptureTaskCompileContext(input) {
+    return (readActiveTaskCompileContext(input.store.db, input.workflowRef) ??
+        captureTaskCompileContext(input.store.db, {
+            workflow_ref: input.workflowRef,
+            captured_by_activity_ref: input.activityRef,
+            now: input.now,
+        }));
 }
 function scratchpadHasSubmittableContent(scratchpad) {
     if (scratchpad.state !== "ready") {
@@ -318,4 +373,13 @@ function scratchpadHasSubmittableContent(scratchpad) {
         ...scratchpad.task_changes,
     ].some((item) => item.trim().length > 0);
 }
+function scratchpadSnapshotHasSubmittableContent(scratchpad) {
+    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/control-plane/workflows/openai.d.ts

@@ -2,7 +2,7 @@ import type { ProjectId } from "@tutti/shared/ids";
 import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
 import { type OpenAiStructuredOutputClient } from "../../providers/openai/sdk-procedure-runner.js";
 import { type OpenAiProviderConfig } from "../../providers/openai/provider-config.js";
-import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution } from "./types.js";
+import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution, TaskCompilePromptInput, TaskCompileWorkflowInput } from "./types.js";
 import type { CodexAppServerAgentContextRuntime } from "../../providers/openai/app-server/skills.js";
 export type OpenAiProcedureWorkflowRunnerOptions = {
     config: OpenAiProviderConfig;
@@ -30,6 +30,7 @@ export type ProjectOpenAiProcedureWorkflowRunnerOptions = {
     agentContext?: CodexAppServerAgentContextRuntime;
     recordUsage?: ProviderUsageRecorder;
 };
+export declare function buildTaskCompilePromptInput(input: TaskCompileWorkflowInput): TaskCompilePromptInput;
 export declare function createOpenAiProcedureWorkflowRunner(options: OpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunner;
 export declare function resolveProjectOpenAiProcedureWorkflowRunner(options: ProjectOpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunnerResolution;
 //# sourceMappingURL=openai.d.ts.map

package/dist/control-plane/workflows/openai.js

@@ -137,7 +137,7 @@ function followUpCheckWorkflowOutput(output) {
         summary: output.result.requires_retasking.summary,
     };
 }
-function taskCompilePromptInput(input) {
+export function buildTaskCompilePromptInput(input) {
     const promptInput = {
         scratchpad: {
             topic: input.scratchpad.topic,
@@ -160,34 +160,20 @@ function taskCompilePromptInput(input) {
             })),
         },
     };
-    if (input.clarification !== undefined) {
-        const request = {
-            ...(input.clarification.request_payload.title === undefined
-                ? {}
-                : { title: input.clarification.request_payload.title }),
-            summary: input.clarification.request_payload.summary,
-            request: input.clarification.request_payload.request,
-        };
-        promptInput.clarification = {
-            request,
-            answer_messages: input.clarification.messages
-                .filter((message) => message.message_kind === "user_text" || message.message_kind === "agent_text")
-                .map(taskCompileClarificationMessage),
-        };
+    if (input.clarification_rounds !== undefined) {
+        promptInput.clarification_rounds = input.clarification_rounds.map((round) => ({
+            request: {
+                ...(round.request_payload.title === undefined
+                    ? {}
+                    : { title: round.request_payload.title }),
+                summary: round.request_payload.summary,
+                request: round.request_payload.request,
+            },
+            answer_messages: round.answer_messages,
+        }));
     }
     return promptInput;
 }
-function taskCompileClarificationMessage(message) {
-    const role = message.author.kind === "agent" ? "tutti" : "human";
-    const authorDisplayName = message.author.display_name?.trim();
-    return {
-        role,
-        ...(role === "human" && authorDisplayName !== undefined && authorDisplayName !== ""
-            ? { author_display_name: authorDisplayName }
-            : {}),
-        text: message.body.trim(),
-    };
-}
 function taskCompileWorkflowOutput(output) {
     if ("clarification_request_payload" in output.result) {
         return {
@@ -280,7 +266,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 templateKey: "procedures.task_compile",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
-                    workflow_input_json: taskCompilePromptInput(input),
+                    workflow_input_json: buildTaskCompilePromptInput(input),
                 },
             });
             const result = await runCodexAppServerReadOnlyProcedure({

package/dist/control-plane/workflows/types.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, ScratchpadProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
 import type { ProjectDocKey } from "@tutti/shared/schemas/api";
 import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
@@ -6,21 +6,31 @@ import type { RunLineage } from "@tutti/shared/domain";
 import type { ProjectBriefSnapshot, ProjectBriefSourceDocument } from "../../project-brief/index.js";
 export type ScratchpadRefreshWorkflowInput = {
     project_brief?: ProjectBriefSnapshot;
-    previous: {
-        topic?: string;
-        background?: string;
-        consensus?: string[];
-        questions?: string[];
-        changes?: string[];
-    };
-    recent_messages: ScratchpadRefreshSourceMessageInput[];
-    new_messages: ScratchpadRefreshSourceMessageInput[];
+    worklist: ScratchpadRefreshWorklistInput;
+    active_task_compile?: ScratchpadWorkflowSnapshot;
+    messages: ScratchpadRefreshSourceMessageInput[];
+};
+export type ScratchpadWorkflowSnapshot = {
+    topic: string;
+    background_summary: string;
+    current_consensus: string[];
+    open_questions: string[];
+    task_changes: string[];
+};
+export type ScratchpadRefreshWorklistInput = {
+    modules: Array<{
+        name: string;
+        tasks: Array<{
+            title: string;
+            summary?: string;
+            status: WorklistProjection["modules"][number]["tasks"][number]["status"];
+        }>;
+    }>;
 };
 export type ScratchpadRefreshSourceMessageInput = {
     role: "human" | "tutti";
     author_display_name?: string;
     text: string;
-    ref?: string;
 };
 export type ScratchpadRefreshWorkflowContext = {
     workflow_ref: WorkflowInvocationRef;
@@ -68,12 +78,12 @@ export type TaskCompileProposalTask = {
 };
 export type TaskCompileWorkflowInput = {
     workflow_ref: WorkflowInvocationRef;
-    scratchpad: ScratchpadProjection;
+    scratchpad: ScratchpadWorkflowSnapshot;
     worklist: WorklistProjection;
-    clarification?: {
+    clarification_rounds?: Array<{
         request_payload: ClarificationRequestPayload;
-        messages: MessageProjection[];
-    };
+        answer_messages: TaskCompilePromptClarificationMessage[];
+    }>;
 };
 export type TaskCompileWorkflowOutput = {
     decision: "ready";
@@ -103,14 +113,14 @@ export type TaskCompilePromptInput = {
             }>;
         }>;
     };
-    clarification?: {
+    clarification_rounds?: Array<{
         request: {
             title?: string;
             summary: string;
             request: string;
         };
         answer_messages: TaskCompilePromptClarificationMessage[];
-    };
+    }>;
 };
 export type TaskCompilePromptClarificationMessage = {
     role: "human" | "tutti";

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

@@ -28,6 +28,10 @@ export type CliCommand = {
 } | {
     kind: "internal-desktop-open";
     url?: string;
+} | {
+    kind: "internal-package-update-worker";
+} | {
+    kind: "internal-package-update-complete";
 } | {
     kind: "ps";
     manage: boolean;

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

@@ -138,6 +138,17 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
     }
     if (command === "internal") {
         const internalCommand = args.shift();
+        if (internalCommand === "package-update-worker" ||
+            internalCommand === "package-update-complete") {
+            if (args.length > 0) {
+                throw new LaunchError("git_bootstrap_failed", `Internal ${internalCommand} does not accept options`, "Internal commands are managed by Tutti.");
+            }
+            return {
+                kind: internalCommand === "package-update-worker"
+                    ? "internal-package-update-worker"
+                    : "internal-package-update-complete",
+            };
+        }
         if (internalCommand === "console-run") {
             if (args.length > 0) {
                 throw new LaunchError("git_bootstrap_failed", "Internal console-run does not accept options", "Internal commands are managed by Tutti.");

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { dirname, resolve } from "node:path";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
 import { formatCliError, formatCliErrorReason, LaunchError } from "./errors.js";
 import { parseCliArgs, shouldEnsureDesktopIntegrationAutomatically } from "./args.js";
 import { confirmTextFromTty, runBackgroundLaunchCommand, runForegroundLaunchCommand, runInternalHostRunCommand, } from "./launch-command.js";
@@ -9,6 +10,8 @@ import { runArchiveCommand, runDoctorCommand, runForgetCommand, runInviteCommand
 import { readCliVersion } from "./version.js";
 import { ensureDesktopIntegrationAutomatically, parseTuttiDesktopUrl, runDesktopIntegrationCommand, TUTTI_DESKTOP_PROJECTS_URL, TuttiDesktopProtocolError, } from "../desktop-integration/index.js";
 import { ensureLocalConsole, openLocalConsoleBrowser, readLocalConsoleServiceStatus, restartLocalConsoleService, runLocalConsoleProcess, stopLocalConsoleService, } from "../local-console/index.js";
+import { runPackageUpdateCompletionProtocol, runPackageUpdateWorkerProtocol, } from "../local-console/package-update-process.js";
+import { recoverPackageUpdateForConsoleStartup } from "../local-console/package-update-recovery.js";
 const HELP_TEXT = `Usage:
   tutti
   tutti launch [target] [--yes] [--foreground]
@@ -209,13 +212,30 @@ function ensureDesktopIntegrationForConsole() {
         process.stderr.write("Tutti could not update its desktop entry. Run `tutti desktop` for details.\n");
     }
 }
+async function ensureUserLocalConsole(options) {
+    const env = process.env;
+    const entrypointArgument = process.argv[1];
+    if (entrypointArgument !== undefined && entrypointArgument.trim() !== "") {
+        const recovery = await recoverPackageUpdateForConsoleStartup({
+            tuttiHome: resolveTuttiHome(env.TUTTI_HOME, options.cwd),
+            cliEntrypoint: resolve(entrypointArgument),
+            cwd: options.cwd,
+            env,
+            source: options.source,
+        });
+        if (recovery.status === "completed") {
+            return recovery.url;
+        }
+    }
+    return (await ensureLocalConsole({ cwd: options.cwd, env, source: options.source })).url;
+}
 async function runLocalConsoleCommand() {
-    const console = await ensureLocalConsole();
-    if (openLocalConsoleBrowser(console.url)) {
-        process.stdout.write(`Tutti is ready at ${console.endpoint.base_url}/console\n`);
+    const url = await ensureUserLocalConsole({ cwd: process.cwd(), source: "terminal" });
+    if (openLocalConsoleBrowser(url)) {
+        process.stdout.write(`Tutti is ready at ${new URL(url).origin}/console\n`);
         return;
     }
-    process.stdout.write(["Open Tutti in a browser:", console.url, ""].join("\n"));
+    process.stdout.write(["Open Tutti in a browser:", url, ""].join("\n"));
 }
 function desktopResultMessage(result) {
     if (result.status === "installed") {
@@ -239,9 +259,9 @@ function runDesktopCommand(action) {
     return desktopResultMessage(runDesktopIntegrationCommand(action));
 }
 async function runDesktopOpenCommand(value) {
-    const url = value ?? TUTTI_DESKTOP_PROJECTS_URL;
+    const desktopUrl = value ?? TUTTI_DESKTOP_PROJECTS_URL;
     try {
-        parseTuttiDesktopUrl(url);
+        parseTuttiDesktopUrl(desktopUrl);
     }
     catch (error) {
         if (error instanceof TuttiDesktopProtocolError) {
@@ -250,11 +270,9 @@ async function runDesktopOpenCommand(value) {
         throw error;
     }
     const cliEntrypoint = process.argv[1];
-    const console = await ensureLocalConsole({
-        source: "desktop",
-        ...(cliEntrypoint === undefined ? {} : { cwd: dirname(resolve(cliEntrypoint)) }),
-    });
-    if (!openLocalConsoleBrowser(console.url)) {
+    const cwd = cliEntrypoint === undefined ? process.cwd() : dirname(resolve(cliEntrypoint));
+    const url = await ensureUserLocalConsole({ source: "desktop", cwd });
+    if (!openLocalConsoleBrowser(url)) {
         throw new LaunchError("desktop_open_failed", "The Local Console started, but no desktop browser opener is available.", "Run `tutti` from a terminal to print a one-time browser URL.");
     }
 }
@@ -378,6 +396,12 @@ try {
         case "internal-desktop-open":
             await runDesktopOpenCommand(command.url);
             break;
+        case "internal-package-update-worker":
+            await runPackageUpdateWorkerProtocol();
+            break;
+        case "internal-package-update-complete":
+            await runPackageUpdateCompletionProtocol();
+            break;
         case "ps":
             if (command.manage) {
                 await runPsManageCommand({ all: command.all });

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

@@ -1,4 +1,5 @@
 import type { FastifyInstance } from "fastify";
+import type { ExecutionStatusProjection } from "@tutti/shared/schemas/api";
 import { type HostProjectStore } from "../../store/index.js";
 import type { createHostServer } from "../http/create-server.js";
 import type { HostLocalLaunchStatus } from "../http/routes/local-control.js";
@@ -8,6 +9,7 @@ import type { HostRelayConnectionManager } from "./host-relay-connection-manager
 import type { LaunchPreparationResult } from "./launch.js";
 import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
 export declare const HOST_SERVER_VERSION: string;
+export declare function packageUpdateReadinessFromExecutionStatus(execution: Pick<ExecutionStatusProjection, "status" | "active_activity" | "active_activities" | "blocked_by">): "ready" | "busy";
 export type HostServerFactory = typeof createHostServer;
 export type HostServerHandle = {
     app: FastifyInstance;