@xfey/tutti 0.1.16 → 0.1.18

package/dist/collaboration-state/run-recording.js

@@ -29,6 +29,9 @@ export function recordRunResult(db, input) {
         };
         if (input.result.result_kind === "finished") {
             detailResult.outcome = input.result.outcome;
+            if (input.result.user_note_candidate !== undefined) {
+                detailResult.user_note_candidate = input.result.user_note_candidate;
+            }
             detailResult.checks = input.result.checks;
             detailResult.docs = input.result.docs;
             if (input.result.skip_reason_code !== undefined) {

package/dist/collaboration-state/run-results.js

@@ -38,6 +38,9 @@ export function mapRunResultRow(row) {
         result_kind: "finished",
         outcome: result.outcome === "failed" ? "failed" : "completed",
         summary: typeof result.summary === "string" ? result.summary : "",
+        ...(typeof result.user_note_candidate === "string"
+            ? { user_note_candidate: result.user_note_candidate }
+            : {}),
         checks: result.checks === "failed" || result.checks === "skipped" ? result.checks : "passed",
         docs: result.docs === "checked_no_change" ||
             result.docs === "not_checked" ||

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

@@ -120,6 +120,7 @@ export type RecordRunResultInput = {
         summary: string;
         checks: "passed" | "failed" | "skipped";
         docs: "updated" | "checked_no_change" | "not_checked" | "sync_deferred";
+        user_note_candidate?: string;
         skip_reason_code?: TaskDetailResultProjection["skip_reason_code"];
         skip_reason_summary?: string;
         external_side_effects?: TaskDetailResultProjection["external_side_effects"];

package/dist/control-plane/index.js

@@ -313,6 +313,9 @@ export class Phase5ControlPlane {
         emitWorklistCompletedFeedback({
             store: this.store,
             events: this.events,
+            ...(this.projectContext === undefined
+                ? {}
+                : { workspaceRoot: this.projectContext.workspaceRoot }),
             now: this.now,
         });
         this.maybeStartContextSyncAfterWorklistCompletion();

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/control-plane/types.d.ts

@@ -123,6 +123,7 @@ export type RunPipelineResult = RunPipelineResultMetadata & ({
     result_kind: "finished";
     outcome: "completed" | "failed";
     summary: string;
+    user_note_candidate?: string;
     checks: "passed" | "failed" | "skipped";
     docs: "updated" | "checked_no_change" | "not_checked" | "sync_deferred";
     skip_reason_code?: NonNullable<TaskDetailProjection["detail"]["result"]["skip_reason_code"]>;

package/dist/control-plane/worklist-terminal-feedback.d.ts

@@ -5,6 +5,7 @@ import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js
 type EmitWorklistFeedbackInput = {
     store: HostProjectStore;
     events: WorkspaceEventBus;
+    workspaceRoot?: string;
     now: () => Date;
 };
 export declare function emitWorklistCompletedFeedback(input: EmitWorklistFeedbackInput): MessageProjection | null;

package/dist/control-plane/worklist-terminal-feedback.js

@@ -1,3 +1,4 @@
+import { readViewerFile, referenceFileSourceForPath, referenceMediaTypeForPath, referenceTuttiGroupForPath, } from "../workspace-ops/index.js";
 import { createMainChatAgentMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readTaskDetailProjection, readWorklistProjection, } from "../collaboration-state/index.js";
 import { mainChatInvalidates } from "./invalidations.js";
 const BODY_ITEM_LIMIT = 12;
@@ -27,6 +28,100 @@ function feedbackItemFromEntry(entry) {
     }
     return item;
 }
+function userNoteCandidateFromEntry(entry) {
+    const trimmed = (entry.detail?.detail.result.user_note_candidate ?? "").trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+function normalizedUserNoteLine(value) {
+    return value.replace(/\s+/gu, " ").trim();
+}
+function finalNoteForCompletedEntries(entries) {
+    const notes = entries
+        .map(userNoteCandidateFromEntry)
+        .filter((note) => note !== undefined)
+        .map(normalizedUserNoteLine)
+        .filter((note) => note.length > 0);
+    if (notes.length === 0) {
+        return undefined;
+    }
+    if (entries.length === 1) {
+        return notes[0];
+    }
+    return `Completed work across ${entries.length} tasks: ${notes.join(" ")}`;
+}
+function shouldInspectGeneratedFiles(entry) {
+    const result = entry.detail?.detail.result;
+    return (result?.result_kind === "finished" &&
+        result.outcome === "completed" &&
+        result.promotion?.status === "promoted" &&
+        Array.isArray(result.changed_paths));
+}
+function generatedFileProjection(file) {
+    const projection = {
+        path: file.path,
+        name: file.name,
+        size_bytes: file.size_bytes,
+    };
+    const group = referenceTuttiGroupForPath(file.path);
+    if (group !== undefined) {
+        projection.group = group;
+    }
+    const mediaType = referenceMediaTypeForPath(file.path);
+    if (mediaType !== undefined) {
+        projection.media_type = mediaType;
+    }
+    return projection;
+}
+function readGeneratedFile(input) {
+    if (referenceFileSourceForPath(input.path) !== "tutti_output") {
+        return null;
+    }
+    try {
+        const file = readViewerFile({
+            workspaceRoot: input.workspaceRoot,
+            path: input.path,
+            maxBytes: 1,
+            now: input.now,
+        });
+        return generatedFileProjection(file.file);
+    }
+    catch {
+        return null;
+    }
+}
+function generatedFilesForCompletedEntries(input, entries) {
+    const workspaceRoot = input.workspaceRoot;
+    if (workspaceRoot === undefined) {
+        return [];
+    }
+    const paths = new Set();
+    for (const entry of entries) {
+        if (!shouldInspectGeneratedFiles(entry)) {
+            continue;
+        }
+        for (const path of entry.detail?.detail.result.changed_paths ?? []) {
+            if (referenceFileSourceForPath(path) === "tutti_output") {
+                paths.add(path);
+            }
+        }
+    }
+    return [...paths]
+        .map((path) => readGeneratedFile({
+        workspaceRoot,
+        path,
+        now: input.now,
+    }))
+        .filter((file) => file !== null)
+        .sort((left, right) => {
+        const groupOrder = (left.group ?? "").localeCompare(right.group ?? "", "en", {
+            sensitivity: "base",
+        });
+        if (groupOrder !== 0) {
+            return groupOrder;
+        }
+        return left.name.localeCompare(right.name, "en", { sensitivity: "base" });
+    });
+}
 function feedbackCounters(entries) {
     const completed = entries.filter((entry) => entry.task.status === "done").length;
     const failed = entries.filter((entry) => entry.task.status === "failed").length;
@@ -51,6 +146,16 @@ function taskCountLabel(count) {
 }
 function markdownFallback(feedback) {
     const lines = [feedback.title, ""];
+    if (feedback.final_note !== undefined && feedback.final_note.trim().length > 0) {
+        lines.push(feedback.final_note.trim(), "");
+    }
+    if (feedback.generated_files !== undefined && feedback.generated_files.length > 0) {
+        lines.push("Generated files:");
+        for (const file of feedback.generated_files) {
+            lines.push(`- ${file.name}`);
+        }
+        lines.push("");
+    }
     const visibleItems = feedback.items.slice(0, BODY_ITEM_LIMIT);
     for (const item of visibleItems) {
         const prefix = item.status === "done" ? "- Done" : "- Failed";
@@ -102,6 +207,8 @@ export function emitWorklistCompletedFeedback(input) {
         return null;
     }
     const items = newCompletedEntries.map(feedbackItemFromEntry);
+    const finalNote = finalNoteForCompletedEntries(newCompletedEntries);
+    const generatedFiles = generatedFilesForCompletedEntries(input, newCompletedEntries);
     const feedback = {
         kind: "worklist_terminal",
         status: "completed",
@@ -110,6 +217,8 @@ export function emitWorklistCompletedFeedback(input) {
         feedback_key: completedFeedbackKey(items),
         counters: feedbackCounters(newCompletedEntries),
         items,
+        ...(finalNote === undefined ? {} : { final_note: finalNote }),
+        ...(generatedFiles.length === 0 ? {} : { generated_files: generatedFiles }),
     };
     return publishFeedbackMessage(input, feedback);
 }

package/dist/run-pipeline/openai.js

@@ -332,6 +332,9 @@ async function runTaskAttempt(options, input) {
         if (changedPaths.length === 0 && taskOutput.decision === "completed_no_repo_changes") {
             return completedWithoutRepoChanges({
                 summary: taskOutput.summary,
+                ...(taskOutput.user_note_candidate === undefined
+                    ? {}
+                    : { userNoteCandidate: taskOutput.user_note_candidate }),
             });
         }
         if (changedPaths.length === 0) {
@@ -424,6 +427,9 @@ async function runTaskAttempt(options, input) {
                 checks,
                 completion: "Promotion complete.",
             }),
+            ...(taskOutput.user_note_candidate === undefined
+                ? {}
+                : { user_note_candidate: taskOutput.user_note_candidate }),
             checks: checkStatus(checks),
             docs,
             ...checkSkipFields(checks),

package/dist/run-pipeline/promotion-reconcile.d.ts

@@ -1,12 +1,12 @@
 import type { RunPipelineInput, RunPipelineResult } from "../control-plane/index.js";
 import { type ResultCommit, type RunWorkspaceHandle } from "../workspace-ops/index.js";
 import type { OpenAiRunPipelineRunnerOptions } from "./openai.js";
-import type { TaskRunOutput } from "./task-run-output.js";
+import type { CompletedNoRepoChangesTaskRunOutput, CompletedTaskRunOutput } from "./task-run-output.js";
 export declare function runPromotionReconcile(input: {
     options: OpenAiRunPipelineRunnerOptions;
     pipelineInput: RunPipelineInput;
     runHandle: RunWorkspaceHandle;
-    taskOutput: TaskRunOutput;
+    taskOutput: CompletedTaskRunOutput | CompletedNoRepoChangesTaskRunOutput;
     sourceCommit: ResultCommit;
     changedPaths: string[];
 }): Promise<RunPipelineResult>;

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

@@ -93,6 +93,9 @@ export async function runPromotionReconcile(input) {
                 checks,
                 completion: "Promotion reconciled and complete.",
             }),
+            ...(input.taskOutput.user_note_candidate === undefined
+                ? {}
+                : { user_note_candidate: input.taskOutput.user_note_candidate }),
             checks: checkStatus(checks),
             docs,
             ...checkSkipFields(checks),

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

@@ -35,5 +35,6 @@ export declare function failedBeforeChecks(input: {
 }): RunPipelineResult;
 export declare function completedWithoutRepoChanges(input: {
     summary: string;
+    userNoteCandidate?: string;
 }): RunPipelineResult;
 //# sourceMappingURL=result-projections.d.ts.map

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

@@ -104,6 +104,9 @@ export function completedWithoutRepoChanges(input) {
         result_kind: "finished",
         outcome: "completed",
         summary: input.summary,
+        ...(input.userNoteCandidate === undefined
+            ? {}
+            : { user_note_candidate: input.userNoteCandidate }),
         checks: "skipped",
         docs: "checked_no_change",
         skip_reason_code: "validation_not_applicable",

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

@@ -5,10 +5,12 @@ export type InitialTaskRunOutput = {
     result: {
         completed: {
             summary: string;
+            user_note_candidate: string | null;
         };
     } | {
         completed_no_repo_changes: {
             summary: string;
+            user_note_candidate: string | null;
         };
     } | {
         needs_human: ClarificationRequestPayload;
@@ -18,13 +20,17 @@ export type InitialTaskRunOutput = {
         };
     };
 };
-export type TaskRunOutput = {
+export type CompletedTaskRunOutput = {
     decision: "completed";
     summary: string;
-} | {
+    user_note_candidate?: string;
+};
+export type CompletedNoRepoChangesTaskRunOutput = {
     decision: "completed_no_repo_changes";
     summary: string;
-} | {
+    user_note_candidate?: string;
+};
+export type TaskRunOutput = CompletedTaskRunOutput | CompletedNoRepoChangesTaskRunOutput | {
     decision: "needs_human";
     summary: string;
     clarification_request_payload: ClarificationRequestPayload;

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

@@ -22,10 +22,13 @@ export const TASK_RUN_OUTPUT_SCHEMA = {
                     properties: {
                         completed: {
                             type: "object",
-                            required: ["summary"],
+                            required: ["summary", "user_note_candidate"],
                             additionalProperties: false,
                             properties: {
                                 summary: { type: "string" },
+                                user_note_candidate: {
+                                    anyOf: [{ type: "string" }, { type: "null" }],
+                                },
                             },
                         },
                     },
@@ -37,10 +40,13 @@ export const TASK_RUN_OUTPUT_SCHEMA = {
                     properties: {
                         completed_no_repo_changes: {
                             type: "object",
-                            required: ["summary"],
+                            required: ["summary", "user_note_candidate"],
                             additionalProperties: false,
                             properties: {
                                 summary: { type: "string" },
+                                user_note_candidate: {
+                                    anyOf: [{ type: "string" }, { type: "null" }],
+                                },
                             },
                         },
                     },
@@ -96,6 +102,16 @@ function isSummaryRecord(value) {
         Object.keys(value).every((key) => key === "summary") &&
         typeof value.summary === "string");
 }
+function isCompletedRecord(value) {
+    return (isRecord(value) &&
+        Object.keys(value).every((key) => key === "summary" || key === "user_note_candidate") &&
+        typeof value.summary === "string" &&
+        (typeof value.user_note_candidate === "string" || value.user_note_candidate === null));
+}
+function normalizedUserNoteCandidate(value) {
+    const trimmed = (value ?? "").trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
 export function isInitialTaskRunOutput(value) {
     if (!isRecord(value) || !isRecord(value.result) || Object.keys(value).length !== 1) {
         return false;
@@ -105,10 +121,10 @@ export function isInitialTaskRunOutput(value) {
         return false;
     }
     if ("completed" in value.result) {
-        return isSummaryRecord(value.result.completed);
+        return isCompletedRecord(value.result.completed);
     }
     if ("completed_no_repo_changes" in value.result) {
-        return isSummaryRecord(value.result.completed_no_repo_changes);
+        return isCompletedRecord(value.result.completed_no_repo_changes);
     }
     if ("needs_human" in value.result) {
         return isTaskRunClarificationRequestPayload(value.result.needs_human);
@@ -120,15 +136,19 @@ export function isInitialTaskRunOutput(value) {
 }
 export function normalizeTaskRunOutput(output) {
     if ("completed" in output.result) {
+        const userNoteCandidate = normalizedUserNoteCandidate(output.result.completed.user_note_candidate);
         return {
             decision: "completed",
             summary: output.result.completed.summary,
+            ...(userNoteCandidate === undefined ? {} : { user_note_candidate: userNoteCandidate }),
         };
     }
     if ("completed_no_repo_changes" in output.result) {
+        const userNoteCandidate = normalizedUserNoteCandidate(output.result.completed_no_repo_changes.user_note_candidate);
         return {
             decision: "completed_no_repo_changes",
             summary: output.result.completed_no_repo_changes.summary,
+            ...(userNoteCandidate === undefined ? {} : { user_note_candidate: userNoteCandidate }),
         };
     }
     if ("needs_human" in output.result) {

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