freeharness 0.4.1

package/dist/infra/dogfood.d.ts

@@ -0,0 +1,31 @@
+/** Project-relative SDD workspace: `<change>/<task>.brief.md` and `<task>.review.md`. */
+export declare const SDD_DIR: string;
+/** Gitignore line for the transient SDD workspace (briefs, review packages). */
+export declare const SDD_GITIGNORE_LINE = ".freeharness/sdd/";
+/** Gitignore line for the project-scope agent-memory tree (`memory: project` agents). */
+export declare const AGENT_MEMORY_GITIGNORE_LINE = ".claude/agent-memory/";
+/** Gitignore line for the project-scope local agent-memory tree (`memory: local` agents). */
+export declare const AGENT_MEMORY_LOCAL_GITIGNORE_LINE = ".claude/agent-memory-local/";
+/**
+ * Ensures `.gitignore` contains `line` (exact line match, comments ignored). Creates the file
+ * when absent; appends otherwise; never removes or reorders anything.
+ * @param projectRoot Project root.
+ * @param line Line to guarantee.
+ * @param dryRun Report without writing.
+ * @returns Absolute `.gitignore` path and whether the line was added.
+ */
+export declare function ensureGitignoreLine(projectRoot: string, line: string, dryRun: boolean): {
+    path: string;
+    added: boolean;
+};
+/**
+ * Creates the SDD workspace directory when absent. Never recorded in the install manifest:
+ * briefs and review packages are the project's transient evidence, not ours to uninstall.
+ * @param projectRoot Project root.
+ * @param dryRun Report without writing.
+ * @returns Absolute path and whether the directory was created.
+ */
+export declare function ensureSddDir(projectRoot: string, dryRun: boolean): {
+    path: string;
+    created: boolean;
+};

package/dist/infra/dogfood.js

@@ -0,0 +1,51 @@
+// Project-scope evidence helpers. `init --scope project` creates `.freeharness/` and keeps
+// `.freeharness/sdd/` (the transient subagent-driven-development workspace: briefs and review
+// packages) out of git. The durable evidence is `.freeharness/telemetry.jsonl`, written by the
+// cost-tracker hook at session end; it is never seeded or read here, only documented in the
+// adapter's notes.
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir } from "./fsutil.js";
+/** Project-relative SDD workspace: `<change>/<task>.brief.md` and `<task>.review.md`. */
+export const SDD_DIR = path.join(".freeharness", "sdd");
+/** Gitignore line for the transient SDD workspace (briefs, review packages). */
+export const SDD_GITIGNORE_LINE = ".freeharness/sdd/";
+/** Gitignore line for the project-scope agent-memory tree (`memory: project` agents). */
+export const AGENT_MEMORY_GITIGNORE_LINE = ".claude/agent-memory/";
+/** Gitignore line for the project-scope local agent-memory tree (`memory: local` agents). */
+export const AGENT_MEMORY_LOCAL_GITIGNORE_LINE = ".claude/agent-memory-local/";
+/**
+ * Ensures `.gitignore` contains `line` (exact line match, comments ignored). Creates the file
+ * when absent; appends otherwise; never removes or reorders anything.
+ * @param projectRoot Project root.
+ * @param line Line to guarantee.
+ * @param dryRun Report without writing.
+ * @returns Absolute `.gitignore` path and whether the line was added.
+ */
+export function ensureGitignoreLine(projectRoot, line, dryRun) {
+    const file = path.join(projectRoot, ".gitignore");
+    const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    const present = current.split(/\r?\n/).some((l) => l.trim() === line || l.trim() === line.replace(/\/$/, ""));
+    if (present)
+        return { path: file, added: false };
+    if (!dryRun) {
+        ensureDir(projectRoot, false);
+        const sep = current === "" || current.endsWith("\n") ? "" : "\n";
+        fs.writeFileSync(file, `${current}${sep}${line}\n`, "utf8");
+    }
+    return { path: file, added: true };
+}
+/**
+ * Creates the SDD workspace directory when absent. Never recorded in the install manifest:
+ * briefs and review packages are the project's transient evidence, not ours to uninstall.
+ * @param projectRoot Project root.
+ * @param dryRun Report without writing.
+ * @returns Absolute path and whether the directory was created.
+ */
+export function ensureSddDir(projectRoot, dryRun) {
+    const dir = path.join(projectRoot, SDD_DIR);
+    if (fs.existsSync(dir))
+        return { path: dir, created: false };
+    ensureDir(dir, dryRun);
+    return { path: dir, created: true };
+}

