@interf/compiler 0.18.0 → 0.21.0

package/dist/packages/engine/wire-schemas.d.ts

@@ -302,6 +302,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                         "portable-context": "portable-context";
                         "preparation-config": "preparation-config";
                         "compile-run": "compile-run";
+                        "artifact-checks": "artifact-checks";
                         "readiness-checks": "readiness-checks";
                         "checks-current": "checks-current";
                     }>;
@@ -349,6 +350,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                         "portable-context": "portable-context";
                         "preparation-config": "preparation-config";
                         "compile-run": "compile-run";
+                        "artifact-checks": "artifact-checks";
                         "readiness-checks": "readiness-checks";
                         "checks-current": "checks-current";
                     }>;
@@ -424,6 +426,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                     "portable-context": "portable-context";
                     "preparation-config": "preparation-config";
                     "compile-run": "compile-run";
+                    "artifact-checks": "artifact-checks";
                     "readiness-checks": "readiness-checks";
                     "checks-current": "checks-current";
                 }>;
@@ -471,6 +474,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                     "portable-context": "portable-context";
                     "preparation-config": "preparation-config";
                     "compile-run": "compile-run";
+                    "artifact-checks": "artifact-checks";
                     "readiness-checks": "readiness-checks";
                     "checks-current": "checks-current";
                 }>;
@@ -531,7 +535,7 @@ export type PreparationCompileRunListResponse = z.infer<typeof PreparationCompil
  * can render an actionable error rather than a stack trace.
  *
  * `issues` is typed as `unknown[]` so the class works across both
