@xfey/tutti 0.1.16 → 0.1.17

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 !== "ready") {
+    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;

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

@@ -9,54 +9,51 @@ const SHOW_CURSOR = "\u001B[?25h";
 const BLINK_ON = "\u001B[5m";
 const BLINK_OFF = "\u001B[25m";
 const CLEAR = "\u001B[2J\u001B[H";
-const DIVIDER = "----------------------------------------------------------------";
+const FIELD_UNDERLINE = "------------------------------------------------------------";
 function providerSetupCancelled() {
     return new LaunchError("provider_setup_cancelled", "Provider setup cancelled.", "Run the command again when you are ready.");
 }
-function fieldLine(options) {
+function renderFieldInput(options) {
     const value = options.secret && options.value.length > 0 ? "*".repeat(options.value.length) : options.value;
-    return `> ${options.label}: ${value}${BLINK_ON}_${BLINK_OFF}`;
+    return [options.label, `${value}${BLINK_ON}_${BLINK_OFF}`, FIELD_UNDERLINE];
 }
 function renderProviderField(state) {
     if (state.step === "base-url") {
         return [
-            "Step 1 of 2 - Base URL",
-            "Enter the base URL for your OpenAI-compatible provider.",
+            "Step 1/2  Base URL",
+            "OpenAI-compatible Responses API base URL; must expose POST /responses.",
             "",
-            fieldLine({
+            ...renderFieldInput({
                 label: "Base URL",
                 value: state.baseUrl,
             }),
             "",
-            "[Enter] to continue",
+            "[Enter] Continue    [Esc] Cancel",
         ];
     }
     return [
-        "Step 2 of 2 - API Key",
-        "Enter the API key for this provider. It will be stored only in the machine-local Tutti credential store.",
+        "Step 2/2  API Key",
+        "Stored only in the machine-local Tutti credential store.",
         "",
-        fieldLine({
+        ...renderFieldInput({
             label: "API Key",
             value: state.apiKey,
             secret: true,
         }),
         "",
         state.error === undefined
-            ? "[Enter] to validate    [Esc] to edit Base URL"
-            : "[Enter] to retry    [Esc] to edit Base URL",
+            ? "[Enter] Validate    [Esc] Back to Base URL"
+            : "[Enter] Retry    [Esc] Back to Base URL",
     ];
 }
-function renderProviderForm(options) {
+export function renderProviderForm(options) {
     const lines = [
         CLEAR,
         HIDE_CURSOR,
         renderTuttiTerminalLogo({ tty: options.tty === true }),
         "",
         "Provider setup",
-        DIVIDER,
-        "Tutti uses an OpenAI-compatible Responses API provider.",
-        "The base URL should expose POST /responses under the entered URL.",
-        DIVIDER,
+        "Connect a provider compatible with OpenAI's Responses API.",
         "",
         ...renderProviderField(options.state),
         "",
@@ -209,9 +206,7 @@ function renderChecking(frame, tty) {
         renderTuttiTerminalLogo({ tty }),
         "",
         "Provider setup",
-        DIVIDER,
-        "Validating the provider with the configured Responses API endpoint.",
-        DIVIDER,
+        "Validating the configured Responses API endpoint.",
         "",
         `${indicator} Checking provider connection with ${DEFAULT_OPENAI_MODEL}...`,
     ].join("\n");

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

@@ -1,6 +1,7 @@
 import { type ProjectId } from "@tutti/shared/ids";
 import { type FetchLike } from "./host-runtime-endpoint.js";
 import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+import type { LocalControlFetch } from "./local-control-client.js";
 export type RuntimeProjectRow = {
     project_id: ProjectId;
     status: "online" | "stale";
@@ -22,10 +23,18 @@ export declare function runPsManageCommand(options?: {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
 }): Promise<void>;
-export declare function runStopCommand(target?: string): Promise<string>;
+export declare function runStopCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+}): Promise<string>;
 export declare function runInviteCommand(target?: string): Promise<string>;
 export declare function runProviderStatusCommand(target?: string): string;
 export declare function runLogsCommand(target?: string, tailLines?: number): string;
+export declare function runDoctorCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
 export declare function readRuntimeEndpointForProject(tuttiHome: string, projectId: ProjectId): MachineRuntimeEndpointRecord | null;
 export declare function runtimeEndpointPathForProject(tuttiHome: string, projectId: ProjectId): string;
 export declare function projectLocalStoreRoot(tuttiHome: string, projectId: ProjectId): string;

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

@@ -4,16 +4,19 @@ import { emitKeypressEvents } from "node:readline";
 import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 import { redactText } from "@tutti/shared/utils";
 import { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
-import { getHostLogFilePath, getMachineRuntimeEndpointPath, getProjectLocalStoreRoot, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { deleteMachineProjectLocalState, getHostLogFilePath, getMachineRuntimeEndpointPath, getProjectLocalStoreRoot, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
 import { readHostLocalLaunchStatus, readHostLocalProject, readHostLocalProviderConfig, requestHostLocalShutdown, rotateHostLocalInvite, } from "./local-control-client.js";
 import { formatCliErrorReason, LaunchError } from "./errors.js";
-import { resolveExistingProjectContext } from "./project-resolver.js";
+import { resolveManagedProjectContext } from "./project-resolver.js";
 import { formatJoinLinkValidity, renderTerminalQr } from "./terminal-qr.js";
 import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliVersion } from "./version.js";
 const PROJECT_ID_DISPLAY_MIN_LENGTH = 12;
-function resolveProject(target) {
-    return resolveExistingProjectContext({
+function resolveProject(target, options = {}) {
+    return resolveManagedProjectContext({
         ...(target === undefined ? {} : { target }),
+        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+        ...(options.env === undefined ? {} : { env: options.env }),
     });
 }
 function projectIdsFromTuttiHome(tuttiHome) {
@@ -271,18 +274,35 @@ export async function runPsManageCommand(options = {}) {
         stdout.write(SHOW_CURSOR);
     }
 }
-export async function runStopCommand(target) {
-    const project = resolveProject(target);
+export async function runStopCommand(target, options = {}) {
+    const project = resolveProject(target, options);
     const endpoint = project.runtime_endpoint;
     if (endpoint === null) {
+        if (!project.workspace_exists) {
+            deleteMachineProjectLocalState({
+                tuttiHome: project.tutti_home,
+                projectId: project.project_id,
+            });
+            return `Deleted ${project.display_name}; the workspace no longer exists.`;
+        }
         return "Tutti host is not running for this project.";
     }
     try {
-        await requestHostLocalShutdown({ endpoint });
+        await requestHostLocalShutdown({
+            endpoint,
+            ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+        });
     }
     catch (error) {
         throw new LaunchError("existing_server_unhealthy", `Could not stop the host: ${formatCliErrorReason(error)}`, "Run `tutti ps` to inspect the runtime state, or stop the host process manually.");
     }
+    if (!project.workspace_exists) {
+        deleteMachineProjectLocalState({
+            tuttiHome: project.tutti_home,
+            projectId: project.project_id,
+        });
+        return `Stopped and deleted ${project.display_name}; the workspace no longer exists.`;
+    }
     return `Stopped ${project.display_name}.`;
 }
 export async function runInviteCommand(target) {
@@ -339,6 +359,24 @@ export function runLogsCommand(target, tailLines = 120) {
     const lines = readFileSync(logPath, "utf8").split(/\r?\n/u).filter(Boolean).slice(-tailLines);
     return lines.length === 0 ? "Host log is empty." : lines.join("\n");
 }
+export function runDoctorCommand(target, options = {}) {
+    const checks = [];
+    checks.push(`Node: ${process.version}`);
+    checks.push(`Tutti: ${readCliVersion()}`);
+    try {
+        const project = resolveProject(target, options);
+        checks.push(`Project: ${project.display_name}`);
+        checks.push(`Project ID: ${project.project_id}`);
+        checks.push(`Workspace: ${project.workspace_exists ? redactText(project.workspace_root) : "missing"}`);
+        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)}`);
+    }
+    return checks.join("\n");
+}
 export function readRuntimeEndpointForProject(tuttiHome, projectId) {
     return readEndpointFile(tuttiHome, projectId);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",