package/dist/infra/fsutil.d.ts

@@ -0,0 +1,40 @@
+export declare function ensureDir(dir: string, dryRun: boolean): void;
+export declare function writeText(file: string, content: string, dryRun: boolean): string;
+export declare function readText(file: string): string;
+/** Seeds a file without clobbering one a team already maintains; skipped=true even under --dry-run. */
+export declare function writeTextIfAbsent(file: string, content: string, dryRun: boolean): {
+    path: string;
+    skipped: boolean;
+};
+/** Build artifacts, VCS metadata, Python bytecode: shared by copyDir and any caller walking a source tree with the same exclusion, so the two never drift. */
+export declare function isJunkEntry(name: string): boolean;
+/** Copies every file under src into dst; `transformOnly` gates which files `transform` reads as text (the rest copy raw, bytes and mode untouched; a transformed file's target is chmod'd to the source mode). */
+export declare function copyDir(src: string, dst: string, dryRun: boolean, opts?: {
+    skip?: (name: string) => boolean;
+    transform?: (content: string, name: string) => string;
+    transformOnly?: (name: string) => boolean;
+}): string[];
+export declare function copyExecutable(src: string, dst: string, dryRun: boolean): string;
+export interface HookEntry {
+    matcher?: string;
+    hooks: {
+        type: string;
+        command: string;
+        async?: boolean;
+        timeout?: number;
+    }[];
+}
+/** Additive, deduped by command; never removes existing entries, so claude-mem stays intact. */
+export declare function mergeClaudeHook(settingsPath: string, eventName: string, entry: HookEntry, dryRun: boolean): {
+    added: boolean;
+};
+/** A key is written only when absent, so a value the user (or another tool) set is never overwritten; `$comment` keys are never copied. */
+export declare function mergeSettingsKeys(settingsPath: string, entries: Record<string, unknown>, dryRun: boolean): {
+    added: string[];
+    kept: string[];
+};
+/** Marker file the config guard hook honors (`.freeharness/allow-config-edit`). */
+export declare const CONFIG_EDIT_MARKER = "allow-config-edit";
+export declare function configMarkerPath(scope: "user" | "project", projectRoot: string, home: string): string;
+/** Writes the marker with an explicit expiry unless one already exists (never replaced or removed); the closer removes it only when this call created it. */
+export declare function openConfigWindow(file: string, ttlMs?: number): () => void;

