@interf/compiler 0.9.4 → 0.9.5

package/dist/packages/local-service/lib/schema.js

@@ -22,7 +22,13 @@ export const LocalServiceHealthSchema = z.object({
     started_at: z.string().min(1).optional(),
     package_version: z.string().min(1).optional(),
 }).strict();
-export const LocalServiceInstancePointerSchema = z.object({
+export const LocalServiceErrorSchema = z.object({
+    error: z.object({
+        message: z.string().min(1),
+        code: z.string().min(1).optional(),
+    }).strict(),
+}).strict();
+export const LocalServicePointerSchema = z.object({
     service_url: z.string().min(1),
     host: LocalServiceHostSchema,
     port: LocalServicePortSchema,
@@ -66,6 +72,7 @@ export const MethodResourceSchema = z.object({
     source_kind: z.enum(["builtin", "local"]).default("local"),
     built_in: z.boolean().default(false),
     active_for_preparations: z.array(PreparationNameSchema).default([]),
+    output_paths: z.array(z.string().min(1)).default([]),
     stages: z.array(z.object({
         id: z.string().min(1),
         label: z.string().min(1),
@@ -99,12 +106,9 @@ export const CompileRunResourceSchema = z.object({
     run: CompileRunSchema,
 }).strict();
 export const LocalJobTypeSchema = z.enum([
-    "preparation-setup",
     "readiness-check-draft",
     "method-authoring",
     "method-improvement",
-    "compile",
-    "test",
 ]);
 export const LocalJobStatusSchema = z.enum([
     "queued",
@@ -116,7 +120,7 @@ export const LocalJobStatusSchema = z.enum([
 export const LocalRunHandlerResultSchema = z.object({
     ok: z.boolean(),
     error: z.string().min(1).optional(),
-    comparison: ReadinessCheckRunSchema.nullable().optional(),
+    readiness_run: ReadinessCheckRunSchema.nullable().optional(),
 }).strict();
 export const LocalJobAgentSchema = z.object({
     name: z.string().min(1),
@@ -174,6 +178,80 @@ export const LocalJobRunCreateRequestSchema = z.object({
 export const PreparationSetupCreateRequestSchema = z.object({
     preparation: SourcePreparationConfigSchema,
     prepare_after_setup: z.boolean().default(false),
+    setup_mode: z.enum(["create", "select-method"]).default("create"),
+}).strict();
+export const PreparationSetupResultSchema = z.object({
+    kind: z.literal("interf-preparation-setup-result"),
+    version: z.literal(1),
+    operation: z.enum(["create", "select-method"]),
+    preparation: PreparationNameSchema,
+    method: MethodIdSchema,
+    source_folder_path: z.string().min(1),
+    config_path: z.string().min(1),
+    portable_context_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
+    submitted_run_id: z.string().min(1).nullable().optional(),
+    submitted_run_type: z.literal("compile-run").nullable().optional(),
+}).strict();
+export const MethodChangeCreateRequestSchema = z.discriminatedUnion("operation", [
+    z.object({
+        action_type: z.literal("method-change").optional(),
+        operation: z.literal("duplicate"),
+        method: MethodIdSchema,
+        new_method_id: MethodIdSchema,
+        label: z.string().min(1).optional(),
+        hint: z.string().min(1).optional(),
+    }).strict(),
+    z.object({
+        action_type: z.literal("method-change").optional(),
+        operation: z.literal("remove"),
+        method: MethodIdSchema,
+        confirmation: MethodIdSchema,
+    }).strict(),
+]);
+export const MethodChangeResultSchema = z.object({
+    kind: z.literal("interf-method-change-result"),
+    version: z.literal(1),
+    operation: z.enum(["duplicate", "remove"]),
+    method: MethodIdSchema,
+    new_method_id: MethodIdSchema.nullable().optional(),
+    updated_preparations: z.array(PreparationNameSchema).default([]),
+    method_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
+export const PreparationChangeCreateRequestSchema = z.discriminatedUnion("operation", [
+    z.object({
+        action_type: z.literal("preparation-change").optional(),
+        operation: z.literal("remove"),
+        preparation: PreparationNameSchema,
+        confirmation: PreparationNameSchema,
+    }).strict(),
+]);
+export const PreparationChangeResultSchema = z.object({
+    kind: z.literal("interf-preparation-change-result"),
+    version: z.literal(1),
+    operation: z.literal("remove"),
+    preparation: PreparationNameSchema,
+    config_path: z.string().min(1),
+    portable_context_path: z.string().min(1),
+    portable_context_retained: z.boolean(),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
+export const ResetRequestSchema = z.object({
+    preparation: PreparationNameSchema,
+    scope: z.enum(["compile", "all"]),
+}).strict();
+export const ResetResultSchema = z.object({
+    kind: z.literal("interf-reset-result"),
+    version: z.literal(1),
+    preparation: PreparationNameSchema,
+    scope: z.enum(["compile", "all"]),
+    portable_context_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
 }).strict();
 export const ReadinessCheckDraftCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
@@ -251,40 +329,12 @@ export const TestRunResourceSchema = z.object({
     portable_context_path: z.string().min(1).nullable(),
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
-    comparison: ReadinessCheckRunSchema.nullable(),
+    readiness_run: ReadinessCheckRunSchema.nullable(),
     readiness: ReadinessStateSchema.nullable().optional(),
     events: z.array(InterfRunEventSchema).default([]),
     error: z.string().min(1).nullable().optional(),
 }).strict();
 export const RunObservabilityResourceSchema = RunObservabilitySchema;
-export const RunCreateRequestSchema = z.discriminatedUnion("run_type", [
-    z.object({
-        run_type: z.literal("compile"),
-        preparation: PreparationNameSchema,
-        method: MethodIdSchema.optional(),
-        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-        max_loops: SourceCompiledMaxLoopsSchema.optional(),
-        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
-    }).strict(),
-    z.object({
-        run_type: z.literal("prepare"),
-        preparation: PreparationNameSchema,
-        method: MethodIdSchema.optional(),
-        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-        max_loops: SourceCompiledMaxLoopsSchema.optional(),
-        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
-    }).strict(),
-    z.object({
-        run_type: z.literal("test"),
-        preparation: PreparationNameSchema,
-        mode: TestRunModeSchema.default("both"),
-    }).strict(),
-    z.object({
-        run_type: z.literal("check"),
-        preparation: PreparationNameSchema,
-        mode: TestRunModeSchema.default("both"),
-    }).strict(),
-]);
 export const LocalExecutorStatusSchema = z.object({
     kind: z.literal("interf-local-executor-status"),
     version: z.literal(1),
@@ -298,10 +348,20 @@ export const LocalExecutorSelectRequestSchema = z.object({
     agent: z.string().min(1),
 }).strict();
 export const ActionProposalTypeSchema = z.enum([
+    "clarification",
+    "readiness-check-draft",
+    "method-authoring",
+    "method-improvement",
+    "compile",
+    "test",
+]);
+export const ActionProposalPlanActionTypeSchema = z.enum([
     "clarification",
     "preparation-setup",
+    "preparation-change",
     "readiness-check-draft",
     "method-authoring",
+    "method-change",
     "method-improvement",
     "compile",
     "test",
@@ -314,13 +374,22 @@ export const ActionProposalStatusSchema = z.enum([
     "submitted",
     "failed",
 ]);
+export const ActionClientOriginSchema = z.enum([
+    "ui-chat",
+    "cli",
+    "agent-cli",
+    "mcp",
+    "service",
+    "unknown",
+]);
 export const ActionProposalCreateRequestSchema = z.object({
     message: z.string().min(1),
     preparation: PreparationNameSchema.optional(),
+    client_origin: ActionClientOriginSchema.default("unknown"),
     values: JsonObjectSchema.optional(),
 }).strict();
 export const ActionProposalPlanSchema = z.object({
-    action_type: ActionProposalTypeSchema,
+    action_type: ActionProposalPlanActionTypeSchema,
     preparation: PreparationNameSchema.optional(),
     method: MethodIdSchema.optional(),
     values: JsonObjectSchema.optional(),
@@ -350,6 +419,7 @@ const ActionProposalResourceBaseSchema = z.object({
     message: z.string().min(1),
     preparation: PreparationNameSchema.nullable().optional(),
     method: MethodIdSchema.nullable().optional(),
+    client_origin: ActionClientOriginSchema.default("unknown"),
     created_at: z.string().min(1),
     updated_at: z.string().min(1),
     proposed_by_executor: LocalJobAgentSchema.nullable().optional(),
@@ -367,10 +437,6 @@ export const ActionProposalResourceSchema = z.discriminatedUnion("action_type",
         action_type: z.literal("compile"),
         request: CompileRunCreateRequestSchema,
     }).strict(),
-    ActionProposalResourceBaseSchema.extend({
-        action_type: z.literal("preparation-setup"),
-        request: PreparationSetupCreateRequestSchema,
-    }).strict(),
     ActionProposalResourceBaseSchema.extend({
         action_type: z.literal("test"),
         request: TestRunCreateRequestSchema,
@@ -425,6 +491,15 @@ export const LocalServiceDiscoverySchema = z.object({
         source_files: z.string().min(1),
         workspace_files: z.string().min(1),
         action_proposals: z.string().min(1),
+        preparation_setups: z.string().min(1),
+        preparation_changes: z.string().min(1),
+        method_changes: z.string().min(1),
+        readiness_check_drafts: z.string().min(1),
+        method_authoring_runs: z.string().min(1),
+        method_improvement_runs: z.string().min(1),
+        compile_runs: z.string().min(1),
+        test_runs: z.string().min(1),
+        reset: z.string().min(1),
         executor: z.string().min(1),
     }).strict(),
 }).strict();

package/dist/packages/local-service/native-run-handlers.d.ts

@@ -0,0 +1,23 @@
+import type { MethodExecutionProfile, MethodExecutor } from "../agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { StageShellRetentionMode } from "../compiler/method-runs.js";
+import type { RunEventSink } from "../execution/events.js";
+import type { LocalServiceRunHandlers } from "./runtime.js";
+export interface NativeLocalServiceRunHandlerOptions {
+    executor?: MethodExecutor;
+    testExecutor?: MethodExecutor;
+}
+export declare function runConfiguredCompiledCompile(options: {
+    executor: MethodExecutor;
+    testExecutor?: MethodExecutor | null;
+    compiledPath: string;
+    sourcePath: string;
+    compiledConfig: SourcePreparationConfig | null;
+    executionProfile?: MethodExecutionProfile;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+    preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<boolean>;
+export declare function createNativeLocalServiceRunHandlers(options?: NativeLocalServiceRunHandlerOptions): Pick<LocalServiceRunHandlers, "planActionProposal" | "createCompileRun" | "createTestRun" | "createReadinessCheckDraft" | "createMethodAuthoringRun">;

package/dist/{cli/commands/compile-controller.js → packages/local-service/native-run-handlers.js}

@@ -2,16 +2,22 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
-import { readInterfConfig } from "../../packages/project-model/interf.js";
-import { clearCompiledRuntimeDerivedArtifacts, } from "../../packages/compiler/reset.js";
-import { formatActiveCompiledMethodStageStep, resolveRequiredCompiledMethodFromConfig, } from "../../packages/method-package/method-definitions.js";
-import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../../packages/project-model/source-config.js";
-import { runMethodImprovementLoop } from "../../packages/method-authoring/method-improvement.js";
-import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "../../packages/compiler/compiled-paths.js";
-import { readCompiledSchemaFile } from "../../packages/compiler/compiled-schema.js";
-import { initializeCompiledRuntimeState } from "../../packages/compiler/state.js";
-import { compileCompiledWithReporter } from "./compiled-flow.js";
-import { printSavedTestOutcome, readinessPassRate, runSavedCompiledTest, } from "./test-flow.js";
+import { compileCompiled, } from "../compiler/method-runs.js";
+import { readInterfConfig } from "../project-model/interf.js";
+import { resolveLocalExecutor, } from "../agents/lib/executors.js";
+import { formatMethodExecutionProfile } from "../agents/lib/execution-profile.js";
+import { clearCompiledRuntimeDerivedArtifacts, } from "../compiler/reset.js";
+import { formatActiveCompiledMethodStageStep, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
+import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../project-model/source-config.js";
+import { runMethodImprovementLoop } from "../method-authoring/method-improvement.js";
+import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "../compiler/compiled-paths.js";
+import { readCompiledSchemaFile } from "../compiler/compiled-schema.js";
+import { initializeCompiledRuntimeState } from "../compiler/state.js";
+import { readinessPassRate, runReadinessChecksForExecutor, runSavedPortableContextCheck, } from "../testing/readiness-check-run.js";
+import { runMethodAuthoringDraft, } from "../method-authoring/method-authoring.js";
+import { draftReadinessChecks, } from "./readiness-check-draft.js";
+import { planActionProposalWithExecutor, } from "./action-planner.js";
+import { ActionProposalPlanSchema, } from "./lib/schema.js";
 function printCompileFailure(compiledPath, failedStage) {
     resolveRequiredCompiledMethodFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
     let failedStageLabel = failedStage ? `Stage "${failedStage}"` : "Compile";
@@ -26,6 +32,55 @@ function printCompileFailure(compiledPath, failedStage) {
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
+async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
+    console.log();
+    console.log(chalk.bold(`  ${options.heading ?? "Building Portable Context..."}`));
+    const profileLabel = formatMethodExecutionProfile(executor.executionProfile);
+    if (profileLabel) {
+        console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
+    }
+    console.log();
+    const reporter = {
+        line: (message) => console.log(chalk.dim(`  ${message}`)),
+        blankLine: () => console.log(),
+    };
+    const result = await compileCompiled({
+        executor,
+        compiledPath,
+        reporter,
+        preserveStageShells: options.preserveStageShells,
+        runId: options.runId,
+        events: options.events,
+    });
+    if (!result.ok)
+        return result;
+    console.log();
+    console.log(chalk.green(`  ${options.successMessage ?? "Portable Context ready."}`));
+    return result;
+}
+function printSavedReadinessOutcome(prefix, outcome) {
+    const color = outcome.result.ok ? chalk.green : chalk.red;
+    const status = outcome.result.ok ? chalk.green("PASS") : chalk.red("FAIL");
+    console.log(chalk.bold(`  ${prefix}`));
+    console.log();
+    console.log(color(`  ${status} ${outcome.result.passedCases}/${outcome.result.totalCases} readiness checks`));
+    console.log();
+    for (const [index, caseResult] of outcome.result.caseResults.entries()) {
+        const caseStatus = caseResult.ok ? chalk.green("PASS") : chalk.red("FAIL");
+        console.log(`  ${caseStatus} Check ${index + 1}`);
+        console.log(chalk.dim(`       ${caseResult.question}`));
+        const failedChecks = caseResult.checks.filter((entry) => !entry.ok).slice(0, 3);
+        for (const failedCheck of failedChecks) {
+            console.log(chalk.dim(`       Failed criterion: ${failedCheck.label}: ${failedCheck.detail}`));
+        }
+    }
+    console.log();
+    if (outcome.result.sandbox_path) {
+        console.log(chalk.dim(`  Preserved sandbox: ${outcome.result.sandbox_path}`));
+        console.log();
+    }
+    console.log(chalk.dim(`  Saved run: ${outcome.displayRunPath ?? outcome.runPath}`));
+}
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
@@ -107,12 +162,11 @@ async function runMethodVariation(options) {
                     fatalError: null,
                 };
             }
-            const outcome = await runSavedCompiledTest({
+            const outcome = await runSavedPortableContextCheck({
                 sourcePath: options.sourcePath,
                 preparationConfig: options.compiledConfig,
                 executor: options.testExecutor,
-                executionProfile: options.executionProfile,
-                compiledPath: options.compiledPath,
+                portableContextPath: options.compiledPath,
                 preserveSandboxes: options.preserveStageShells === "always" ? "always" : "on-failure",
             });
             if (!outcome) {
@@ -123,11 +177,11 @@ async function runMethodVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved Portable Context comparison after compile.",
+                    fatalError: "Could not run saved readiness checks against the Portable Context after prepare.",
                 };
             }
             console.log();
-            printSavedTestOutcome(`${options.variationLabel} · attempt ${attempt}/${options.maxAttempts}`, outcome);
+            printSavedReadinessOutcome(`${options.variationLabel} · attempt ${attempt}/${options.maxAttempts}`, outcome);
             if (!bestOutcome || testScore(outcome) > testScore(bestOutcome)) {
                 if (bestSnapshotPath) {
                     rmSync(bestSnapshotPath, { recursive: true, force: true });
@@ -185,7 +239,7 @@ function summarizeMethodVariation(options) {
         : options.result.bestOutcome
             ? `Best result: ${passedChecks}/${totalChecks} readiness checks passed.`
             : options.result.failedStage
-                ? `Compile failed at stage ${options.result.failedStage} before any saved comparison result.`
+                ? `Prepare failed at stage ${options.result.failedStage} before any saved readiness result.`
                 : "Method variation did not produce a passing result.";
     return {
         variation: options.variation,
@@ -219,10 +273,10 @@ function printPostCompileNextStep(options) {
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf test` if you also want a source files versus Portable Context comparison."));
+        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf test` if you also want readiness evidence for source files and Portable Context."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to compare source files and Portable Context."));
+    console.log(chalk.dim("  Next: run `interf test` to collect readiness evidence for source files and Portable Context."));
 }
 function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -300,7 +354,7 @@ export async function runConfiguredCompiledCompile(options) {
         const compiledConfig = options.compiledConfig
             ?? loadCompiledPreparationConfig(options.compiledPath)
             ?? {
-                name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
+                name: readInterfConfig(options.compiledPath)?.name ?? "preparation",
                 path: "./source-folder",
                 checks: [],
             };
@@ -443,3 +497,133 @@ export async function runConfiguredCompiledCompile(options) {
         }
     }
 }
+function resolveHandlerExecutor(configured) {
+    if (configured)
+        return configured;
+    const resolved = resolveLocalExecutor({ preflight: true });
+    if (!resolved.executor) {
+        throw new Error(resolved.error ?? "No local agent detected.");
+    }
+    return resolved.executor;
+}
+export function createNativeLocalServiceRunHandlers(options = {}) {
+    return {
+        async planActionProposal(request, context) {
+            const resolved = options.executor
+                ? { executor: options.executor, error: null }
+                : resolveLocalExecutor({ preflight: true });
+            if (!resolved.executor) {
+                return ActionProposalPlanSchema.parse({
+                    action_type: "clarification",
+                    preparation: request.preparation,
+                    assistant_message: resolved.error ?? "No local agent detected for action planning.",
+                });
+            }
+            return planActionProposalWithExecutor({
+                request,
+                context,
+                executor: resolved.executor,
+            });
+        },
+        async createCompileRun(request, context) {
+            const executor = resolveHandlerExecutor(options.executor);
+            const testExecutor = resolveHandlerExecutor(options.testExecutor ?? options.executor);
+            const ok = await runConfiguredCompiledCompile({
+                executor,
+                testExecutor,
+                compiledPath: context.compiledPath,
+                sourcePath: context.sourcePath,
+                compiledConfig: context.preparationConfig,
+                maxAttemptsOverride: request.max_attempts ?? null,
+                maxLoopsOverride: request.max_loops ?? null,
+                preserveStageShells: request.preserve_stage_shells,
+                runId: context.runId,
+                events: context.events,
+            });
+            return { ok };
+        },
+        async createTestRun(request, context) {
+            const executor = resolveHandlerExecutor(options.testExecutor ?? options.executor);
+            const result = await runReadinessChecksForExecutor({
+                sourcePath: context.sourcePath,
+                preparationConfig: context.preparationConfig,
+                portableContextPath: context.compiledPath,
+                mode: request.mode,
+                executor,
+            });
+            const missingSourceFiles = (request.mode === "raw" || request.mode === "both") && !result.rawOutcome;
+            const missingPortableContext = (request.mode === "compiled" || request.mode === "both") && !result.compiledOutcome;
+            if (missingSourceFiles || missingPortableContext) {
+                return {
+                    ok: false,
+                    readiness_run: result.readinessRun,
+                    error: missingPortableContext
+                        ? "Portable Context is not ready for readiness checks."
+                        : "Source files are not ready for readiness checks.",
+                };
+            }
+            return {
+                ok: true,
+                readiness_run: result.readinessRun,
+            };
+        },
+        async createReadinessCheckDraft(request, context) {
+            const executor = resolveHandlerExecutor(options.executor);
+            context.emit({
+                type: "log.appended",
+                step_id: "agent-draft",
+                message: `Using ${executor.displayName} to draft readiness checks.`,
+            });
+            const drafted = await draftReadinessChecks({
+                preparationName: request.preparation,
+                sourceFolderPath: request.source_folder_path,
+                about: request.about,
+                executor,
+                targetCount: request.target_count,
+                onStatus: (line) => context.emit({
+                    type: "log.appended",
+                    step_id: "agent-draft",
+                    message: line,
+                }),
+            });
+            if (!drafted.checks) {
+                throw new Error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
+            }
+            return {
+                checks: drafted.checks,
+            };
+        },
+        async createMethodAuthoringRun(request, context) {
+            const executor = resolveHandlerExecutor(options.executor);
+            context.emit({
+                type: "log.appended",
+                step_id: "draft-package",
+                message: `Using ${executor.displayName} for Method authoring.`,
+            });
+            const result = await runMethodAuthoringDraft({
+                sourcePath: context.sourcePath,
+                sourceFolderPath: request.source_folder_path,
+                baseMethodId: request.reference_method_id ?? request.base_method_id,
+                methodId: request.method_id,
+                label: request.label,
+                hint: request.hint,
+                taskPrompt: request.task_prompt,
+                checks: request.checks,
+                executor,
+                onStatus: (line) => context.emit({
+                    type: "log.appended",
+                    step_id: "draft-package",
+                    message: line,
+                }),
+            });
+            return {
+                status: result.status,
+                changed: result.changed,
+                summary: result.summary,
+                validation: result.validation,
+                method_path: result.methodPath,
+                shell_path: result.shellPath,
+            };
+        },
+    };
+}

package/dist/{cli/commands/check-draft.d.ts → packages/local-service/readiness-check-draft.d.ts}

@@ -1,5 +1,5 @@
-import type { MethodExecutor } from "../../packages/agents/lib/executors.js";
-import type { SourceReadinessCheck } from "../../packages/project-model/lib/schema.js";
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
 export declare function buildReadinessCheckDraftPrompt(options: {
     preparationName: string;
     sourceFolderPath: string;

package/dist/packages/local-service/routes.d.ts

@@ -1,6 +1,6 @@
 export declare const LOCAL_SERVICE_DEFAULT_HOST = "127.0.0.1";
 export declare const LOCAL_SERVICE_DEFAULT_PORT = 4873;
-export declare const LOCAL_SERVICE_INSTANCE_POINTER_PATH: readonly ["interf", ".service", "local-instance.json"];
+export declare const LOCAL_SERVICE_POINTER_PATH: readonly ["interf", ".service", "local-service.json"];
 export declare const LOCAL_SERVICE_ROUTES: {
     readonly root: "/";
     readonly api: "/v1";
@@ -9,10 +9,15 @@ export declare const LOCAL_SERVICE_ROUTES: {
     readonly workspaceFiles: "/v1/workspace-files";
     readonly sourceFiles: "/v1/source-files";
     readonly methods: "/v1/methods";
+    readonly preparationSetups: "/v1/preparation-setups";
+    readonly preparationChanges: "/v1/preparation-changes";
+    readonly methodChanges: "/v1/method-changes";
     readonly jobs: "/v1/jobs";
     readonly readinessCheckDrafts: "/v1/readiness-check-drafts";
     readonly methodAuthoringRuns: "/v1/method-authoring-runs";
+    readonly methodImprovementRuns: "/v1/method-improvement-runs";
     readonly runs: "/v1/runs";
+    readonly reset: "/v1/reset";
     readonly executor: "/v1/executor";
     readonly actionProposals: "/v1/action-proposals";
     readonly compileRuns: "/v1/compile-runs";

package/dist/packages/local-service/routes.js

@@ -1,9 +1,9 @@
 export const LOCAL_SERVICE_DEFAULT_HOST = "127.0.0.1";
 export const LOCAL_SERVICE_DEFAULT_PORT = 4873;
-export const LOCAL_SERVICE_INSTANCE_POINTER_PATH = [
+export const LOCAL_SERVICE_POINTER_PATH = [
     "interf",
     ".service",
-    "local-instance.json",
+    "local-service.json",
 ];
 export const LOCAL_SERVICE_ROUTES = {
     root: "/",
@@ -13,10 +13,15 @@ export const LOCAL_SERVICE_ROUTES = {
     workspaceFiles: "/v1/workspace-files",
     sourceFiles: "/v1/source-files",
     methods: "/v1/methods",
+    preparationSetups: "/v1/preparation-setups",
+    preparationChanges: "/v1/preparation-changes",
+    methodChanges: "/v1/method-changes",
     jobs: "/v1/jobs",
     readinessCheckDrafts: "/v1/readiness-check-drafts",
     methodAuthoringRuns: "/v1/method-authoring-runs",
+    methodImprovementRuns: "/v1/method-improvement-runs",
     runs: "/v1/runs",
+    reset: "/v1/reset",
     executor: "/v1/executor",
     actionProposals: "/v1/action-proposals",
     compileRuns: "/v1/compile-runs",