@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/{method-package → methods/package}/method-definitions.js

@@ -1,12 +1,12 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, } from "./local-methods.js";
-import { warnInterf } from "../shared/logger.js";
-import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { resolveSourceControlPath } from "../project-model/interf.js";
-import { PACKAGE_ROOT } from "./lib/package-root.js";
+import { builtinMethodPackagePath, isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, mergeStagePolicyNotesForStages, } from "./local-methods.js";
+import { listUserMethodDefinitions, loadUserMethodDefinition, } from "./user-methods.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
+import { asPreparationDataDir, preparationMethodPackagePath } from "../../contracts/lib/preparation-paths.js";
+import { resolveSourceControlPath } from "../../project/interf.js";
 import { deriveMethodInputsFromContextInterface, } from "./context-interface.js";
-import { mergeStagePolicyNotesForStages } from "./method-stage-policy.js";
 const DEFAULT_METHOD_ID = "interf-default";
 let builtinDefaultMethodCache = null;
 function toMethodStages(stages) {
@@ -16,6 +16,7 @@ function toMethodStages(stages) {
         description: stage.description ?? stage.label,
         contractType: stage.contract_type,
         skillDir: stage.skill_dir ?? stage.id,
+        role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
         reads: [...stage.reads],
         writes: [...stage.writes],
         ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
@@ -56,9 +57,6 @@ export function standaloneMethodDefinitionFromLocalPackage(local) {
         scope: "local",
     };
 }
-function builtinMethodPackagePath(methodId) {
-    return join(PACKAGE_ROOT, "builtin-methods", methodId);
-}
 function getBuiltinDefaultMethod() {
     if (builtinDefaultMethodCache)
         return builtinDefaultMethodCache;
@@ -78,24 +76,41 @@ function getBuiltinDefaultMethod() {
 function listBuiltinCompiledMethods() {
     return [getBuiltinDefaultMethod()];
 }
-function resolveCompiledMethodFromLocal(methodId, sourcePath) {
-    const local = loadLocalMethodDefinition(sourcePath, methodId);
+function resolveCompiledMethodFromLocal(methodId, prepDataDir) {
+    const local = loadLocalMethodDefinition(prepDataDir, methodId);
     if (!local)
         return null;
     const resolved = standaloneMethodDefinitionFromLocalPackage(local);
     return resolved;
 }
-export function listCompiledMethodChoices(sourcePath) {
+function resolveCompiledMethodFromUserLibrary(methodId) {
+    const user = loadUserMethodDefinition(methodId);
+    if (!user)
+        return null;
+    const resolved = standaloneMethodDefinitionFromLocalPackage(user);
+    return { ...resolved, scope: "user" };
+}
+export function listCompiledMethodChoices(prepDataDir) {
     const builtins = listBuiltinCompiledMethods();
-    if (!sourcePath)
-        return builtins;
     const methodsById = new Map();
     for (const method of builtins) {
         methodsById.set(method.id, method);
     }
-    for (const definition of listLocalMethodDefinitions(sourcePath)) {
+    for (const definition of listUserMethodDefinitions()) {
+        try {
+            const method = resolveCompiledMethodFromUserLibrary(definition.id);
+            if (method)
+                methodsById.set(method.id, method);
+        }
+        catch (error) {
+            warnInterf(`Warning: skipping user Method "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!prepDataDir)
+        return [...methodsById.values()];
+    for (const definition of listLocalMethodDefinitions(prepDataDir)) {
         try {
-            const method = resolveCompiledMethodFromLocal(definition.id, sourcePath);
+            const method = resolveCompiledMethodFromLocal(definition.id, prepDataDir);
             if (method)
                 methodsById.set(method.id, method);
         }
@@ -106,16 +121,21 @@ export function listCompiledMethodChoices(sourcePath) {
     return [...methodsById.values()];
 }
 export function getCompiledMethod(methodId, options = {}) {
+    if (options.prepDataDir) {
+        const local = resolveCompiledMethodFromLocal(methodId, options.prepDataDir);
+        if (local)
+            return local;
+    }
+    const user = resolveCompiledMethodFromUserLibrary(methodId);
+    if (user)
+        return user;
     const builtin = listBuiltinCompiledMethods().find((candidate) => candidate.id === methodId);
     if (builtin)
         return builtin;
-    if (options.sourcePath) {
-        const local = resolveCompiledMethodFromLocal(methodId, options.sourcePath);
-        if (local)
-            return local;
-        throw new Error(`No local Method package found for "${methodId}" under ${join(options.sourcePath, "interf", "methods", methodId)}.`);
+    if (options.prepDataDir) {
+        throw new Error(`No Method "${methodId}" found in this workspace, in your user library, or among bundled Methods. Looked under ${preparationMethodPackagePath(asPreparationDataDir(options.prepDataDir), methodId)} and ~/.interf/methods/${methodId}.`);
     }
-    throw new Error(`Method "${methodId}" is not built-in. Provide a source path so Interf can resolve a local Method package.`);
+    throw new Error(`Method "${methodId}" is not built-in and no workspace root was provided to look for a local override.`);
 }
 export function getActiveCompiledMethod(compiledPath) {
     const methodPath = methodPackagePathForCompiled(compiledPath);
@@ -147,15 +167,12 @@ export function resolveRequiredCompiledMethodFromConfig(config, label = "compile
     }
     return methodId;
 }
-export function formatCompiledMethodStageStep(methodId, stage, options = {}) {
-    return formatMethodStageStep(getCompiledMethod(methodId, options), stage);
-}
-function resolveMethodDefinitionForStageMetadata(methodId, sourcePath) {
-    if (sourcePath &&
-        existsSync(join(methodPackagePathForCompiled(sourcePath), "method.json"))) {
-        return getActiveCompiledMethod(sourcePath);
+function resolveMethodDefinitionForStageMetadata(methodId, prepDataDir) {
+    if (prepDataDir &&
+        existsSync(join(methodPackagePathForCompiled(prepDataDir), "method.json"))) {
+        return getActiveCompiledMethod(prepDataDir);
     }
-    return getCompiledMethod(methodId, { sourcePath });
+    return getCompiledMethod(methodId, { prepDataDir });
 }
 function formatMethodStageStep(method, stage) {
     const stageIndex = method.stages.findIndex((candidate) => candidate.id === stage);
@@ -168,12 +185,12 @@ function formatMethodStageStep(method, stage) {
     }
     return `Stage ${stageIndex + 1}/${method.stages.length} - ${stageDefinition.label}`;
 }
-export function getMethodStageDefinition(methodId, stage, sourcePath) {
-    const method = resolveMethodDefinitionForStageMetadata(methodId, sourcePath);
+export function getMethodStageDefinition(methodId, stage, prepDataDir) {
+    const method = resolveMethodDefinitionForStageMetadata(methodId, prepDataDir);
     return method.stages.find((candidate) => candidate.id === stage) ?? null;
 }
-export function getMethodStagePosition(methodId, stage, sourcePath) {
-    const stages = getMethodStages(methodId, sourcePath);
+export function getMethodStagePosition(methodId, stage, prepDataDir) {
+    const stages = getMethodStages(methodId, prepDataDir);
     const stageIndex = stages.findIndex((candidate) => candidate === stage);
     if (stageIndex === -1)
         return null;
@@ -183,16 +200,12 @@ export function getMethodStagePosition(methodId, stage, sourcePath) {
         stages: [...stages],
     };
 }
-export function getMethodStages(methodId, sourcePath) {
-    return resolveMethodDefinitionForStageMetadata(methodId, sourcePath).stages.map((definition) => definition.id);
+export function getMethodStages(methodId, prepDataDir) {
+    return resolveMethodDefinitionForStageMetadata(methodId, prepDataDir).stages.map((definition) => definition.id);
 }
 export function getActiveCompiledStages(compiledPath) {
     return getActiveCompiledMethod(compiledPath).stages.map((definition) => definition.id);
 }
-export function getMethodStagePolicyNotes(methodId, stage, sourcePath) {
-    const method = resolveMethodDefinitionForStageMetadata(methodId, sourcePath);
-    return [...(method.stagePolicyNotes?.[stage] ?? [])];
-}
 export function getActiveCompiledStagePolicyNotes(compiledPath, stage) {
     const method = getActiveCompiledMethod(compiledPath);
     return [...(method.stagePolicyNotes?.[stage] ?? [])];

package/dist/packages/{method-package → methods/package}/method-helpers.d.ts

@@ -1,4 +1,4 @@
-import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../compiler/lib/schema.js";
+import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
 import { type MethodStageDefinition } from "./method-definitions.js";
 export interface MethodReporter {
     line?: (message: string) => void;
@@ -9,8 +9,6 @@ export interface MethodStageResult {
     code: number;
     summary?: string | null;
 }
-export declare function methodQueryDirectory(): string;
-export declare function methodImproveDirectory(): string;
 export declare function methodCompileStageDirectory(stageDir: string): string;
 export interface LocalSkillContractExtension {
     reads: string[];
@@ -20,19 +18,9 @@ export interface LocalSkillContractExtension {
     effectiveMode: RuntimeInstructionMode;
     modeSources: string[];
 }
-export declare function emptyLocalSkillContractExtension(): LocalSkillContractExtension;
 export declare function buildLocalSkillContractExtension(rootPath: string, directories: string[], purpose: string): LocalSkillContractExtension;
-export declare function buildLocalSkillContractExtensionRelativeTo(rootPath: string, relativeToPath: string, directories: string[], purpose: string): LocalSkillContractExtension;
-export declare function mergeLocalSkillContractExtensions(extensions: LocalSkillContractExtension[]): LocalSkillContractExtension;
 export declare function buildStageInstructions(stageSkillDir: string, localSkills: LocalSkillContractExtension): RuntimeStageInstructions;
 export declare function reportLine(reporter: MethodReporter | undefined, message: string): void;
 export declare function reportBlankLine(reporter: MethodReporter | undefined): void;
 export declare function reportValidationFailure(reporter: MethodReporter | undefined, summary: string, errors?: string[]): void;
-export declare function resolveStageAcceptance(methodId: string, stageId: string, sourcePath?: string): MethodStageDefinition["acceptance"] | undefined;
-export declare function validateStageOutcome(_dirPath: string, validation: {
-    ok: boolean;
-    summary: string;
-}): {
-    ok: boolean;
-    summary: string;
-};
+export declare function resolveStageAcceptance(methodId: string, stageId: string, prepDataDir?: string): MethodStageDefinition["acceptance"] | undefined;

package/dist/packages/{method-package → methods/package}/method-helpers.js

@@ -1,21 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
-import { isMarkdownFile } from "../shared/file-types.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
+import { isMarkdownFile } from "../../contracts/utils/file-types.js";
 import { getCompiledMethod, } from "./method-definitions.js";
-import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
-export function methodQueryDirectory() {
-    return `${COMPILED_METHOD_DIR}/use/query`;
-}
-export function methodImproveDirectory() {
-    return `${COMPILED_METHOD_DIR}/improve`;
-}
 export function methodCompileStageDirectory(stageDir) {
     return `${COMPILED_METHOD_DIR}/compile/stages/${stageDir}`;
 }
-export function emptyLocalSkillContractExtension() {
+function emptyLocalSkillContractExtension() {
     return {
         reads: [],
         count: 0,
@@ -36,14 +30,11 @@ function readLocalInstructionMode(filePath) {
     }
 }
 function collectLocalSkillDocs(rootPath, directories) {
-    return collectLocalSkillDocsRelativeTo(rootPath, rootPath, directories);
-}
-function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
     const docs = new Map();
     const methodRoot = methodPackagePathForCompiled(rootPath);
     const rootReadme = join(methodRoot, "README.md");
     if (existsSync(rootReadme)) {
-        const read = projectMethodReadPath(rootPath, relativeToPath, rootReadme);
+        const read = projectMethodReadPath(rootPath, rootReadme);
         docs.set(read, {
             read,
             absolutePath: rootReadme,
@@ -53,7 +44,7 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
     for (const directory of directories) {
         const absoluteDirectory = resolveAuthoringDirectory(rootPath, directory);
         for (const filePath of listFilesRecursive(absoluteDirectory, isMarkdownFile)) {
-            const read = projectMethodReadPath(rootPath, relativeToPath, filePath);
+            const read = projectMethodReadPath(rootPath, filePath);
             docs.set(read, {
                 read,
                 absolutePath: filePath,
@@ -75,23 +66,19 @@ function resolveAuthoringDirectory(rootPath, directory) {
     }
     return join(rootPath, directory);
 }
-function projectMethodReadPath(rootPath, relativeToPath, absolutePath) {
+function projectMethodReadPath(rootPath, absolutePath) {
     const methodRoot = methodPackagePathForCompiled(rootPath);
     const normalizedMethodRoot = `${methodRoot}${sep}`;
     if (absolutePath === methodRoot || absolutePath.startsWith(normalizedMethodRoot)) {
         const relativeMethodPath = relative(methodRoot, absolutePath);
-        return relative(relativeToPath, join(rootPath, COMPILED_METHOD_DIR, relativeMethodPath));
+        return relative(rootPath, join(rootPath, COMPILED_METHOD_DIR, relativeMethodPath));
     }
-    return relative(relativeToPath, absolutePath);
+    return relative(rootPath, absolutePath);
 }
 export function buildLocalSkillContractExtension(rootPath, directories, purpose) {
     const docs = collectLocalSkillDocs(rootPath, directories);
     return buildContractExtensionFromDocs(docs, directories, purpose);
 }
-export function buildLocalSkillContractExtensionRelativeTo(rootPath, relativeToPath, directories, purpose) {
-    const docs = collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories);
-    return buildContractExtensionFromDocs(docs, directories, purpose);
-}
 function buildContractExtensionFromDocs(docs, directories, purpose) {
     const reads = docs.map((doc) => doc.read);
     const modeSources = docs.filter((doc) => doc.mode !== null).map((doc) => doc.read);
@@ -120,24 +107,6 @@ function buildContractExtensionFromDocs(docs, directories, purpose) {
         modeSources,
     };
 }
-export function mergeLocalSkillContractExtensions(extensions) {
-    const reads = Array.from(new Set(extensions.flatMap((extension) => extension.reads)));
-    const notes = Array.from(new Set(extensions.flatMap((extension) => extension.notes)));
-    const modeSources = Array.from(new Set(extensions.flatMap((extension) => extension.modeSources)));
-    const localMode = extensions.some((extension) => extension.localMode === "override")
-        ? "override"
-        : extensions.some((extension) => extension.localMode === "extend")
-            ? "extend"
-            : null;
-    return {
-        reads,
-        count: reads.length,
-        notes,
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
 export function buildStageInstructions(stageSkillDir, localSkills) {
     return {
         stage_skill_dir: stageSkillDir,
@@ -159,9 +128,6 @@ export function reportValidationFailure(reporter, summary, errors = []) {
         reportLine(reporter, `- ${error}`);
     }
 }
-export function resolveStageAcceptance(methodId, stageId, sourcePath) {
-    return getCompiledMethod(methodId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
-}
-export function validateStageOutcome(_dirPath, validation) {
-    return validation;
+export function resolveStageAcceptance(methodId, stageId, prepDataDir) {
+    return getCompiledMethod(methodId, { prepDataDir }).stages.find((stage) => stage.id === stageId)?.acceptance;
 }

package/dist/packages/{method-package → methods/package}/method-review-paths.d.ts

@@ -1,4 +1,4 @@
-import type { MethodImprovementContext } from "../compiler/lib/schema.js";
+import type { MethodImprovementContext } from "../../engine/compile/lib/schema.js";
 export interface MethodImprovementReviewSourcePaths {
     compiledRuntime: string | null;
     readinessRuns: string | null;

package/dist/packages/{method-package → methods/package}/method-review-paths.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../compiler/compiled-paths.js";
+import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../../engine/compile/compiled-paths.js";
 export function resolveMethodImprovementReviewSourcePaths(compiledPath) {
     const compiledRuntime = compiledRuntimeRoot(compiledPath);
     const readinessRuns = testRootForCompiled(compiledPath);

package/dist/packages/{method-package → methods/package}/method-stage-runner.d.ts

@@ -1,7 +1,7 @@
-import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type RuntimeStageInstructions } from "../compiler/lib/schema.js";
-import type { RuntimeContractType } from "../contracts/lib/schema.js";
-import { type RuntimeStageContractDraft } from "../compiler/runtime.js";
+import { type MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
+import type { RuntimeContractType } from "../../contracts/lib/schema.js";
+import { type RuntimeStageContractDraft } from "../../engine/compile/runtime.js";
 import { type MethodReporter, type MethodStageResult } from "./method-helpers.js";
 interface MethodStageShape<TContractType extends RuntimeContractType> {
     id: string;
@@ -31,13 +31,8 @@ interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType
         summary: string;
     };
 }
-interface ExecuteValidatedSummarizeStageOptions<TContractType extends RuntimeContractType> extends ExecuteValidatedStageOptions<TContractType> {
-    startingSummaryCount: number;
-    targetCount: number;
-}
 export declare function findStageByContractType<TStage extends {
     contractType: string;
 }>(stages: TStage[], contractType: TStage["contractType"]): TStage;
 export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<MethodStageResult>;
-export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<MethodStageResult>;
 export {};

package/dist/packages/{method-package → methods/package}/method-stage-runner.js

@@ -1,5 +1,5 @@
-import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, runExecutorSummarizeStage, } from "../compiler/runtime.js";
-import { reportValidationFailure, validateStageOutcome, } from "./method-helpers.js";
+import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, } from "../../engine/compile/runtime.js";
+import { reportValidationFailure, } from "./method-helpers.js";
 export function findStageByContractType(stages, contractType) {
     const stage = stages.find((candidate) => candidate.contractType === contractType);
     if (!stage) {
@@ -33,40 +33,12 @@ export async function executeValidatedStage(options) {
     });
     return finalizeValidatedStage(options, code);
 }
-export async function executeValidatedSummarizeStage(options) {
-    const completionCheck = options.completionCheck
-        ? () => {
-            options.syncWrites?.();
-            options.reconcile?.();
-            return options.completionCheck?.() === true;
-        }
-        : undefined;
-    const code = await runExecutorSummarizeStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        executionPath: options.executionPath,
-        compiledName: options.targetName,
-        method: options.method,
-        methodSourcePath: options.methodSourcePath,
-        stage: options.stageDefinition.id,
-        stageLabel: options.stageDefinition.label,
-        contractType: options.stageDefinition.contractType,
-        summary: options.summary,
-        contract: options.contract,
-        buildPrompt: (contractPath) => buildStagePrompt(options.instructions, contractPath, options.statusLines),
-        completionCheck,
-        onStatus: options.onStatus,
-        startingSummaryCount: options.startingSummaryCount,
-        targetCount: options.targetCount,
-    });
-    return finalizeValidatedStage(options, code);
-}
 function finalizeValidatedStage(options, code) {
     const refreshAndValidate = () => {
         options.syncWrites?.();
         options.reconcile?.();
         options.refreshArtifacts?.();
-        return validateStageOutcome(options.compiledPath, options.validate());
+        return options.validate();
     };
     if (code !== 0) {
         let completionSatisfied = false;

package/dist/packages/methods/package/user-methods.d.ts

@@ -0,0 +1,17 @@
+import { type LocalMethodDefinition } from "./local-methods.js";
+export declare function userMethodPath(id: string): string;
+export declare function userMethodExists(id: string): boolean;
+export declare function listUserMethodDefinitions(): LocalMethodDefinition[];
+export declare function loadUserMethodDefinition(id: string): LocalMethodDefinition | null;
+export interface InstallUserMethodOptions {
+    sourceDir: string;
+    id?: string;
+    overwrite?: boolean;
+}
+export interface InstallUserMethodResult {
+    id: string;
+    path: string;
+    overwritten: boolean;
+}
+export declare function installUserMethod(options: InstallUserMethodOptions): InstallUserMethodResult;
+export declare function removeUserMethod(id: string): boolean;

package/dist/packages/methods/package/user-methods.js

@@ -0,0 +1,77 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { userMethodPackagePath, userMethodsRoot, } from "../../contracts/lib/preparation-paths.js";
+import { loadMethodDefinitionFromDir, } from "./local-methods.js";
+export function userMethodPath(id) {
+    return userMethodPackagePath(id);
+}
+export function userMethodExists(id) {
+    return existsSync(join(userMethodPath(id), "method.json"));
+}
+export function listUserMethodDefinitions() {
+    const root = userMethodsRoot();
+    if (!existsSync(root))
+        return [];
+    const definitions = [];
+    for (const entry of readdirSync(root)) {
+        const entryPath = join(root, entry);
+        try {
+            if (!statSync(entryPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const definition = loadMethodDefinitionFromDir(entryPath);
+        if (definition)
+            definitions.push(definition);
+    }
+    return definitions.sort((a, b) => a.label.localeCompare(b.label));
+}
+export function loadUserMethodDefinition(id) {
+    return loadMethodDefinitionFromDir(userMethodPath(id));
+}
+export function installUserMethod(options) {
+    const sourceDir = resolve(options.sourceDir);
+    if (!existsSync(join(sourceDir, "method.json"))) {
+        throw new Error(`No method.json found at ${sourceDir}.`);
+    }
+    const definition = loadMethodDefinitionFromDir(sourceDir);
+    if (!definition) {
+        throw new Error(`Could not load Method package at ${sourceDir}.`);
+    }
+    const id = options.id ?? definition.id;
+    if (!id)
+        throw new Error("Method id is required.");
+    const targetPath = userMethodPath(id);
+    const existed = existsSync(targetPath);
+    if (existed && !options.overwrite) {
+        throw new Error(`User Method "${id}" already exists at ${targetPath}. Pass overwrite to replace it.`);
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    if (existed)
+        rmSync(targetPath, { recursive: true, force: true });
+    cpSync(sourceDir, targetPath, { recursive: true, force: true });
+    if (id !== definition.id) {
+        const targetMethodJson = join(targetPath, "method.json");
+        const raw = readFileSync(targetMethodJson, "utf8");
+        const parsed = JSON.parse(raw);
+        parsed.id = id;
+        writeFileSync(targetMethodJson, `${JSON.stringify(parsed, null, 2)}\n`);
+    }
+    return { id, path: targetPath, overwritten: existed };
+}
+export function removeUserMethod(id) {
+    const target = userMethodPath(id);
+    if (!existsSync(target))
+        return false;
+    try {
+        rmSync(target, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        warnInterf(`Warning: failed to remove user Method ${id} at ${target}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

package/dist/packages/{project-model → project}/index.d.ts

@@ -5,6 +5,5 @@ export * as interf from "./interf.js";
 export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
-export * as projectPaths from "./project-paths.js";
 export * as preparationEntries from "./preparation-entries.js";
 export type { InterfConfig, MethodId, PreparationName, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";

package/dist/packages/{project-model → project}/index.js

@@ -5,5 +5,4 @@ export * as interf from "./interf.js";
 export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
-export * as projectPaths from "./project-paths.js";
 export * as preparationEntries from "./preparation-entries.js";

package/dist/packages/{project-model → project}/interf-bootstrap.d.ts

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";

package/dist/packages/{project-model → project}/interf-bootstrap.js

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";

package/dist/packages/{project-model → project}/interf-detect.d.ts

@@ -1,7 +1,7 @@
 import { type InterfConfig } from "./lib/schema.js";
 export type { InterfConfig } from "./lib/schema.js";
 export interface ResolvedCompiled {
-    sourcePath: string;
+    prepDataDir: string;
     compiledPath: string;
     config: InterfConfig;
 }
@@ -16,6 +16,11 @@ export declare function hasSourceFolderInput(config: InterfConfig | null | undef
         path: string;
     };
 };
+export declare function hasSourcePreparationInput(config: InterfConfig | null | undefined): config is InterfConfig & {
+    source: {
+        preparation_path: string;
+    };
+};
 export declare function detectInterf(cwd: string): {
     path: string;
     config: InterfConfig;
@@ -24,10 +29,10 @@ export declare function resolveCompiled(cwd: string): ResolvedCompiled | null;
 export declare function resolveSourceFolderPath(compiledPath: string, config?: InterfConfig | null): string;
 export declare function resolveSourceControlPath(compiledPath: string): string;
 export declare function resolveSourceInputPath(compiledPath: string): string;
-export declare function listPortableContextsForSourceFolder(sourcePath: string): Array<{
+export declare function listPortableContextsForSourceFolder(prepDataDir: string): Array<{
     path: string;
     config: InterfConfig;
 }>;
-export declare function assertCompiledContainer(sourcePath: string): string;
+export declare function assertCompiledContainer(prepDataDir: string): string;
 export declare function assertWritableTargetDir(dirPath: string, label: string): void;
 export declare function assertCompiledName(name: string, label: string): void;