package/dist/infra/fsutil.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
+export function ensureDir(dir, dryRun) {
+    if (dryRun)
+        return;
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function writeText(file, content, dryRun) {
+    if (!dryRun) {
+        ensureDir(path.dirname(file), false);
+        fs.writeFileSync(file, content, "utf8");
+    }
+    return file;
+}
+export function readText(file) {
+    return fs.readFileSync(file, "utf8");
+}
+/** Seeds a file without clobbering one a team already maintains; skipped=true even under --dry-run. */
+export function writeTextIfAbsent(file, content, dryRun) {
+    if (fs.existsSync(file))
+        return { path: file, skipped: true };
+    if (!dryRun) {
+        ensureDir(path.dirname(file), false);
+        fs.writeFileSync(file, content, "utf8");
+    }
+    return { path: file, skipped: false };
+}
+const JUNK = new Set(["node_modules", "__pycache__", ".git", "dist", ".DS_Store"]);
+/** Build artifacts, VCS metadata, Python bytecode: shared by copyDir and any caller walking a source tree with the same exclusion, so the two never drift. */
+export function isJunkEntry(name) {
+    return JUNK.has(name) || name.endsWith(".pyc");
+}
+/** Copies every file under src into dst; `transformOnly` gates which files `transform` reads as text (the rest copy raw, bytes and mode untouched; a transformed file's target is chmod'd to the source mode). */
+export function copyDir(src, dst, dryRun, opts = {}) {
+    const written = [];
+    const walk = (rel) => {
+        const abs = path.join(src, rel);
+        for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+            if (isJunkEntry(entry.name))
+                continue;
+            const childRel = path.join(rel, entry.name);
+            if (entry.isDirectory()) {
+                walk(childRel);
+            }
+            else {
+                if (opts.skip?.(entry.name))
+                    continue;
+                const target = path.join(dst, childRel);
+                const srcFile = path.join(src, childRel);
+                const transform = opts.transform;
+                if (!dryRun) {
+                    ensureDir(path.dirname(target), false);
+                    if (transform !== undefined && (opts.transformOnly === undefined || opts.transformOnly(entry.name))) {
+                        writeText(target, transform(readText(srcFile), entry.name), false);
+                        fs.chmodSync(target, fs.statSync(srcFile).mode);
+                    }
+                    else {
+                        fs.copyFileSync(srcFile, target);
+                    }
+                }
+                written.push(target);
+            }
+        }
+    };
+    walk("");
+    return written;
+}
+export function copyExecutable(src, dst, dryRun) {
+    if (!dryRun) {
+        ensureDir(path.dirname(dst), false);
+        fs.copyFileSync(src, dst);
+        fs.chmodSync(dst, 0o755);
+    }
+    return dst;
+}
+/** Additive, deduped by command; never removes existing entries, so claude-mem stays intact. */
+export function mergeClaudeHook(settingsPath, eventName, entry, dryRun) {
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    }
+    settings.hooks ??= {};
+    settings.hooks[eventName] ??= [];
+    const arr = settings.hooks[eventName];
+    const ourCmd = entry.hooks[0].command;
+    const exists = arr.some((e) => e.hooks.some((h) => h.command === ourCmd));
+    if (!exists)
+        arr.push(entry);
+    if (!dryRun && !exists) {
+        ensureDir(path.dirname(settingsPath), false);
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    }
+    return { added: !exists };
+}
+/** A key is written only when absent, so a value the user (or another tool) set is never overwritten; `$comment` keys are never copied. */
+export function mergeSettingsKeys(settingsPath, entries, dryRun) {
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    }
+    const added = [];
+    const kept = [];
+    for (const [k, v] of Object.entries(entries)) {
+        if (k.startsWith("$"))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(settings, k))
+            kept.push(k);
+        else {
+            settings[k] = v;
+            added.push(k);
+        }
+    }
+    if (!dryRun && added.length > 0) {
+        ensureDir(path.dirname(settingsPath), false);
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    }
+    return { added, kept };
+}
+/** Marker file the config guard hook honors (`.freeharness/allow-config-edit`). */
+export const CONFIG_EDIT_MARKER = "allow-config-edit";
+export function configMarkerPath(scope, projectRoot, home) {
+    return scope === "user" ? path.join(home, ".claude", "freeharness", CONFIG_EDIT_MARKER) : path.join(projectRoot, ".freeharness", CONFIG_EDIT_MARKER);
+}
+/** Writes the marker with an explicit expiry unless one already exists (never replaced or removed); the closer removes it only when this call created it. */
+export function openConfigWindow(file, ttlMs = 10 * 60_000) {
+    if (fs.existsSync(file))
+        return () => undefined;
+    try {
+        ensureDir(path.dirname(file), false);
+        fs.writeFileSync(file, String(Date.now() + ttlMs), "utf8");
+    }
+    catch {
+        return () => undefined;
+    }
+    return () => {
+        try {
+            fs.rmSync(file, { force: true });
+        }
+        catch {
+            // best effort
+        }
+    };
+}

package/dist/infra/manifest.d.ts

