@interf/compiler 0.3.4 → 0.4.0

package/dist/lib/schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { WORKSPACE_CONTRACT_TYPES, WORKSPACE_ZONE_KINDS, } from "./workflow-abi.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const WORKSPACE_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
 function isWorkspaceRelativePath(value) {
@@ -11,35 +12,13 @@ function isWorkspaceRelativePath(value) {
         .every((segment) => WORKSPACE_RELATIVE_PATH_SEGMENT.test(segment));
 }
 export const RuntimeTargetTypeSchema = z.enum(["workspace"]);
-export const BenchmarkTargetTypeSchema = z.enum(["workspace", "raw"]);
+export const TestTargetTypeSchema = z.enum(["workspace", "raw"]);
 export const WorkflowIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const RuntimeStageSchema = z.string().regex(WorkflowIdPattern);
-export const RuntimeContractTypeSchema = z.enum([
-    "workspace-file-evidence",
-    "workspace-knowledge-structure",
-    "workspace-query-shape",
-]);
+export const RuntimeContractTypeSchema = z.enum(WORKSPACE_CONTRACT_TYPES);
 export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkspaceInterfConfigSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        type: "workspace",
-        source: raw.source ?? { path: "./raw" },
-    };
-}, z.object({
-    type: z.literal("workspace"),
-    name: z.string(),
-    about: z.string().optional(),
-    workflow: WorkflowIdSchema.optional(),
-    source: z.object({
-        path: z.string(),
-    }),
-}).passthrough());
-export const InterfConfigSchema = WorkspaceInterfConfigSchema;
+export const WorkflowWorkspaceZoneKindSchema = z.enum(WORKSPACE_ZONE_KINDS);
 export const WorkspaceStateSchema = z.object({
     version: z.literal(1),
     pending: z.array(z.string()),
@@ -138,7 +117,7 @@ export const WorkflowWorkspaceZoneSchema = z.object({
     path: z.string().min(1).refine(isWorkspaceRelativePath, {
         message: "Zone paths must stay inside the workspace root",
     }),
-    kind: z.enum(["directory", "file", "runtime"]),
+    kind: WorkflowWorkspaceZoneKindSchema,
     required: z.boolean(),
     owned_by: z.array(z.string().regex(WorkflowIdPattern)),
     description: z.string().min(1),
@@ -282,7 +261,7 @@ export const WorkspaceInventorySchema = z.union([
         summary_total: z.number().optional(),
     }),
 ]);
-export const BenchmarkCaseExpectSchema = z.object({
+export const TestCaseExpectSchema = z.object({
     must_include: z.array(z.string().min(1)).optional(),
     must_include_one_of: z.array(z.array(z.string().min(1)).min(1)).optional(),
     must_not_include: z.array(z.string().min(1)).optional(),
@@ -297,24 +276,24 @@ export const BenchmarkCaseExpectSchema = z.object({
     (value.must_not_include?.length ?? 0) > 0 ||
     value.min_words !== undefined ||
     value.max_words !== undefined, {
-    message: "Benchmark expectations must include at least one check",
+    message: "Test expectations must include at least one check",
 });
-const BenchmarkCaseCoreSchema = z.object({
+const TestCaseCoreSchema = z.object({
     id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,79}$/),
     question: z.string().min(1),
     file: z.string().min(1).optional(),
     answer: z.string().min(1).optional(),
-    expect: BenchmarkCaseExpectSchema.optional(),
+    expect: TestCaseExpectSchema.optional(),
     strictness: z.string().min(1).optional(),
 }).superRefine((value, ctx) => {
     if (!value.file && !value.answer && !value.expect) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "Benchmark checks need at least one of file, answer, or expect.",
+            message: "Test cases need at least one of file, answer, or expect.",
         });
     }
 });
-export const BenchmarkCaseSchema = z.preprocess((value) => {
+export const TestCaseSchema = z.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
     const raw = value;
@@ -323,14 +302,14 @@ export const BenchmarkCaseSchema = z.preprocess((value) => {
         question: raw.question ?? raw.check ?? raw.ask,
         answer: raw.answer ?? raw.expected ?? raw.pass_when,
     };
-}, BenchmarkCaseCoreSchema);
-const BenchmarkSpecCoreSchema = z.object({
-    type: BenchmarkTargetTypeSchema,
+}, TestCaseCoreSchema);
+const TestSpecCoreSchema = z.object({
+    type: TestTargetTypeSchema,
     name: z.string().min(1),
     description: z.string().min(1).optional(),
-    cases: z.array(BenchmarkCaseSchema).min(1),
+    cases: z.array(TestCaseSchema).min(1),
 });
-export const BenchmarkSpecSchema = z.preprocess((value) => {
+export const TestSpecSchema = z.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
     const raw = value;
@@ -339,12 +318,12 @@ export const BenchmarkSpecSchema = z.preprocess((value) => {
         type: raw.type ?? "workspace",
         cases: raw.cases ?? raw.checks,
     };
-}, BenchmarkSpecCoreSchema);
-export const SourceEvalCaseSchema = z.object({
+}, TestSpecCoreSchema);
+export const SourceTruthCheckSchema = z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
     question: z.string().min(1),
     answer: z.string().min(1).optional(),
-    expect: BenchmarkCaseExpectSchema.optional(),
+    expect: TestCaseExpectSchema.optional(),
     strictness: z.string().min(1).optional(),
 }).strict().superRefine((value, ctx) => {
     if (!value.answer && !value.expect) {
@@ -356,6 +335,7 @@ export const SourceEvalCaseSchema = z.object({
     }
 });
 export const SourceWorkspaceMaxAttemptsSchema = z.number().int().min(1).max(5);
+export const SourceWorkspaceMaxLoopsSchema = z.number().int().min(1).max(3);
 export const SourceWorkspaceConfigSchema = z.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
@@ -366,6 +346,7 @@ export const SourceWorkspaceConfigSchema = z.preprocess((value) => {
     return {
         ...raw,
         max_attempts: raw.max_attempts ?? legacyRetryPolicy?.max_attempts,
+        max_loops: raw.max_loops,
     };
 }, z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
@@ -373,8 +354,129 @@ export const SourceWorkspaceConfigSchema = z.preprocess((value) => {
     about: z.string().min(1).optional(),
     workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceWorkspaceMaxAttemptsSchema.optional(),
-    checks: z.array(SourceEvalCaseSchema).default([]),
+    max_loops: SourceWorkspaceMaxLoopsSchema.optional(),
+    checks: z.array(SourceTruthCheckSchema).default([]),
 }).strict());
+export const WorkspaceInterfConfigSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const raw = value;
+    return {
+        ...raw,
+        type: "workspace",
+        source: raw.source ?? { path: "./raw" },
+        checks: raw.checks ?? [],
+    };
+}, z.object({
+    type: z.literal("workspace"),
+    name: z.string(),
+    about: z.string().optional(),
+    workflow: WorkflowIdSchema.optional(),
+    max_attempts: SourceWorkspaceMaxAttemptsSchema.optional(),
+    max_loops: SourceWorkspaceMaxLoopsSchema.optional(),
+    checks: z.array(SourceTruthCheckSchema).default([]),
+    workflow_origin: z.object({
+        selected: WorkflowIdSchema,
+        local_draft: z.boolean().optional(),
+    }).optional(),
+    source: z.object({
+        path: z.string(),
+        control_path: z.string().optional(),
+    }),
+}).passthrough());
+export const InterfConfigSchema = WorkspaceInterfConfigSchema;
+export const WorkflowImprovementLoopSummarySchema = z.object({
+    variation: z.number().int().min(1),
+    kind: z.enum(["baseline", "edited"]),
+    attempts_run: z.number().int().min(1),
+    passed: z.boolean(),
+    passed_questions: z.number().int().min(0),
+    total_questions: z.number().int().min(0),
+    failed_stage: z.string().nullable().optional(),
+    test_run_path: z.string().nullable().optional(),
+    test_sandbox_path: z.string().nullable().optional(),
+    summary: z.string().min(1),
+});
+export const WorkflowImprovementContextSchema = z.object({
+    kind: z.literal("interf-workflow-improvement-loop"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    workflow_id: WorkflowIdSchema,
+    loop_index: z.number().int().min(1),
+    max_loops: SourceWorkspaceMaxLoopsSchema,
+    max_attempts: SourceWorkspaceMaxAttemptsSchema,
+    review_paths: z.object({
+        workflow_root: z.string(),
+        workspace_runtime: z.string().nullable(),
+        test_comparisons: z.string().nullable(),
+        execution_shells: z.string().nullable(),
+        test_runs: z.string().nullable(),
+        test_sandboxes: z.string().nullable(),
+    }),
+    truth_checks: z.object({
+        count: z.number().int().min(0),
+        questions: z.array(z.object({
+            id: z.string(),
+            question: z.string(),
+        })),
+    }),
+    previous_variations: z.array(WorkflowImprovementLoopSummarySchema),
+    latest_failure: WorkflowImprovementLoopSummarySchema.nullable(),
+});
+export const PreservedShellTypeSchema = z.enum([
+    "stage-execution",
+    "workflow-improvement",
+]);
+export const PreservedShellSnapshotSchema = z.object({
+    kind: z.literal("interf-preserved-shell"),
+    version: z.literal(1),
+    shell_type: PreservedShellTypeSchema,
+    generated_at: z.string(),
+    root_path: z.string(),
+    materialized_symlinks: z.number().int().min(0),
+});
+export const WorkflowPackageValidationSchema = z.object({
+    ok: z.boolean(),
+    summary: z.string(),
+    errors: z.array(z.string()),
+    counts: z.record(z.string(), z.number()),
+});
+export const WorkflowImprovementLoopRecordSchema = z.object({
+    kind: z.literal("interf-workflow-improvement-loop-record"),
+    version: z.literal(1),
+    recorded_at: z.string(),
+    run_id: z.string(),
+    loop_index: z.number().int().min(1),
+    target_name: z.string(),
+    workflow_id: WorkflowIdSchema,
+    result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
+    changed: z.boolean(),
+    applied: z.boolean(),
+    summary: z.string(),
+    shell_path: z.string(),
+    loop_root_path: z.string(),
+    context_path: z.string(),
+    workflow_before_path: z.string(),
+    workflow_after_path: z.string(),
+    prompt_log_path: z.string(),
+    event_log_path: z.string(),
+    status_log_path: z.string(),
+    preserved_shell_manifest_path: z.string().nullable(),
+    validation: WorkflowPackageValidationSchema.nullable(),
+});
+export const WorkflowImprovementRunLedgerSchema = z.object({
+    kind: z.literal("interf-workflow-improvement-run"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    updated_at: z.string(),
+    run_id: z.string(),
+    target_name: z.string(),
+    workflow_id: WorkflowIdSchema,
+    max_loops: SourceWorkspaceMaxLoopsSchema,
+    max_attempts: SourceWorkspaceMaxAttemptsSchema,
+    loops: z.array(WorkflowImprovementLoopRecordSchema),
+});
 export const SourceFolderConfigSchema = z.object({
     workspaces: z.array(SourceWorkspaceConfigSchema).optional(),
 }).strict().superRefine((value, ctx) => {
@@ -385,12 +487,12 @@ export const SourceFolderConfigSchema = z.object({
         });
     }
 });
-export const BenchmarkCheckResultSchema = z.object({
+export const TestCheckResultSchema = z.object({
     label: z.string(),
     ok: z.boolean(),
     detail: z.string(),
 });
-export const BenchmarkCaseResultSchema = z.object({
+export const TestCaseResultSchema = z.object({
     caseId: z.string(),
     question: z.string(),
     file: z.string().optional(),
@@ -398,13 +500,13 @@ export const BenchmarkCaseResultSchema = z.object({
     wordCount: z.number(),
     passedChecks: z.number(),
     totalChecks: z.number(),
-    checks: z.array(BenchmarkCheckResultSchema),
+    checks: z.array(TestCheckResultSchema),
     answer: z.string().optional(),
     trace: JsonRecordSchema.nullable().optional(),
 });
-export const BenchmarkTargetResultSchema = z.object({
+export const TestTargetResultSchema = z.object({
     target: z.object({
-        type: BenchmarkTargetTypeSchema,
+        type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
         workflow: z.string(),
@@ -415,16 +517,16 @@ export const BenchmarkTargetResultSchema = z.object({
     totalCases: z.number(),
     passedChecks: z.number(),
     totalChecks: z.number(),
-    caseResults: z.array(BenchmarkCaseResultSchema),
+    caseResults: z.array(TestCaseResultSchema),
 });
-export const BenchmarkRunResultSchema = z.object({
-    kind: z.literal("interf-benchmark-run"),
+export const TestTargetRunSchema = z.object({
+    kind: z.literal("interf-test-target-run"),
     version: z.literal(1),
     generated_at: z.string(),
-    benchmark: z.object({
+    spec: z.object({
         id: z.string(),
         name: z.string(),
-        type: BenchmarkTargetTypeSchema,
+        type: TestTargetTypeSchema,
         file: z.string(),
         description: z.string().optional(),
         case_count: z.number(),
@@ -434,13 +536,47 @@ export const BenchmarkRunResultSchema = z.object({
             file: z.string().optional(),
             answer: z.string().optional(),
             strictness: z.string().optional(),
-            expect: BenchmarkCaseExpectSchema.optional(),
+            expect: TestCaseExpectSchema.optional(),
         })),
     }),
     source_path: z.string(),
     executor: RuntimeExecutorInfoSchema.optional(),
     target_count: z.number(),
-    results: z.array(BenchmarkTargetResultSchema),
+    results: z.array(TestTargetResultSchema),
+});
+export const TestRunModeSchema = z.enum(["raw", "workspace", "both"]);
+export const TestRunTargetSummarySchema = z.object({
+    label: z.string(),
+    run_path: z.string(),
+    ok: z.boolean(),
+    passed_cases: z.number(),
+    total_cases: z.number(),
+    passed_checks: z.number(),
+    total_checks: z.number(),
+    target: z.object({
+        type: TestTargetTypeSchema,
+        name: z.string(),
+        path: z.string(),
+        workflow: z.string(),
+    }),
+});
+export const TestRunComparisonSchema = z.object({
+    kind: z.literal("interf-test-run"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    mode: TestRunModeSchema,
+    source_path: z.string(),
+    workspace: z.object({
+        name: z.string(),
+        path: z.string(),
+    }),
+    raw: TestRunTargetSummarySchema.nullable(),
+    compiled_workspace: TestRunTargetSummarySchema.nullable(),
+    summary: z.object({
+        raw_pass_rate: z.number().nullable(),
+        compiled_pass_rate: z.number().nullable(),
+        pass_rate_delta: z.number().nullable(),
+    }),
 });
 export const InterfUserConfigSchema = z.object({
     agent: z.string(),
@@ -449,4 +585,3 @@ export const InterfUserConfigSchema = z.object({
     viewer: z.enum(["plain", "obsidian"]).optional(),
     initialized: z.string(),
 });
-//# sourceMappingURL=schema.js.map

package/dist/lib/source-config.d.ts

@@ -1,6 +1,6 @@
-import { type BenchmarkSpec, type BenchmarkTargetType, type SourceEvalCase, type SourceWorkspaceConfig, type SourceFolderConfig } from "./schema.js";
+import { type InterfConfig, type TestSpec, type TestTargetType, type SourceTruthCheck, type SourceWorkspaceConfig, type SourceFolderConfig } from "./schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.config.json";
-export interface LoadedSourceBenchmarkSpec extends BenchmarkSpec {
+export interface LoadedSourceTestSpec extends TestSpec {
     id: string;
     filePath: string;
 }
@@ -8,19 +8,28 @@ export declare function loadSourceFolderConfig(sourcePath: string): SourceFolder
 export interface WritableSourceFolderConfig {
     workspaces?: SourceWorkspaceConfig[];
 }
-export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceFolderConfig): void;
 export declare function listSourceWorkspaceConfigs(config: SourceFolderConfig | null): SourceWorkspaceConfig[];
 export declare function resolveWorkspaceCompileMaxAttempts(workspaceConfig: Pick<SourceWorkspaceConfig, "max_attempts">, override?: number | null): number | null;
+export declare function resolveWorkspaceCompileMaxLoops(workspaceConfig: Pick<SourceWorkspaceConfig, "max_loops">, override?: number | null): number | null;
 export declare function getDefaultSourceWorkspaceConfig(config: SourceFolderConfig | null): SourceWorkspaceConfig | null;
 export declare function findSourceWorkspaceConfig(config: SourceFolderConfig | null, workspaceName: string): SourceWorkspaceConfig | null;
-export declare function appendSourceWorkspaceChecks(sourcePath: string, workspaceName: string, checks: SourceEvalCase[]): void;
+export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceFolderConfig): void;
+export declare function appendSourceWorkspaceChecks(sourcePath: string, workspaceName: string, checks: SourceTruthCheck[]): void;
 export declare function upsertSourceWorkspaceConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig, options?: {
     matchName?: string;
 }): void;
 export declare function workspaceMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
-export declare function buildBenchmarkSpecFromSourceFolderConfig(options: {
+export declare function workspaceMaxLoops(maxLoops: number | null | undefined): number | undefined;
+export declare function sourceWorkspaceConfigFromInterfConfig(config: InterfConfig): SourceWorkspaceConfig;
+export declare function loadWorkspaceControlConfig(workspacePath: string): SourceWorkspaceConfig | null;
+export declare function saveWorkspaceInterfConfig(workspacePath: string, config: InterfConfig): InterfConfig;
+export declare function syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath: string, workspaceConfig: SourceWorkspaceConfig): InterfConfig;
+export declare function buildTestSpecFromSourceFolderConfig(options: {
     sourcePath: string;
     targetName?: string | null;
-    targetType?: BenchmarkTargetType;
-}): LoadedSourceBenchmarkSpec | null;
-//# sourceMappingURL=source-config.d.ts.map
+    targetType?: TestTargetType;
+}): LoadedSourceTestSpec | null;
+export declare function buildTestSpecFromWorkspaceConfig(options: {
+    workspacePath: string;
+    targetType?: TestTargetType;
+}): LoadedSourceTestSpec | null;

package/dist/lib/source-config.js

@@ -1,13 +1,17 @@
-import { existsSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { readInterfConfig, refreshWorkspaceBootstrapGuidance, resolveSourceControlPath, } from "./interf.js";
+import { seedWorkspaceWorkflowPackage } from "./interf-workflow-package.js";
 import { readJsonFileWithSchema } from "./parse.js";
+import { getWorkspaceWorkflow } from "./workflow-definitions.js";
 import { SourceFolderConfigSchema, } from "./schema.js";
 import { slugify } from "./util.js";
+import { defaultControlPathForWorkspace, workspaceInterfConfigPath, workspaceInterfRoot, } from "./workspace-paths.js";
 export const SOURCE_FOLDER_CONFIG_FILE = "interf.config.json";
 function sourceConfigPath(sourcePath) {
     return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
 }
-function normalizeEvalCases(cases) {
+function normalizeTruthChecks(cases) {
     const seen = new Set();
     return cases.map((caseSpec, index) => {
         const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
@@ -33,9 +37,6 @@ export function loadSourceFolderConfig(sourcePath) {
         return null;
     return readJsonFileWithSchema(filePath, "source-folder config", SourceFolderConfigSchema);
 }
-export function saveSourceFolderConfig(sourcePath, config) {
-    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(config, null, 2) + "\n");
-}
 export function listSourceWorkspaceConfigs(config) {
     return config?.workspaces ?? [];
 }
@@ -48,6 +49,15 @@ export function resolveWorkspaceCompileMaxAttempts(workspaceConfig, override = n
         return 1;
     return Math.min(5, normalized);
 }
+export function resolveWorkspaceCompileMaxLoops(workspaceConfig, override = null) {
+    const configured = override ?? workspaceConfig.max_loops ?? null;
+    if (configured == null)
+        return null;
+    const normalized = Math.trunc(configured);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(3, normalized);
+}
 export function getDefaultSourceWorkspaceConfig(config) {
     const workspaces = listSourceWorkspaceConfigs(config);
     return workspaces[0] ?? null;
@@ -62,14 +72,18 @@ function toWritableSourceFolderConfig(config) {
             workspaces: workspaces.map((workspace) => ({
                 name: workspace.name,
                 ...(workspace.about ? { about: workspace.about } : {}),
-                ...(workspace.workflow ? { workflow: workspace.workflow } : {}),
+                ...(workspace.workflow && workspace.workflow !== "interf" ? { workflow: workspace.workflow } : {}),
                 ...(typeof workspace.max_attempts === "number" ? { max_attempts: workspace.max_attempts } : {}),
+                ...(typeof workspace.max_loops === "number" ? { max_loops: workspace.max_loops } : {}),
                 checks: workspace.checks,
             })),
         };
     }
     return {};
 }
+export function saveSourceFolderConfig(sourcePath, config) {
+    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceFolderConfig(config), null, 2) + "\n");
+}
 export function appendSourceWorkspaceChecks(sourcePath, workspaceName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
     const currentWorkspace = findSourceWorkspaceConfig(existing, workspaceName);
@@ -84,6 +98,9 @@ export function appendSourceWorkspaceChecks(sourcePath, workspaceName, checks) {
                 ...(typeof currentWorkspace?.max_attempts === "number"
                     ? { max_attempts: currentWorkspace.max_attempts }
                     : {}),
+                ...(typeof currentWorkspace?.max_loops === "number"
+                    ? { max_loops: currentWorkspace.max_loops }
+                    : {}),
                 checks: [...currentChecks, ...checks],
             },
             ...otherWorkspaces,
@@ -110,7 +127,86 @@ export function workspaceMaxAttempts(maxAttempts) {
         return undefined;
     return resolveWorkspaceCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
 }
-export function buildBenchmarkSpecFromSourceFolderConfig(options) {
+export function workspaceMaxLoops(maxLoops) {
+    if (maxLoops == null)
+        return undefined;
+    return resolveWorkspaceCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+}
+export function sourceWorkspaceConfigFromInterfConfig(config) {
+    return {
+        name: config.name,
+        ...(config.about ? { about: config.about } : {}),
+        ...(config.workflow ? { workflow: config.workflow } : {}),
+        ...(typeof config.max_attempts === "number"
+            ? { max_attempts: config.max_attempts }
+            : {}),
+        ...(typeof config.max_loops === "number"
+            ? { max_loops: config.max_loops }
+            : {}),
+        checks: config.checks ?? [],
+    };
+}
+export function loadWorkspaceControlConfig(workspacePath) {
+    const config = readInterfConfig(workspacePath);
+    return config ? sourceWorkspaceConfigFromInterfConfig(config) : null;
+}
+export function saveWorkspaceInterfConfig(workspacePath, config) {
+    mkdirSync(workspaceInterfRoot(workspacePath), { recursive: true });
+    writeFileSync(workspaceInterfConfigPath(workspacePath), JSON.stringify(config, null, 2) + "\n");
+    return config;
+}
+export function syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath, workspaceConfig) {
+    const current = readInterfConfig(workspacePath);
+    const workflowId = workspaceConfig.workflow ?? current?.workflow ?? "interf";
+    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
+    const workflowOrigin = workflowChanged || !current?.workflow_origin
+        ? {
+            selected: workflowId,
+            local_draft: false,
+        }
+        : current.workflow_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+    const nextConfig = {
+        ...passthrough,
+        ...(!current ? {
+            type: "workspace",
+            source: {
+                path: "./raw",
+            },
+        } : {}),
+        type: "workspace",
+        name: workspaceConfig.name,
+        ...(workspaceConfig.about ? { about: workspaceConfig.about } : {}),
+        workflow: workflowId,
+        ...(typeof workspaceConfig.max_attempts === "number"
+            ? { max_attempts: workspaceConfig.max_attempts }
+            : {}),
+        ...(typeof workspaceConfig.max_loops === "number"
+            ? { max_loops: workspaceConfig.max_loops }
+            : {}),
+        checks: workspaceConfig.checks,
+        workflow_origin: workflowOrigin,
+        source: {
+            path: current?.source?.path ?? "./raw",
+            ...(current?.source?.control_path
+                ? { control_path: current.source.control_path }
+                : { control_path: defaultControlPathForWorkspace(workspacePath) }),
+        },
+    };
+    const saved = saveWorkspaceInterfConfig(workspacePath, nextConfig);
+    if (workflowChanged) {
+        const sourcePath = resolveSourceControlPath(workspacePath);
+        const selectedWorkflow = getWorkspaceWorkflow(workflowId, { sourcePath });
+        seedWorkspaceWorkflowPackage({
+            workspacePath,
+            sourcePath,
+            workflowId: selectedWorkflow.id,
+        });
+    }
+    refreshWorkspaceBootstrapGuidance(workspacePath);
+    return saved;
+}
+export function buildTestSpecFromSourceFolderConfig(options) {
     const { sourcePath, targetName, targetType = "workspace" } = options;
     const config = loadSourceFolderConfig(sourcePath);
     if (!config)
@@ -127,16 +223,34 @@ export function buildBenchmarkSpecFromSourceFolderConfig(options) {
     if (!match || workspaceChecks.length === 0)
         return null;
     const configPath = sourceConfigPath(sourcePath);
-    const benchmarkId = match.id ?? slugify(match.name);
+    const testId = match.id ?? slugify(match.name);
     return {
-        id: targetType === "raw" ? `${benchmarkId}-raw` : benchmarkId,
+        id: targetType === "raw" ? `${testId}-raw` : testId,
         filePath: targetType === "raw"
             ? `${configPath}#workspaces/${match.name}:raw`
             : `${configPath}#workspaces/${match.name}`,
         type: targetType,
         name: match.name,
         description: match.about ?? `Derived from dataset truth checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
-        cases: normalizeEvalCases(workspaceChecks),
+        cases: normalizeTruthChecks(workspaceChecks),
+    };
+}
+export function buildTestSpecFromWorkspaceConfig(options) {
+    const { workspacePath, targetType = "workspace" } = options;
+    const config = readInterfConfig(workspacePath);
+    const workspaceChecks = config?.checks ?? [];
+    if (!config || workspaceChecks.length === 0)
+        return null;
+    const testId = slugify(config.name);
+    const configPath = workspaceInterfConfigPath(workspacePath);
+    return {
+        id: targetType === "raw" ? `${testId}-raw` : testId,
+        filePath: targetType === "raw"
+            ? `${configPath}#checks:raw`
+            : `${configPath}#checks:workspace`,
+        type: targetType,
+        name: config.name,
+        description: config.about ?? "Derived from workspace truth checks.",
+        cases: normalizeTruthChecks(workspaceChecks),
     };
 }
-//# sourceMappingURL=source-config.js.map

package/dist/lib/state-artifacts.d.ts

@@ -6,4 +6,3 @@ export declare function refreshWorkspaceArtifacts(dirPath: string, options?: {
     viewSpec?: WorkspaceViewSpec;
     rawSnapshot: WorkspaceRawSnapshot;
 };
-//# sourceMappingURL=state-artifacts.d.ts.map

package/dist/lib/state-artifacts.js

@@ -11,4 +11,3 @@ export function refreshWorkspaceArtifacts(dirPath, options) {
     }
     return { health, viewSpec, rawSnapshot };
 }
-//# sourceMappingURL=state-artifacts.js.map

package/dist/lib/state-health.d.ts

@@ -2,4 +2,3 @@ import { type WorkspaceHealth, type WorkspaceState, type WorkspaceStage, type Ru
 export declare function computeWorkspaceHealth(dirPath: string): WorkspaceHealth;
 export declare function resolveWorkspaceStatus(sourceTotal: number, summarized: number, toSummarize: number, toStructure: number, toShape: number, errors: number, state: WorkspaceState): RuntimeStatus;
 export declare function resolveWorkspaceStage(state: WorkspaceState, sourceTotal: number, summarized: number, toSummarize: number, toStructure: number, toShape: number, errors: number): WorkspaceStage;
-//# sourceMappingURL=state-health.d.ts.map

package/dist/lib/state-health.js

@@ -5,8 +5,8 @@ import { discoverSourceFiles } from "./discovery.js";
 import { readInterfConfig, resolveSourceFolderPath, } from "./interf.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { validateWorkspace } from "./validate.js";
-import { STATE_DIR } from "./util.js";
 import { initWorkspaceState, loadState, } from "./state-io.js";
+import { workspaceRuntimeInventoryPath } from "./workspace-paths.js";
 export function computeWorkspaceHealth(dirPath) {
     const state = {
         ...initWorkspaceState(),
@@ -19,7 +19,7 @@ export function computeWorkspaceHealth(dirPath) {
     const sourcePath = resolveSourceFolderPath(dirPath, config);
     const discovery = discoverSourceFiles(sourcePath, dirPath);
     const summariesPresent = existsSync(join(dirPath, "summaries"));
-    const inventoryPresent = existsSync(join(dirPath, STATE_DIR, "inventory.json"));
+    const inventoryPresent = existsSync(workspaceRuntimeInventoryPath(dirPath));
     const homePresent = existsSync(join(dirPath, "home.md"));
     const outputs = countOutputFiles(dirPath);
     const outputsPresent = outputs > 0;
@@ -146,4 +146,3 @@ function countOutputFiles(dirPath) {
         join(dirPath, "knowledge", "indexes"),
     ].reduce((total, dir) => total + countFilesRecursive(dir), 0);
 }
-//# sourceMappingURL=state-health.js.map

package/dist/lib/state-io.d.ts

@@ -6,5 +6,5 @@ export declare function saveWorkspaceHealth(dirPath: string, health: WorkspaceHe
 export declare function loadWorkspaceViewSpec(dirPath: string): WorkspaceViewSpec | null;
 export declare function saveWorkspaceViewSpec(dirPath: string, viewSpec: WorkspaceViewSpec): void;
 export declare function loadWorkspaceRawSnapshot(dirPath: string): WorkspaceRawSnapshot | null;
+export declare function saveEmptyWorkspaceInventory(dirPath: string): void;
 export declare function initWorkspaceState(): WorkspaceState;
-//# sourceMappingURL=state-io.d.ts.map