@interf/compiler 0.13.0 → 0.16.0

package/dist/packages/{testing → engine/verify}/test-sandbox.js

@@ -2,13 +2,13 @@ import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } fr
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig, resolveSourceInputPath } from "../project-model/interf.js";
+import { readInterfConfig, resolveSourceInputPath } from "../../project/interf.js";
 import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { buildCompiledSourceFiles } from "../compiler/source-files.js";
-import { refreshCompiledArtifacts } from "../compiler/state.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { saveCompiledInterfConfig } from "../../project/source-config.js";
+import { buildCompiledSourceFiles } from "../compile/source-files.js";
+import { refreshCompiledArtifacts } from "../compile/state.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compile/compiled-paths.js";
 function sanitizeCompiledArtifacts(compiledPath) {
     for (const absolutePath of [
         testRootForCompiled(compiledPath),

package/dist/packages/{testing → engine/verify}/test-specs.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
 import { basename, extname, join } from "node:path";
-import { readJsonFileWithSchema } from "../shared/parse.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { TestSpecSchema } from "./lib/schema.js";
 import { TEST_SPEC_EXTENSIONS, assertTestId, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./test-paths.js";
 function readTestSpecFile(filePath) {

package/dist/packages/{testing → engine/verify}/test-targets.js

@@ -1,6 +1,6 @@
-import { listPortableContextsForSourceFolder } from "../project-model/interf-detect.js";
-import { computeCompiledHealth } from "../compiler/state.js";
-import { DEFAULT_METHOD_ID, resolveMethodId } from "../methods/method-resolution.js";
+import { listPortableContextsForSourceFolder } from "../../project/interf-detect.js";
+import { computeCompiledHealth } from "../compile/state.js";
+import { DEFAULT_METHOD_ID, resolveMethodId } from "../../methods/method-resolution.js";
 function summarizeTargetSortKey(target) {
     return `${target.name}\u0000${target.method}`;
 }

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

@@ -1,6 +1,14 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import { validateMethodPackage } from "../method-package/local-methods.js";
-import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { validateMethodPackage } from "../package/local-methods.js";
+import type { SourceReadinessCheck } from "../../project/lib/schema.js";
+/**
+ * Walk method.json after a successful authoring run and fill in
+ * `role: "general"` for any stage missing a role field. Custom role
+ * names are kept as-is. Idempotent — does nothing when every stage
+ * already declares a role. Returns the list of stage ids that were
+ * touched so the runtime can surface that to the user.
+ */
+export declare function ensureStageRoles(methodPath: string): string[];
 export interface MethodAuthoringRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;

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

@@ -1,9 +1,62 @@
-import { rmSync } from "node:fs";
-import { createMethodAuthoringShell } from "../agents/lib/shells.js";
-import { createScratchLocalMethodPackage } from "../method-package/interf-method-package.js";
-import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
-import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../method-package/local-methods.js";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createMethodAuthoringShell } from "../../engine/agents/lib/shells.js";
+import { createScratchLocalMethodPackage } from "../package/interf-method-package.js";
+import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
+import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../package/local-methods.js";
 import { runMethodEditSession } from "./method-edit-session.js";
+/**
+ * Walk method.json after a successful authoring run and fill in
+ * `role: "general"` for any stage missing a role field. Custom role
+ * names are kept as-is. Idempotent — does nothing when every stage
+ * already declares a role. Returns the list of stage ids that were
+ * touched so the runtime can surface that to the user.
+ */
+export function ensureStageRoles(methodPath) {
+    const methodJsonPath = join(methodPath, "method.json");
+    if (!existsSync(methodJsonPath))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(methodJsonPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    const value = parsed;
+    if (!Array.isArray(value.stages))
+        return [];
+    const touched = [];
+    let changed = false;
+    const nextStages = value.stages.map((stage) => {
+        if (!stage || typeof stage !== "object" || Array.isArray(stage))
+            return stage;
+        const stageRecord = stage;
+        const declaredRole = typeof stageRecord.role === "string" && stageRecord.role.trim().length > 0
+            ? stageRecord.role.trim()
+            : null;
+        if (declaredRole)
+            return stage;
+        const id = typeof stageRecord.id === "string" ? stageRecord.id : "(unknown)";
+        touched.push(id);
+        changed = true;
+        return { ...stageRecord, role: "general" };
+    });
+    if (!changed)
+        return [];
+    value.stages = nextStages;
+    writeFileSync(methodJsonPath, `${JSON.stringify(value, null, 2)}\n`);
+    return touched;
+}
 function buildMethodAuthoringPrompt() {
     return [
         "This is an automated Interf Method-authoring run, not an open-ended chat session.",
@@ -21,6 +74,7 @@ function buildMethodAuthoringPrompt() {
         "Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
         "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+        "Each stage MAY declare a `role`: one of `extractor`, `summarizer`, `structurer`, `verifier`, or `general`. Pick the role that best matches what the stage's prompt asks the agent to do. Omit `role` (or use `general`) when the stage doesn't fit any specialized role. Custom role names are allowed; the engine treats unknown roles as `general`.",
         "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
         "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
         "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
@@ -102,6 +156,15 @@ export async function runMethodAuthoringDraft(options) {
     if (session.status !== "updated") {
         rmSync(methodPath, { recursive: true, force: true });
     }
+    else {
+        // 0.15 — auto-fill `role: "general"` for any stage the agent
+        // didn't explicitly tag. Idempotent and silent when every stage
+        // already declares a role.
+        const touched = ensureStageRoles(methodPath);
+        if (touched.length > 0 && options.onStatus) {
+            options.onStatus(`STATUS: filled role=general on ${touched.length} stage(s) the author didn't tag (${touched.join(", ")}).`);
+        }
+    }
     return {
         status: session.status,
         changed: session.changed,

package/dist/packages/{method-authoring → methods/authoring}/method-edit-session.d.ts

@@ -1,5 +1,5 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import type { MethodValidationResult } from "../method-package/local-methods.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import type { MethodValidationResult } from "../package/local-methods.js";
 import { type MethodEditShellArtifacts } from "./lib/method-edit-utils.js";
 export interface MethodEditSessionResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";

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

@@ -1,7 +1,7 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import { type MethodValidationResult } from "../method-package/local-methods.js";
-import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
-import type { MethodImprovementLoopSummary } from "../compiler/lib/schema.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { type MethodValidationResult } from "../package/local-methods.js";
+import type { SourcePreparationConfig } from "../../project/lib/schema.js";
+import type { MethodImprovementLoopSummary } from "../../engine/compile/lib/schema.js";
 export interface MethodImprovementRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;

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

@@ -1,15 +1,16 @@
 import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
-import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../agents/lib/shells.js";
-import { validateMethodPackage } from "../method-package/local-methods.js";
-import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { resolveMethodImprovementReviewPaths } from "../method-package/method-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../compiler/compiled-paths.js";
-import { readInterfConfig } from "../project-model/interf.js";
-import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { MethodImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
+import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../../engine/agents/lib/shells.js";
+import { validateMethodPackage } from "../package/local-methods.js";
+import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { resolveMethodImprovementReviewPaths } from "../package/method-review-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../../engine/compile/compiled-paths.js";
+import { readInterfConfig } from "../../project/interf.js";
+import { saveCompiledInterfConfig } from "../../project/source-config.js";
+import { MethodImprovementRunLedgerSchema, } from "../../engine/compile/lib/schema.js";
 import { runMethodEditSession } from "./method-edit-session.js";
+import { ensureStageRoles } from "./method-authoring.js";
 function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     if (!absolutePath)
         return null;
@@ -169,6 +170,11 @@ export async function runMethodImprovementLoop(options) {
         validate: validateMethodPackage,
         maxValidationRepairAttempts: 1,
     });
+    if (session.status === "updated") {
+        // 0.15 — fill role=general on any stage the improvement run
+        // dropped a role from. Idempotent and silent when complete.
+        ensureStageRoles(methodRoot);
+    }
     const preservedShellManifestPath = freezeMethodImprovementShell(shell.rootPath);
     writeMethodImprovementRunLedger(options.compiledPath, options.runId, buildMethodImprovementLoopRecord({
         targetName: compiledName,

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

@@ -1,4 +1,4 @@
-import { type CompiledZoneKind } from "../compiler/method-primitives.js";
+import { type CompiledZoneKind } from "../../engine/compile/method-primitives.js";
 declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";

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

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { z } from "zod";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { MethodCompiledSchemaSchema } from "../compiler/lib/schema.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { MethodCompiledSchemaSchema } from "../../engine/compile/lib/schema.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
 const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../compiler/lib/schema.js";
+import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../../engine/compile/lib/schema.js";
 export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"method-schema">;

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

@@ -1,9 +1,9 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
-import { MethodCompiledSchemaSchema, MethodZoneIdSchema, } from "../compiler/lib/schema.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
+import { MethodCompiledSchemaSchema, MethodZoneIdSchema, } from "../../engine/compile/lib/schema.js";
 import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-method.js";
 // Method packages define the context interface. The compiler persists the
 // same schema on disk, but higher layers should prefer this boundary when they

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

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { renderCompiledQuerySkill } from "../agents/lib/shells.js";
+import { renderCompiledQuerySkill } from "../../engine/agents/lib/shells.js";
 import { copyMethodPackageDirectory, isPortableMethodPackage, patchMethodPackageMetadata, resolveMethodPackageSourcePath, methodDefinitionPath, mergeStagePolicyNotesForStages, } from "./local-methods.js";
 import { getCompiledMethod, } from "./method-definitions.js";
 import { CONTEXT_INTERFACE_FILE, deriveMethodInputsFromContextInterface, summarizeContextInterface, writeContextInterface, writeContextInterfaceFile, } from "./context-interface.js";
-import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
 function writeMethodStarterDocs(dirPath, docs, options) {
     for (const doc of docs ?? []) {
         const targetPath = join(dirPath, doc.relativePath);
@@ -456,6 +456,7 @@ export function createScratchLocalMethodPackage(options) {
                 description: "Neutral placeholder stage for Method authoring. Replace this stage with the topology this agent work needs.",
                 contractType: "method-draft-stage",
                 skillDir: "prepare",
+                role: "general",
                 reads: ["runtime"],
                 writes: ["draft-context"],
                 acceptance: {

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

@@ -2,5 +2,5 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Package root (dist/packages/method-package/lib/ -> package root)
-export const PACKAGE_ROOT = join(__dirname, "..", "..", "..", "..");
+// Package root (dist/packages/methods/package/lib/ -> package root)
+export const PACKAGE_ROOT = join(__dirname, "..", "..", "..", "..", "..");

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema } from "../compiler/lib/schema.js";
-import { RuntimeContractTypeSchema } from "../contracts/lib/schema.js";
+import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema } from "../../engine/compile/lib/schema.js";
+import { RuntimeContractTypeSchema } from "../../contracts/lib/schema.js";
 import { MethodInputSpecSchema, type ContextInterface, type MethodInputSpec } from "./context-interface.js";
 export interface LocalMethodStarterDoc {
     relativePath: string;
@@ -12,6 +12,12 @@ export interface LocalMethodStageDefinition {
     contract_type: z.infer<typeof RuntimeContractTypeSchema>;
     skill_dir?: string;
     description?: string;
+    /**
+     * Optional role hint. Open-ended string; defaults to `general` at the
+     * runtime layer when missing. Maps to a connected agent via the user's
+     * role-map (`~/.interf/agents.json`).
+     */
+    role?: string;
     reads: z.infer<typeof MethodStageZoneAccessSchema>;
     writes: z.infer<typeof MethodStageZoneAccessSchema>;
     acceptance?: z.infer<typeof RuntimeStageAcceptanceSchema>;

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

@@ -1,13 +1,13 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
 import { z } from "zod";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
-import { isMarkdownFile } from "../shared/file-types.js";
-import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema, } from "../compiler/lib/schema.js";
-import { RuntimeContractTypeSchema, InterfIdPattern, } from "../contracts/lib/schema.js";
-import { asPreparationDataDir, preparationMethodsRoot, } from "../contracts/lib/preparation-paths.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { isMarkdownFile } from "../../contracts/utils/file-types.js";
+import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema, } from "../../engine/compile/lib/schema.js";
+import { RuntimeContractTypeSchema, InterfIdPattern, } from "../../contracts/lib/schema.js";
+import { asPreparationDataDir, preparationMethodsRoot, } from "../../contracts/lib/preparation-paths.js";
 import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-method.js";
 import { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, contextInterfaceExists, contextInterfaceFilePath, readContextInterface, MethodInputSpecSchema, writeContextInterface, } from "./context-interface.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
@@ -17,6 +17,7 @@ const LocalMethodStageDefinitionSchema = z.object({
     contract_type: RuntimeContractTypeSchema,
     skill_dir: z.string().regex(InterfIdPattern).optional(),
     description: z.string().min(1).optional(),
+    role: z.string().min(1).optional(),
     reads: MethodStageZoneAccessSchema,
     writes: MethodStageZoneAccessSchema,
     acceptance: RuntimeStageAcceptanceSchema.optional(),

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

@@ -1,6 +1,6 @@
 import { type LocalMethodDefinition } from "./local-methods.js";
-import type { RuntimeStageAcceptance, MethodCompilerApi } from "../compiler/lib/schema.js";
-import type { MethodId, RuntimeContractType } from "../contracts/lib/schema.js";
+import type { RuntimeStageAcceptance, MethodCompilerApi } from "../../engine/compile/lib/schema.js";
+import type { MethodId, RuntimeContractType } from "../../contracts/lib/schema.js";
 import { type ContextInterface, type ContextInterfaceZoneId, type MethodInputSpec } from "./context-interface.js";
 export interface MethodStarterDoc {
     relativePath: string;
@@ -12,6 +12,12 @@ export interface MethodStageDefinition {
     description: string;
     contractType: RuntimeContractType;
     skillDir: string;
+    /**
+     * Role hint declared by the Method package. Defaults to `general` when
+     * absent; mapped to a connected agent via the user's role-map at run
+     * time.
+     */
+    role: string;
     reads: ContextInterfaceZoneId[];
     writes: ContextInterfaceZoneId[];
     acceptance?: RuntimeStageAcceptance;

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

@@ -2,10 +2,10 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { builtinMethodPackagePath, isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, mergeStagePolicyNotesForStages, } from "./local-methods.js";
 import { listUserMethodDefinitions, loadUserMethodDefinition, } from "./user-methods.js";
-import { warnInterf } from "../shared/logger.js";
-import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { asPreparationDataDir, preparationMethodPackagePath } from "../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPath } from "../project-model/interf.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";
 const DEFAULT_METHOD_ID = "interf-default";
 let builtinDefaultMethodCache = null;
@@ -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 } : {}),

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;

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

@@ -1,10 +1,10 @@
 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 methodCompileStageDirectory(stageDir) {
     return `${COMPILED_METHOD_DIR}/compile/stages/${stageDir}`;

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,4 +1,4 @@
-import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, runExecutorSummarizeStage, } from "../compiler/runtime.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);
@@ -33,34 +33,6 @@ 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?.();

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

@@ -1,7 +1,7 @@
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { userMethodPackagePath, userMethodsRoot, } from "../contracts/lib/preparation-paths.js";
+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);

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.js

@@ -1,11 +1,11 @@
 import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
+import { warnInterf } from "../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../contracts/utils/parse.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../engine/compile/compiled-paths.js";
 import { InterfConfigSchema, } from "./lib/schema.js";
-import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { assertPathWithinRoot } from "../contracts/utils/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
 export const METHOD_CONTAINER_NAME = "methods";
 export const TEST_CONTAINER_NAME = "tests";

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

@@ -1,15 +1,15 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
-import { getCompiledMethod } from "../method-package/method-definitions.js";
-import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../method-package/local-methods.js";
-import { initializeCompiledRuntimeState, } from "../compiler/state.js";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { getCompiledMethod } from "../methods/package/method-definitions.js";
+import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../methods/package/local-methods.js";
+import { initializeCompiledRuntimeState, } from "../engine/compile/state.js";
+import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
 import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
-import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
+import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../compiler/compiled-schema.js";
+import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
 import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../engine/compile/compiled-paths.js";
 import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",

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

@@ -38,7 +38,7 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$loose>;
 export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
@@ -102,7 +102,7 @@ export declare const InterfConfigSchema: z.ZodObject<{
 export declare const SourceFolderConfigSchema: z.ZodObject<{
     source_folder: z.ZodOptional<z.ZodObject<{
         path: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$loose>>;
     preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;

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

@@ -65,7 +65,7 @@ export const SourcePreparationConfigSchema = z.object({
 }).strict();
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),
-}).strict();
+}).passthrough();
 export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
     name: PreparationNameSchema,

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

@@ -1,5 +1,5 @@
 import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourcePreparationConfig, type SourceFolderConfig } from "./lib/schema.js";
-import type { TestSpec, TestTargetType } from "../testing/lib/schema.js";
+import type { TestSpec, TestTargetType } from "../engine/verify/lib/schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
 export declare const SOURCE_FOLDER_CONFIG_PATH = "interf.json";
 export interface LoadedSourceTestSpec extends TestSpec {