@@ -0,0 +1,76 @@
+import type { AdapterResult, Scope } from "@freeharness/core";
+/** One emitted file (or directory) and the step that produced it. */
+export interface ManifestFile {
+    path: string;
+    capability: string;
+    target: string;
+}
+/** The persisted manifest shape. */
+export interface InstallManifest {
+    /** CLI version that last applied. */
+    version: string;
+    /** Short HEAD of the repo checkout that served the canonical source, when it was one. */
+    sourceCommit?: string;
+    scope: Scope;
+    targets: string[];
+    capabilities: string[];
+    /** First install (ISO). */
+    installedAt: string;
+    /** Last apply pass (ISO). */
+    updatedAt: string;
+    files: ManifestFile[];
+    /** Descriptions of the side-effecting actions that were run. */
+    actions: string[];
+    /** Opt-in profiles applied to this scope (v4 P6), by profile id. */
+    profiles?: Record<string, ProfileRecord>;
+}
+/** What one profile wrote, so `init --profile none` removes exactly that and nothing else. */
+export interface ProfileRecord {
+    target: string;
+    /** File that received the merge (settings.json or opencode.json). */
+    file: string;
+    /** Keys written by the profile (env keys, or `provider.<id>` for OpenCode). */
+    keys: string[];
+    /** Extra files written (notes), removed with the profile. */
+    files: string[];
+    appliedAt: string;
+}
+/**
+ * Resolves the manifest path for a scope.
+ * @param scope user | project.
+ * @param projectRoot Project root (project scope).
+ * @returns Absolute manifest path.
+ */
+export declare function manifestPath(scope: Scope, projectRoot: string): string;
+/**
+ * Reads a manifest when present.
+ * @param file Manifest path.
+ * @returns The parsed manifest, or undefined when absent/unreadable.
+ */
+export declare function readManifest(file: string): InstallManifest | undefined;
+/**
+ * Short HEAD of a repo checkout (git must be on PATH).
+ * @param repoRoot Checkout root.
+ * @returns The 8-char commit, or undefined.
+ */
+export declare function repoHead(repoRoot: string): string | undefined;
+/** Inputs for one apply pass, merged into the manifest. */
+export interface ManifestUpdate {
+    version: string;
+    sourceCommit?: string;
+    scope: Scope;
+    projectRoot: string;
+    targets: string[];
+    capabilities: string[];
+    results: AdapterResult[];
+    actions: string[];
+    /** Profile records to set (value) or drop (null); absent = untouched. */
+    profiles?: Record<string, ProfileRecord | null>;
+}
+/**
+ * Merges an apply pass into the manifest on disk (creating it) and registers the
+ * manifest file itself last. Files the adapters reported as skipped are never recorded.
+ * @param u The pass to record.
+ * @returns The manifest path.
+ */
+export declare function writeManifest(u: ManifestUpdate): string;

package/dist/infra/manifest.js