- * `zod` dependency trees in the monorepo (root + `apps/compiler-ui`).
+ * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
  * Callers cast or render structurally as needed.
  */
 export declare class WireShapeError extends Error {

package/dist/packages/engine/wire-schemas.js

@@ -36,7 +36,7 @@ export const PreparationCompileRunListResponseSchema = z.object({
  * can render an actionable error rather than a stack trace.
  *
  * `issues` is typed as `unknown[]` so the class works across both
- * `zod` dependency trees in the monorepo (root + `apps/compiler-ui`).
+ * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
  * Callers cast or render structurally as needed.
  */
 export class WireShapeError extends Error {

package/dist/packages/methods/authoring/method-authoring.d.ts

@@ -1,7 +1,7 @@
 import { type MethodAuthoringArtifactRequirement } from "../../engine/agents/lib/shells.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";
+import type { RequestedArtifact, SourceProfile, 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
@@ -27,6 +27,8 @@ export declare function runMethodAuthoringDraft(options: {
     hint: string;
     taskPrompt: string;
     checks?: SourceReadinessCheck[];
+    requestedArtifacts?: RequestedArtifact[];
+    sourceProfile?: SourceProfile | null;
     artifactRequirements?: MethodAuthoringArtifactRequirement[];
     executor: MethodExecutor;
     onStatus?: (line: string) => void;

package/dist/packages/methods/authoring/method-authoring.js

@@ -78,7 +78,7 @@ function buildMethodAuthoringPrompt() {
         "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
         "Put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks.",
         "Use only the CheckKind values listed in `runtime/authoring-context.json`; do not invent aliases.",
-        "Keep Artifact checks and the producing stage docs aligned: every checked output requirement must be described in the stage doc that writes that Artifact.",
+        "Keep Artifact checks aligned with produced outputs. Use stage docs to describe the output contract, but do not turn source-specific user wording into brittle stage-doc wording requirements.",
         "For every stage in `method.json`, create `method/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's kebab-case `skill_dir`.",
         "Every Artifact path in `method.schema.json` must be unique and non-overlapping.",
         "Make the package materially specific to this Preparation task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
@@ -116,39 +116,7 @@ function checkMatchesRequirement(actual, required) {
 function producingStagesForArtifact(definition, artifactId) {
     return (definition.stages ?? []).filter((stage) => Array.isArray(stage.writes) && stage.writes.includes(artifactId));
 }
-function readProducingStageDocs(methodPath, stages) {
-    return stages
-        .map((stage) => join(methodPath, "compile", "stages", stage.skill_dir ?? stage.id, "SKILL.md"))
-        .filter((filePath) => existsSync(filePath))
-        .map((filePath) => readFileSync(filePath, "utf8"))
-        .join("\n");
-}
-function validateMustContainStageDocs(methodPath, definition) {
-    const artifacts = definition.method_schema.artifacts ?? [];
-    const errors = [];
-    for (const artifact of artifacts) {
-        const producingStages = producingStagesForArtifact(definition, artifact.id);
-        if (producingStages.length === 0)
-            continue;
-        const producingStageDocs = readProducingStageDocs(methodPath, producingStages);
-        for (const check of artifact.checks ?? []) {
-            if (check.kind !== "must_contain")
-                continue;
-            const phrases = check.params?.phrases;
-            if (!Array.isArray(phrases))
-                continue;
-            for (const phrase of phrases) {
-                if (typeof phrase !== "string")
-                    continue;
-                if (!producingStageDocs.includes(phrase)) {
-                    errors.push(`Artifact \`${artifact.id}\` check \`${check.id}\` requires phrase not present in producing stage docs.`);
-                }
-            }
-        }
-    }
-    return errors;
-}
-function validateArtifactRequirements(methodPath, definition, requirements) {
+function validateArtifactRequirements(definition, requirements) {
     const artifacts = definition.method_schema.artifacts ?? [];
     const errors = [];
     for (const requirement of requirements) {
@@ -197,8 +165,7 @@ function validateAuthoredMethodPackage(methodPath, artifactRequirements = []) {
     if (placeholderPurpose) {
         errors.push("Authored Method still contains the neutral scaffold purpose.");
     }
-    errors.push(...validateArtifactRequirements(methodPath, definition, artifactRequirements));
-    errors.push(...validateMustContainStageDocs(methodPath, definition));
+    errors.push(...validateArtifactRequirements(definition, artifactRequirements));
     return {
         ok: validation.ok && errors.length === 0,
         summary: errors.length === 0
@@ -223,6 +190,8 @@ export async function runMethodAuthoringDraft(options) {
         sourceFolderPath: options.sourceFolderPath,
         taskPrompt: options.taskPrompt,
         checks: options.checks ?? [],
+        requestedArtifacts: options.requestedArtifacts ?? [],
+        sourceProfile: options.sourceProfile ?? null,
         artifactRequirements: options.artifactRequirements ?? [],
     });
     const session = await runMethodEditSession({

package/dist/packages/methods/package/builtin-compiled-method.js

@@ -28,7 +28,7 @@ const BuiltinMethodPackageSchema = z.object({
     stages: z.array(BuiltinMethodStageSchema).min(1),
 });
 let builtinCompiledContractCache = null;
-const BUILTIN_DEFAULT_METHOD_ROOT = join(PACKAGE_ROOT, "builtin-methods", "interf-default");
+const BUILTIN_DEFAULT_METHOD_ROOT = join(PACKAGE_ROOT, "public-repo", "methods", "interf-default");
 function assertBuiltinArtifactId(value) {
     if (!BUILTIN_ARTIFACT_ID_SET.has(value)) {
         throw new Error(`Built-in Interf Method schema declares unsupported Artifact id "${value}".`);

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

@@ -43,6 +43,7 @@ export declare function mergeStagePolicyNotesForStages(stages: readonly {
 export declare function builtinMethodPackagePath(methodId: string): string;
 export declare function methodDefinitionPath(prepDataDir: string, id: string): string;
 export declare function loadMethodDefinitionFromDir(dirPath: string): LocalMethodDefinition | null;
+export declare function isNeutralScaffoldMethodDefinition(definition: Pick<LocalMethodDefinition, "purpose" | "stages" | "method_schema">): boolean;
 export declare function listLocalMethodDefinitions(prepDataDir: string): LocalMethodDefinition[];
 export declare function loadLocalMethodDefinition(prepDataDir: string, id: string): LocalMethodDefinition | null;
 export declare function resolveMethodPackageSourcePath(prepDataDir: string, methodId: string): string | null;

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

@@ -66,7 +66,7 @@ function methodRootPath(prepDataDir) {
     return preparationMethodsRoot(asPreparationDataDir(prepDataDir));
 }
 export function builtinMethodPackagePath(methodId) {
-    return join(PACKAGE_ROOT, "builtin-methods", methodId);
+    return join(PACKAGE_ROOT, "public-repo", "methods", methodId);
 }
 export function methodDefinitionPath(prepDataDir, id) {
     return join(methodRootPath(prepDataDir), id);
@@ -139,6 +139,16 @@ export function loadMethodDefinitionFromDir(dirPath) {
         methodSchemaPath: contextInterfaceFilePath(dirPath),
     };
 }
+export function isNeutralScaffoldMethodDefinition(definition) {
+    const hasScaffoldPurpose = definition.purpose?.label === "From-scratch Method draft" ||
+        Boolean(definition.purpose?.task_hint?.includes("Replace this neutral scaffold"));
+    const hasScaffoldStage = Boolean(definition.stages?.some((stage) => stage.id === "prepare" &&
+        stage.contract_type === "method-draft-stage" &&
+        stage.writes.includes("draft-context")));
+    const hasScaffoldArtifact = listContextInterfaceArtifacts(definition.method_schema).some((artifact) => artifact.id === "draft-context" &&
+        artifact.description.includes("neutral authoring scaffold"));
+    return hasScaffoldPurpose || hasScaffoldStage || hasScaffoldArtifact;
+}
 export function listLocalMethodDefinitions(prepDataDir) {
     const definitions = new Map();
     const root = methodRootPath(prepDataDir);
@@ -152,18 +162,23 @@ export function listLocalMethodDefinitions(prepDataDir) {
                 continue;
             }
             const definition = loadMethodDefinitionFromDir(entryPath);
-            if (definition)
+            if (definition && !isNeutralScaffoldMethodDefinition(definition)) {
                 definitions.set(definition.id, definition);
+            }
         }
     }
     return [...definitions.values()].sort((a, b) => a.label.localeCompare(b.label));
 }
 export function loadLocalMethodDefinition(prepDataDir, id) {
-    return loadMethodDefinitionFromDir(methodDefinitionPath(prepDataDir, id));
+    const definition = loadMethodDefinitionFromDir(methodDefinitionPath(prepDataDir, id));
+    if (!definition || isNeutralScaffoldMethodDefinition(definition))
+        return null;
+    return definition;
 }
 export function resolveMethodPackageSourcePath(prepDataDir, methodId) {
     const localPath = methodDefinitionPath(prepDataDir, methodId);
-    if (loadMethodDefinitionFromDir(localPath))
+    const local = loadMethodDefinitionFromDir(localPath);
+    if (local && !isNeutralScaffoldMethodDefinition(local))
         return localPath;
     const builtinPath = builtinMethodPackagePath(methodId);
     if (loadMethodDefinitionFromDir(builtinPath))

package/dist/packages/methods/package/method-definitions.js

@@ -61,7 +61,7 @@ function getBuiltinDefaultMethod() {
         return builtinDefaultMethodCache;
     const local = loadMethodDefinitionFromDir(builtinMethodPackagePath(DEFAULT_METHOD_ID));
     if (!local) {
-        throw new Error(`Missing built-in Interf Method package at builtin-methods/${DEFAULT_METHOD_ID}.`);
+        throw new Error(`Missing built-in Interf Method package at public-repo/methods/${DEFAULT_METHOD_ID}.`);
     }
     const resolved = standaloneMethodDefinitionFromLocalPackage(local);
     builtinDefaultMethodCache = {

package/dist/packages/project/interf-detect.js

@@ -80,7 +80,7 @@ export function listPortableContextsForSourceFolder(prepDataDir) {
             return [];
     }
     catch (error) {
-        warnInterf(`Warning: failed to inspect Interf Workspace at ${prepDataDir}: ${error instanceof Error ? error.message : String(error)}`);
+        warnInterf(`Warning: failed to inspect Interf preparation data folder at ${prepDataDir}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
     return readdirSync(prepDataDir)
@@ -100,7 +100,7 @@ export function assertCompiledContainer(prepDataDir) {
     if (existsSync(prepDataDir)) {
         const stat = statSync(prepDataDir);
         if (!stat.isDirectory()) {
-            throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
+            throw new Error(`Interf preparation data folder exists and is not a directory: ${prepDataDir}`);
         }
         const unexpectedRootEntries = readdirSync(prepDataDir).filter((entry) => {
             if (entry.startsWith("."))
@@ -121,7 +121,7 @@ export function assertCompiledContainer(prepDataDir) {
                     return !statSync(entryPath).isDirectory();
                 }
                 catch (error) {
-                    warnInterf(`Warning: failed to inspect Interf Workspace path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    warnInterf(`Warning: failed to inspect Interf preparation data path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
                     return true;
                 }
             }
@@ -134,7 +134,7 @@ export function assertCompiledContainer(prepDataDir) {
             }
         });
         if (unexpectedRootEntries.length > 0) {
-            throw new Error(`Interf Workspace contains unexpected entries: ${prepDataDir}`);
+            throw new Error(`Interf preparation data folder contains unexpected entries: ${prepDataDir}`);
         }
     }
     if (!existsSync(prepDataDir)) {
@@ -142,7 +142,7 @@ export function assertCompiledContainer(prepDataDir) {
     }
     const stat = statSync(prepDataDir);
     if (!stat.isDirectory()) {
-        throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
+        throw new Error(`Interf preparation data folder exists and is not a directory: ${prepDataDir}`);
     }
     const unexpectedEntries = readdirSync(prepDataDir).filter((entry) => {
         if (entry.startsWith("."))
@@ -172,7 +172,7 @@ export function assertCompiledContainer(prepDataDir) {
         return false;
     });
     if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf Workspace contains invalid Preparation entries: ${prepDataDir}`);
+        throw new Error(`Interf preparation data folder contains invalid Preparation entries: ${prepDataDir}`);
     }
     return prepDataDir;
 }

package/dist/packages/project/lib/schema.d.ts

@@ -14,6 +14,95 @@ export declare const SourceReadinessCheckSchema: z.ZodObject<{
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const RequestedArtifactCheckSchema: z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$loose>;
+export declare const RequestedArtifactOutputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    shape: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"path">;
+        path: z.ZodString;
+        artifact_kind: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+        }>;
+    }, z.core.$strict>>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            file_exists: "file_exists";
+            min_file_count: "min_file_count";
+            min_file_count_matches_source: "min_file_count_matches_source";
+            frontmatter_valid: "frontmatter_valid";
+            frontmatter_required_keys: "frontmatter_required_keys";
+            wikilinks_valid: "wikilinks_valid";
+            must_not_contain: "must_not_contain";
+            must_contain: "must_contain";
+            qa_match: "qa_match";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    stage_hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RequestedArtifactSchema: z.ZodPreprocess<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$loose>]>>>;
+    output: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        stage_hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const SourceProfileItemSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    page_count: z.ZodOptional<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const SourceProfileSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        page_count: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
 export declare const SourcePreparationConfigSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
@@ -35,6 +124,56 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        purpose: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$loose>]>>>;
+        output: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            shape: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"path">;
+                path: z.ZodString;
+                artifact_kind: z.ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+            }, z.core.$strict>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    file_exists: "file_exists";
+                    min_file_count: "min_file_count";
+                    min_file_count_matches_source: "min_file_count_matches_source";
+                    frontmatter_valid: "frontmatter_valid";
+                    frontmatter_required_keys: "frontmatter_required_keys";
+                    wikilinks_valid: "wikilinks_valid";
+                    must_not_contain: "must_not_contain";
+                    must_contain: "must_contain";
+                    qa_match: "qa_match";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            stage_hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    source_profile: z.ZodOptional<z.ZodObject<{
+        summary: z.ZodOptional<z.ZodString>;
+        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            page_count: z.ZodOptional<z.ZodNumber>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
 }, z.core.$strict>;
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
@@ -124,10 +263,64 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             strictness: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            title: z.ZodString;
+            purpose: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$loose>]>>>;
+            output: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                shape: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodLiteral<"path">;
+                    path: z.ZodString;
+                    artifact_kind: z.ZodEnum<{
+                        file: "file";
+                        directory: "directory";
+                    }>;
+                }, z.core.$strict>>;
+                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodEnum<{
+                        file_exists: "file_exists";
+                        min_file_count: "min_file_count";
+                        min_file_count_matches_source: "min_file_count_matches_source";
+                        frontmatter_valid: "frontmatter_valid";
+                        frontmatter_required_keys: "frontmatter_required_keys";
+                        wikilinks_valid: "wikilinks_valid";
+                        must_not_contain: "must_not_contain";
+                        must_contain: "must_contain";
+                        qa_match: "qa_match";
+                    }>;
+                    description: z.ZodOptional<z.ZodString>;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                stage_hint: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        source_profile: z.ZodOptional<z.ZodObject<{
+            summary: z.ZodOptional<z.ZodString>;
+            items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+                kind: z.ZodOptional<z.ZodString>;
+                page_count: z.ZodOptional<z.ZodNumber>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
+export type RequestedArtifactCheck = z.infer<typeof RequestedArtifactCheckSchema>;
+export type RequestedArtifact = z.infer<typeof RequestedArtifactSchema>;
+export type RequestedArtifactOutput = z.infer<typeof RequestedArtifactOutputSchema>;
 export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
+export type SourceProfile = z.infer<typeof SourceProfileSchema>;
 export type PreparationName = z.infer<typeof PreparationNameSchema>;
 export type MethodId = z.infer<typeof MethodIdSchema>;
 export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;

package/dist/packages/project/lib/schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { isAbsolute, normalize } from "node:path";
-import { InterfIdPattern, MethodIdSchema, PreparationNameSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
+import { ArtifactPathShapeSchema, CheckSchema, InterfIdPattern, MethodIdSchema, PreparationNameSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
 export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 /**
  * Absolute paths that an attacker-controlled config must never reach. The
@@ -45,6 +45,49 @@ export const SourceReadinessCheckSchema = z.object({
         });
     }
 });
+export const RequestedArtifactCheckSchema = z.object({
+    label: z.string().min(1),
+}).passthrough();
+export const RequestedArtifactOutputSchema = z.object({
+    path: z.string().min(1).optional(),
+    shape: ArtifactPathShapeSchema.optional(),
+    checks: z.array(CheckSchema).default([]),
+    stage_hint: z.string().min(1).optional(),
+}).strict();
+const RequestedArtifactObjectSchema = z.object({
+    id: z.string().min(1).optional(),
+    title: z.string().min(1),
+    purpose: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
+    checks: z.array(z.union([z.string().min(1), RequestedArtifactCheckSchema])).default([]),
+    output: RequestedArtifactOutputSchema.optional(),
+}).strict();
+export const RequestedArtifactSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    if (typeof record.title === "string" && record.title.trim().length > 0)
+        return value;
+    const title = typeof record.label === "string"
+        ? record.label
+        : typeof record.name === "string"
+            ? record.name
+            : null;
+    return title ? { ...record, title } : value;
+}, RequestedArtifactObjectSchema);
+export const SourceProfileItemSchema = z.object({
+    name: z.string().min(1).optional(),
+    path: z.string().min(1).optional(),
+    kind: z.string().min(1).optional(),
+    page_count: z.number().int().nonnegative().optional(),
+    note: z.string().min(1).optional(),
+}).passthrough();
+export const SourceProfileSchema = z.object({
+    summary: z.string().min(1).optional(),
+    items: z.array(SourceProfileItemSchema).default([]),
+    observations: z.array(z.string().min(1)).default([]),
+    limitations: z.array(z.string().min(1)).default([]),
+}).passthrough();
 export const SourcePreparationConfigSchema = z.object({
     id: z.string().regex(InterfIdPattern).optional(),
     name: PreparationNameSchema,
@@ -62,6 +105,8 @@ export const SourcePreparationConfigSchema = z.object({
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    requested_artifacts: z.array(RequestedArtifactSchema).optional(),
+    source_profile: SourceProfileSchema.optional(),
 }).strict();
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),

package/dist/packages/project/source-config.js

@@ -128,6 +128,10 @@ function toWritableSourcePreparationConfig(preparation) {
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
+        ...(preparation.requested_artifacts?.length
+            ? { requested_artifacts: preparation.requested_artifacts }
+            : {}),
+        ...(preparation.source_profile ? { source_profile: preparation.source_profile } : {}),
     };
 }
 export function saveSourceFolderConfig(prepDataDir, config) {

package/dist/packages/project/source-folders.js

@@ -47,7 +47,7 @@ export function normalizeSourcePreparationPathForConfig(prepDataDir, value) {
     const resolvedPath = resolveSourcePreparationPath(prepDataDir, { path: trimmedValue });
     const relativePath = relative(prepDataDir, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
-        throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
+        throw new Error("Pick a Source Folder, not the Interf preparation data folder itself.");
     }
     if (isAbsolute(trimmedValue) && !isPathWithinRoot(prepDataDir, resolvedPath)) {
         if (!existsSync(resolvedPath)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.18.0",
-  "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
+  "version": "0.21.0",
+  "description": "Interf compiles source files into verifiable Artifacts and writes portable context agents can read.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -19,11 +19,11 @@
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('.tsbuildinfo',{force:true})\" && tsc && chmod 755 dist/bin.js",
     "dev": "tsc --watch",
-    "web:dev": "npm --prefix apps/compiler-ui run dev",
-    "web:typecheck": "npm --prefix apps/compiler-ui run typecheck",
+    "web:dev": "npm --prefix src/apps/compiler-ui run dev",
+    "web:typecheck": "npm --prefix src/apps/compiler-ui run typecheck",
     "web:build": "node scripts/web/build-compiler-ui.mjs",
-    "docs:sync-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs",
-    "docs:check-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs --check",
+    "docs:sync-public": "node scripts/docs/sync-public-repo.mjs",
+    "docs:check-public": "node scripts/docs/sync-public-repo.mjs --check",
     "test:smoke": "npm run build && node --test test/**/*.test.mjs",
     "test": "npm run test:smoke",
     "test:full": "npm test && npm run web:build",
@@ -40,8 +40,7 @@
   },
   "files": [
     "dist",
-    "builtin-methods",
-    "agent-skills",
+    "public-repo",
     "LICENSE.md",
     "TRADEMARKS.md"
   ],