@interf/compiler 0.9.5 → 0.13.0

package/dist/packages/testing/readiness-check-run.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { buildTestSpecFromCompiledPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveSourcePreparationPath, } from "../project-model/source-config.js";
-import { preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, portableContextPath, } from "../project-model/project-paths.js";
+import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
 import { testRootForCompiled } from "../compiler/compiled-paths.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
 import { resolveMethodId } from "../methods/method-resolution.js";
-import { createCompiledTestTarget, createRawTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
+import { createCompiledTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -28,9 +28,9 @@ function summarizeSavedTestOutcome(label, outcome) {
     };
 }
 function writePreparationTargetRun(options) {
-    const dirPath = preparationTestRunsRoot(options.projectPath, options.preparationName, options.target);
+    const dirPath = preparationTestRunsRoot(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target);
     mkdirSync(dirPath, { recursive: true });
-    const runPath = preparationTestRunPath(options.projectPath, options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    const runPath = preparationTestRunPath(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
     writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
     return runPath;
 }
@@ -41,23 +41,23 @@ function renderLatestSummaryMarkdown(payload) {
         "| Target | Readiness checks |",
         "| --- | --- |",
     ];
-    if (payload.raw) {
-        lines.push(`| Source files | \`${payload.raw.passed_cases}/${payload.raw.total_cases}\` |`);
+    if (payload.source_files) {
+        lines.push(`| Source files | \`${payload.source_files.passed_cases}/${payload.source_files.total_cases}\` |`);
     }
     if (payload.compiled) {
         lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
     }
     lines.push("");
-    if (payload.raw) {
-        lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
+    if (payload.source_files) {
+        lines.push(`- Latest source-files run: ${payload.source_files.run_path}`);
     }
     if (payload.compiled) {
         lines.push(`- Latest portable-context run: ${payload.compiled.run_path}`);
     }
     return `${lines.join("\n")}\n`;
 }
-export function readSavedReadinessCheckRun(projectPath, preparationName) {
-    const latestPath = preparationLatestReadinessRunPath(projectPath, preparationName);
+export function readSavedReadinessCheckRun(prepDataDir, preparationName) {
+    const latestPath = preparationLatestReadinessRunPath(asPreparationDataDir(prepDataDir), preparationName);
     if (!existsSync(latestPath))
         return null;
     return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
@@ -70,7 +70,7 @@ export function readReadinessCheckRunAtPath(filePath, label = "readiness-check r
     return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
 }
 export function readCurrentSavedReadinessCheckRun(options) {
-    const latestRun = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
+    const latestRun = readSavedReadinessCheckRun(options.prepDataDir, options.preparationName);
     if (!latestRun) {
         return { readinessRun: null, stale: false };
     }
@@ -82,19 +82,19 @@ export function readCurrentSavedReadinessCheckRun(options) {
 }
 export function saveReadinessCheckRun(options) {
     const generatedAt = new Date().toISOString();
-    const rawSummary = options.rawOutcome
-        ? summarizeSavedTestOutcome("Source files", options.rawOutcome)
+    const sourceFilesSummary = options.sourceFilesOutcome
+        ? summarizeSavedTestOutcome("Source files", options.sourceFilesOutcome)
         : null;
     const compiledSummary = options.compiledOutcome
         ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
         : null;
-    const effectiveMode = rawSummary && compiledSummary
+    const effectiveMode = sourceFilesSummary && compiledSummary
         ? "both"
-        : rawSummary
-            ? "raw"
+        : sourceFilesSummary
+            ? "source-files"
             : "compiled";
-    const rawPassRate = rawSummary
-        ? Math.round((rawSummary.passed_cases / rawSummary.total_cases) * 100)
+    const sourceFilesPassRate = sourceFilesSummary
+        ? Math.round((sourceFilesSummary.passed_cases / sourceFilesSummary.total_cases) * 100)
         : null;
     const compiledPassRate = compiledSummary
         ? Math.round((compiledSummary.passed_cases / compiledSummary.total_cases) * 100)
@@ -110,17 +110,17 @@ export function saveReadinessCheckRun(options) {
             name: options.preparationName,
             portable_context_path: options.portableContextPath,
         },
-        raw: rawSummary,
+        source_files: sourceFilesSummary,
         compiled: compiledSummary,
         summary: {
-            source_files_pass_rate: rawPassRate,
+            source_files_pass_rate: sourceFilesPassRate,
             portable_context_pass_rate: compiledPassRate,
         },
     };
-    const latestStatePath = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
+    const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationName);
     mkdirSync(dirname(latestStatePath), { recursive: true });
     writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
-    writeFileSync(preparationLatestReadinessSummaryPath(options.sourcePath, options.preparationName), renderLatestSummaryMarkdown(payload));
+    writeFileSync(preparationLatestReadinessSummaryPath(asPreparationDataDir(options.sourcePath), options.preparationName), renderLatestSummaryMarkdown(payload));
     if (options.portableContextPath) {
         mkdirSync(testRootForCompiled(options.portableContextPath), { recursive: true });
         writeFileSync(join(testRootForCompiled(options.portableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
@@ -129,15 +129,15 @@ export function saveReadinessCheckRun(options) {
 }
 export async function runSavedSourceFilesCheck(options) {
     const spec = buildTestSpecFromSourceFolderConfig({
-        sourcePath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         targetName: options.preparationConfig.name,
-        targetType: "raw",
+        targetType: "source-files",
     });
     if (!spec)
         return null;
     const sourceFolderPath = resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
-    const target = createRawTestTarget(sourceFolderPath);
-    const artifactRoot = preparationLatestReadinessRunPath(options.sourcePath, options.preparationConfig.name);
+    const target = createSourceFilesTestTarget(sourceFolderPath);
+    const artifactRoot = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationConfig.name);
     const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
         executor: options.executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
@@ -147,9 +147,9 @@ export async function runSavedSourceFilesCheck(options) {
     if (!result)
         return null;
     const preparationRunPath = writePreparationTargetRun({
-        projectPath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
-        target: "file-as-is",
+        target: "source-files",
         generatedAt: run.generated_at,
         runId: normalizePreparationTestRunId(spec.id),
         runSuffix: options.runSuffix,
@@ -183,7 +183,7 @@ export async function runSavedPortableContextCheck(options) {
         return null;
     const compiledRunPath = saveTargetTestRun(portableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
-        projectPath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
         target: "compiled",
         generatedAt: run.generated_at,
@@ -199,7 +199,7 @@ export async function runSavedPortableContextCheck(options) {
     };
 }
 export async function runReadinessChecksForExecutor(options) {
-    const rawPromise = options.mode === "raw" || options.mode === "both"
+    const sourceFilesPromise = options.mode === "source-files" || options.mode === "both"
         ? runSavedSourceFilesCheck({
             sourcePath: options.sourcePath,
             preparationConfig: options.preparationConfig,
@@ -218,10 +218,10 @@ export async function runReadinessChecksForExecutor(options) {
             runSuffix: options.runSuffix,
         })
         : Promise.resolve(null);
-    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
-    const modeSatisfied = (options.mode !== "raw" || Boolean(rawOutcome)) &&
+    const [sourceFilesOutcome, compiledOutcome] = await Promise.all([sourceFilesPromise, compiledPromise]);
+    const modeSatisfied = (options.mode !== "source-files" || Boolean(sourceFilesOutcome)) &&
         (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
-        (options.mode !== "both" || (Boolean(rawOutcome) && Boolean(compiledOutcome)));
+        (options.mode !== "both" || (Boolean(sourceFilesOutcome) && Boolean(compiledOutcome)));
     const shouldSave = options.saveLatest !== false;
     const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
@@ -230,7 +230,7 @@ export async function runReadinessChecksForExecutor(options) {
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
             mode: options.mode,
-            rawOutcome,
+            sourceFilesOutcome,
             compiledOutcome,
         })
         : null;
@@ -242,12 +242,12 @@ export async function runReadinessChecksForExecutor(options) {
         preparationConfig: options.preparationConfig,
         portableContextPath: options.portableContextPath,
         mode: options.mode,
-        rawOutcome,
+        sourceFilesOutcome,
         compiledOutcome,
         readinessRunPath,
         readinessRun,
     };
 }
 function portableContextPathForPreparation(sourcePath, preparationName) {
-    return portableContextPath(sourcePath, preparationName);
+    return preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationName);
 }

package/dist/packages/testing/test-execution.js

@@ -201,16 +201,16 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this portable context.",
             "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the Method-declared portable-context outputs before consulting `raw/`.",
-            "This sandbox is self-contained: the copied portable context has sanitized source files under `raw/` via `.interf/interf.json` `source.path`.",
-            "The original Interf Workspace is intentionally absent from this sandbox. Work only from this sandboxed portable context and its embedded raw files.",
+            "Prefer the Method-declared portable-context outputs before consulting source references.",
+            "This sandbox is self-contained: the copied portable context has source references in `.interf/runtime/source-snapshot.json`.",
+            "The original Interf Workspace is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
         ]
         : [
-            "You are running an Interf baseline test inside an isolated raw test shell.",
+            "You are running an Interf baseline test inside an isolated source-files test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
             "There is no portable context in this sandbox.",
-            "Answer only from `raw/` inside this shell.",
+            "Answer only from source references listed in `runtime/source-files.json` inside this shell.",
             "The original control plane folder is intentionally absent from this sandbox.",
         ];
     return [
@@ -218,7 +218,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
         "Emit only STATUS:, DONE:, BLOCKED:, or ERROR: lines.",
         "Do not ask follow-up questions.",
         `Write the answer to ${JSON.stringify(answerPath)}.`,
-        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_source_files, answer_summary.`,
+        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, source_paths_read, used_source_files, answer_summary.`,
         `Set \`case_id\` to ${JSON.stringify(testCase.id)}.`,
         `Set \`target\` to ${JSON.stringify(target.type)}.`,
         `Question: ${testCase.question}`,

package/dist/packages/testing/test-paths.js

@@ -1,10 +1,11 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { asPreparationDataDir, preparationTestsSpecsRoot, } from "../contracts/lib/preparation-paths.js";
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
 export function testSpecRootPath(sourcePath) {
-    return join(sourcePath, "interf", "tests", "specs");
+    return preparationTestsSpecsRoot(asPreparationDataDir(sourcePath));
 }
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
@@ -18,7 +19,7 @@ export function targetTestRunsPath(compiledPath, type) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
     if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
+        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "runs");
     }
     throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
@@ -30,7 +31,7 @@ export function targetTestSandboxesPath(compiledPath, type) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
     if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "sandboxes");
     }
     throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }

package/dist/packages/testing/test-sandbox.d.ts

@@ -2,7 +2,6 @@ import type { TestTargetCandidate } from "./test-types.js";
 export type TestSandboxRetentionMode = "on-failure" | "always";
 export interface TestSandbox {
     rootPath: string;
-    rawPath: string;
     targetPath: string;
     compiledPath: string | null;
     preserve(destinationPath: string): string;

package/dist/packages/testing/test-sandbox.js

@@ -1,17 +1,14 @@
-import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, relative, sep } from "node:path";
+import { dirname, join } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig } from "../project-model/interf.js";
-import { projectRawTestQueryShell } from "../agents/lib/shells.js";
-import { portableContextPath } from "../project-model/project-paths.js";
+import { readInterfConfig, resolveSourceInputPath } from "../project-model/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 { projectRawSnapshot, resolveCompiledRawPath } from "../compiler/raw-snapshot.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";
-function toPortableRelativePath(fromPath, toPath) {
-    return relative(fromPath, toPath).split(sep).join("/");
-}
 function sanitizeCompiledArtifacts(compiledPath) {
     for (const absolutePath of [
         testRootForCompiled(compiledPath),
@@ -28,16 +25,14 @@ export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
     const sandboxCompiledPath = () => (target.type === "compiled"
-        ? portableContextPath(sandboxRoot, target.name)
+        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : null);
-    const sandboxRawPath = () => (target.type === "compiled"
-        ? join(portableContextPath(sandboxRoot, target.name), "raw")
-        : join(sandboxRoot, "raw"));
     const sandboxTargetPath = () => (target.type === "compiled"
-        ? portableContextPath(sandboxRoot, target.name)
+        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : sandboxRoot);
     try {
         if (target.type === "compiled") {
+            const sourceInputPath = resolveSourceInputPath(target.path);
             mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
             cpSync(target.path, sandboxTargetPath(), { recursive: true });
             sanitizeCompiledArtifacts(sandboxTargetPath());
@@ -45,29 +40,21 @@ export function createTestSandbox(target) {
             if (!sandboxConfig) {
                 throw new Error(`Sandbox portable context is missing interf.json: ${sandboxTargetPath()}`);
             }
-            if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                throw new Error(`Sandbox portable context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the portable context before testing it.`);
-            }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
-                    path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                    path: sourceInputPath,
+                    preparation_path: sourceInputPath,
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());
             refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
         }
         else {
-            projectRawSnapshot({
-                sourcePath: target.path,
-                destinationPath: sandboxRawPath(),
-                compiledPath: target.path,
-                mode: "link-or-copy",
-                prune: false,
-                preserveTimestamps: false,
-            });
-            projectRawTestQueryShell(sandboxTargetPath());
+            mkdirSync(join(sandboxTargetPath(), "runtime"), { recursive: true });
+            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(buildCompiledSourceFiles(sandboxTargetPath(), target.path), null, 2)}\n`);
+            projectSourceFilesTestQueryShell(sandboxTargetPath());
         }
     }
     catch (error) {
@@ -78,9 +65,6 @@ export function createTestSandbox(target) {
         get rootPath() {
             return sandboxRoot;
         },
-        get rawPath() {
-            return sandboxRawPath();
-        },
         get targetPath() {
             return sandboxTargetPath();
         },

package/dist/packages/testing/test-targets.d.ts

@@ -1,5 +1,5 @@
 import type { TestTargetCandidate } from "./test-types.js";
 export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
 export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
-export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
+export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;
 export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/packages/testing/test-targets.js

@@ -22,15 +22,15 @@ export function createCompiledTestTarget(compiledPath, compiledName, methodId =
         eligible: health.status === "compiled",
     };
 }
-export function createRawTestTarget(sourcePath) {
+export function createSourceFilesTestTarget(sourcePath) {
     return {
-        type: "raw",
-        name: "raw",
+        type: "source-files",
+        name: "source-files",
         path: sourcePath,
-        method: "raw",
+        method: "source-files",
         status: "compiled",
-        stage: "raw",
-        summary: "Run the checks against an isolated sandbox of the raw files.",
+        stage: "source-files",
+        summary: "Run the checks against source file references in an isolated test shell.",
         eligible: true,
     };
 }

package/dist/packages/testing/test.d.ts

@@ -1,4 +1,4 @@
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/dist/packages/testing/test.js

@@ -1,3 +1,3 @@
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.9.5",
+  "version": "0.13.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.",
   "type": "module",
   "bin": {
@@ -29,7 +29,7 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc && chmod 755 dist/bin.js",
+    "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",
@@ -54,7 +54,6 @@
     "dist",
     "builtin-methods",
     "agent-skills",
-    "CHANGELOG.md",
     "TRADEMARKS.md"
   ],
   "publishConfig": {
@@ -68,7 +67,7 @@
     "claude",
     "codex"
   ],
-  "license": "Apache-2.0",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/interf-labs/interf.git"

package/CHANGELOG.md

@@ -1,93 +0,0 @@
-# Changelog
-
-Interf follows practical release notes: what changed, why it matters, and what
-still needs cleanup. Dates use the local release date.
-
-## 0.9.5 - 2026-05-02
-
-### Changed
-
-- Made the local service the execution gate for observable work. Prepare runs,
-  readiness-check runs, and agent-backed work now route through service-owned
-  run resources so CLI and UI see the same status.
-- Centralized user action definitions under the local-service package. UI
-  dialogs and CLI flows should render the same TypeScript/Zod-backed action
-  contract instead of carrying duplicate labels, prompts, and request fields.
-- Separated structured UI controls from freeform chat. Buttons submit typed
-  service requests; chat remains an explicit proposal surface.
-- Tightened Method removal. Removing a Method clears stale saved Preparation
-  selections instead of blocking on old references; preparing still requires an
-  explicit Method.
-- Expanded smoke coverage around CLI behavior, service-backed actions,
-  Method mutations, run visibility, and package boundary rules.
-
-### Fixed
-
-- Removed the UI path that pasted prepare prompts into chat instead of running
-  the typed prepare action.
-- Fixed action dialog/menu event handling so form input focus does not close the
-  parent row menu.
-- Fixed service and CLI behavior that could hide observable work in package
-  calls instead of a visible run.
-
-### Still To Watch
-
-- `apps/compiler-ui/app/page.tsx` and `src/packages/local-service/runtime.ts`
-  are still too large. Future cleanup should split them only when it reduces
-  reader trace depth or state in memory.
-- Some lower-level tests and package helpers still call package primitives
-  directly. That is correct for unit tests and package oracles; it is wrong for
-  user-visible prepare/check/Method actions.
-- Any remaining compatibility path for old product nouns should be listed for
-  founder review before removal. Do not add new compatibility shims unless the
-  current product contract requires them.
-
-## 0.9.4 - 2026-05-01
-
-### Changed
-
-- Kept setup separate from prepare runs. Creating or editing a Preparation is a
-  deterministic config action; preparing files is a visible run.
-- Simplified retry behavior by removing the partial stage-retry path. A prepare
-  run should be understandable from one run record and one filesystem state.
-- Stabilized trace rendering for active and failed runs, including failed-stage
-  layout and pending-run navigation.
-- Improved portable-context status and expected-output display so the UI
-  distinguishes current output from Method-planned output.
-
-### Fixed
-
-- Repaired missing local Method packages before prepare runs when the selected
-  Method can be reseeded from the current Interf Workspace.
-- Fixed packaged UI availability after local builds.
-- Accepted relative portable-context wikilinks and markdown-source summary links
-  during validation.
-- Stabilized the publish smoke gate environment.
-
-## 0.9.3 - 2026-04-30
-
-### Changed
-
-- Completed the public Preparation/Method vocabulary pass across CLI, service,
-  UI state, runtime records, docs, and tests.
-- Removed legacy 0.8 compatibility surfaces and project-model compiler shims
-  that forced readers to translate old product terms.
-- Moved package boundaries toward one owner per primitive: contracts for shared
-  schemas, project-model for Interf Workspace config, compiler for portable
-  context writes, testing for readiness-check runs, and local-service for read
-  models.
-- Added the source reader map in `src/README.md` so contributors can trace
-  `interf compile` without grepping through the whole repo first.
-- Expanded public CLI smoke coverage and release acceptance checks.
-
-### Fixed
-
-- Fixed release readiness blockers around CLI parsing, status output,
-  verification, UI layout, executor acceptance, and package metadata.
-- Served Interf Compiler UI from the static export used by `interf web`.
-
-### Cleanup Principle
-
-Every 0.9 patch is judged by one rubric: reduce the number of files a reader
-must trace, or reduce the number of facts a reader must hold in memory. If a
-change does neither, it should not be part of the cleanup.