@@ -0,0 +1,92 @@
+// Install manifest: the record of what FreeHarness emitted into a scope, so `uninstall`
+// removes only that, `update --check` can compare versions, and `doctor` can report drift.
+// Lives at <claudeDir>/freeharness/install-manifest.json (user: ~/.claude; project:
+// <project>/.claude). Merged on every apply pass: entries are added, never dropped.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+/**
+ * Resolves the manifest path for a scope.
+ * @param scope user | project.
+ * @param projectRoot Project root (project scope).
+ * @returns Absolute manifest path.
+ */
+export function manifestPath(scope, projectRoot) {
+    const claudeDir = scope === "user" ? path.join(os.homedir(), ".claude") : path.join(projectRoot, ".claude");
+    return path.join(claudeDir, "freeharness", "install-manifest.json");
+}
+/**
+ * Reads a manifest when present.
+ * @param file Manifest path.
+ * @returns The parsed manifest, or undefined when absent/unreadable.
+ */
+export function readManifest(file) {
+    try {
+        const m = JSON.parse(fs.readFileSync(file, "utf8"));
+        return Array.isArray(m.files) ? m : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Short HEAD of a repo checkout (git must be on PATH).
+ * @param repoRoot Checkout root.
+ * @returns The 8-char commit, or undefined.
+ */
+export function repoHead(repoRoot) {
+    const r = spawnSync("git", ["-C", repoRoot, "rev-parse", "--short=8", "HEAD"], { encoding: "utf8" });
+    const c = r.status === 0 ? r.stdout.trim() : "";
+    return /^[0-9a-f]{7,40}$/.test(c) ? c : undefined;
+}
+/**
+ * Merges an apply pass into the manifest on disk (creating it) and registers the
+ * manifest file itself last. Files the adapters reported as skipped are never recorded.
+ * @param u The pass to record.
+ * @returns The manifest path.
+ */
+export function writeManifest(u) {
+    const file = manifestPath(u.scope, u.projectRoot);
+    const now = new Date().toISOString();
+    const prev = readManifest(file);
+    const byPath = new Map();
+    for (const f of prev?.files ?? [])
+        byPath.set(f.path, f);
+    for (const r of u.results) {
+        const skipped = new Set(r.skipped ?? []);
+        for (const p of r.written) {
+            if (skipped.has(p) || p === file)
+                continue;
+            byPath.set(p, { path: p, capability: r.capabilityId, target: r.target });
+        }
+    }
+    byPath.set(file, { path: file, capability: "manifest", target: "freeharness" });
+    const union = (a, b) => [...new Set([...(a ?? []), ...b])];
+    const profiles = { ...(prev?.profiles ?? {}) };
+    for (const [id, rec] of Object.entries(u.profiles ?? {})) {
+        if (rec === null) {
+            // A removed profile takes its files (notes) out of the manifest with it.
+            for (const f of profiles[id]?.files ?? [])
+                byPath.delete(f);
+            delete profiles[id];
+        }
+        else
+            profiles[id] = rec;
+    }
+    const manifest = {
+        version: u.version,
+        sourceCommit: u.sourceCommit ?? prev?.sourceCommit,
+        scope: u.scope,
+        targets: union(prev?.targets, u.targets),
+        capabilities: union(prev?.capabilities, u.capabilities),
+        installedAt: prev?.installedAt ?? now,
+        updatedAt: now,
+        files: [...byPath.values()],
+        actions: union(prev?.actions, u.actions),
+        ...(Object.keys(profiles).length > 0 ? { profiles } : {}),
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    return file;
+}

package/dist/infra/paths.d.ts

@@ -0,0 +1,19 @@
+export declare function resolveCanonicalDir(): string;
+/**
+ * Reads the running CLI version from the package's own package.json (dist/ or src/ layout).
+ * @returns The semver string, or "0.0.0" when the manifest cannot be read.
+ */
+export declare function cliVersion(): string;
+/**
+ * Locates the FreeHarness repo checkout the canonical dir belongs to, when it is one
+ * (bundled `packages/cli/canonical` or the repo-root `canonical/`); npx installs have none.
+ * @param canonicalDir Resolved canonical directory.
+ * @returns The repo root, or undefined when canonical is not inside a checkout.
+ */
+export declare function sourceRepoRoot(canonicalDir: string): string | undefined;
+/**
+ * Locates the vendored `openspec` bin of the @freeharness/sdd package this CLI resolves
+ * (workspace link in a checkout, bundled copy in an npm install), for exposing it on PATH.
+ * @returns Absolute path of dist/src/bin/openspec.js, or undefined when not resolvable.
+ */
+export declare function vendoredSddBin(): string | undefined;

package/dist/infra/paths.js

@@ -0,0 +1,74 @@
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+// Resolve canonical/: $FREEHARNESS_CANONICAL, else walk up to a canonical/ with rules/CLAUDE.md.
+export function resolveCanonicalDir() {
+    const env = process.env.FREEHARNESS_CANONICAL;
+    if (env && fs.existsSync(env))
+        return env;
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+        const candidate = path.join(dir, "canonical");
+        if (fs.existsSync(path.join(candidate, "rules", "CLAUDE.md"))) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error("canonical/ not found (looked for rules/CLAUDE.md). Set FREEHARNESS_CANONICAL to the framework's canonical directory.");
+}
+/**
+ * Reads the running CLI version from the package's own package.json (dist/ or src/ layout).
+ * @returns The semver string, or "0.0.0" when the manifest cannot be read.
+ */
+export function cliVersion() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    for (const candidate of [path.join(here, "..", "..", "package.json"), path.join(here, "..", "package.json")]) {
+        try {
+            const v = JSON.parse(fs.readFileSync(candidate, "utf8"));
+            if (v.name === "freeharness" && typeof v.version === "string")
+                return v.version;
+        }
+        catch {
+            /* try the next layout */
+        }
+    }
+    return "0.0.0";
+}
+/**
+ * Locates the FreeHarness repo checkout the canonical dir belongs to, when it is one
+ * (bundled `packages/cli/canonical` or the repo-root `canonical/`); npx installs have none.
+ * @param canonicalDir Resolved canonical directory.
+ * @returns The repo root, or undefined when canonical is not inside a checkout.
+ */
+export function sourceRepoRoot(canonicalDir) {
+    for (const up of [path.resolve(canonicalDir, ".."), path.resolve(canonicalDir, "..", "..", "..")]) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(up, "package.json"), "utf8"));
+            if (pkg.name === "freeharness-monorepo" && fs.existsSync(path.join(up, ".git")))
+                return up;
+        }
+        catch {
+            /* not a checkout root */
+        }
+    }
+    return undefined;
+}
+/**
+ * Locates the vendored `openspec` bin of the @freeharness/sdd package this CLI resolves
+ * (workspace link in a checkout, bundled copy in an npm install), for exposing it on PATH.
+ * @returns Absolute path of dist/src/bin/openspec.js, or undefined when not resolvable.
+ */
+export function vendoredSddBin() {
+    try {
+        const main = createRequire(import.meta.url).resolve("@freeharness/sdd");
+        const bin = path.join(path.dirname(main), "bin", "openspec.js");
+        return fs.existsSync(bin) ? bin : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/infra/routing.d.ts

@@ -0,0 +1,4 @@
+/** Routing file name. */
+export declare const ROUTING_FILE = "freeharness-routing.md";
+/** Canonical routing source path. */
+export declare function routingSourcePath(canonicalDir: string): string;

package/dist/infra/routing.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+/** Routing file name. */
+export const ROUTING_FILE = "freeharness-routing.md";
+/** Canonical routing source path. */
+export function routingSourcePath(canonicalDir) {
+    return path.join(canonicalDir, "rules", "routing.md");
+}

package/node_modules/@freeharness/core/dist/context.d.ts

@@ -0,0 +1,30 @@
+import type { HarnessTarget } from "./registry.js";
+export type Scope = "project" | "user";
+export interface InstallContext {
+    scope: Scope;
+    projectRoot: string;
+    canonicalDir: string;
+    dryRun: boolean;
+    /**
+     * Lets a harness adapter copy machine-global capabilities (skills, agents, safety,
+     * cost, memory, MCP) into a project. Off by default: at project scope those live in the
+     * user install and a copy would be loaded twice by the harness. Adapters that are
+     * project-only by nature (OpenCode) ignore it.
+     */
+    allowProjectCopies?: boolean;
+}
+export interface ExecStep {
+    description: string;
+    command: string;
+    cwd?: string;
+    optional?: boolean;
+}
+export interface AdapterResult {
+    capabilityId: string;
+    target: HarnessTarget;
+    written: string[];
+    /** Subset of `written` left untouched (absent-guarded seeds that already existed); never recorded as ours. */
+    skipped?: string[];
+    actions: ExecStep[];
+    notes: string[];
+}

package/node_modules/@freeharness/core/dist/context.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@freeharness/core/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./registry.js";
+export * from "./tiers.js";
+export * from "./context.js";
+export * from "./ports.js";
+export * from "./planner.js";

package/node_modules/@freeharness/core/dist/index.js

@@ -0,0 +1,6 @@
+// Core domain barrel. Pure: no I/O, no adapter/cli imports.
+export * from "./registry.js";
+export * from "./tiers.js";
+export * from "./context.js";
+export * from "./ports.js";
+export * from "./planner.js";

package/node_modules/@freeharness/core/dist/planner.d.ts

@@ -0,0 +1,13 @@
+import type { HarnessTarget } from "./registry.js";
+import type { Scope } from "./context.js";
+export interface PlanStep {
+    target: HarnessTarget;
+    capabilityId: string;
+}
+export interface InstallPlan {
+    scope: Scope;
+    targets: HarnessTarget[];
+    capabilityIds: string[];
+    steps: PlanStep[];
+}
+export declare function buildPlan(requested: string[], targets: HarnessTarget[], scope: Scope): InstallPlan;

package/node_modules/@freeharness/core/dist/planner.js

@@ -0,0 +1,18 @@
+import { getCapability, resolveInstallOrder } from "./registry.js";
+// Ordering matches the historical runner: targets outer, capabilities (in
+// dependency order) inner, filtered to those supporting the target. Deterministic.
+export function buildPlan(requested, targets, scope) {
+    const capabilityIds = resolveInstallOrder(requested, targets);
+    const steps = [];
+    for (const target of targets) {
+        for (const id of capabilityIds) {
+            const cap = getCapability(id);
+            if (!cap)
+                continue;
+            if (!cap.targets.includes(target))
+                continue;
+            steps.push({ target, capabilityId: id });
+        }
+    }
+    return { scope, targets, capabilityIds, steps };
+}