@tangle-network/agent-profile-materialize 1.1.7 → 1.1.9

package/dist/prime-agent-dir.js

@@ -1,173 +0,0 @@
-export function writePrimeAgentFile(path, data, mode = 0o600) {
-    mkdirSync(dirname(path), { recursive: true });
-    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync(temp, data, { mode });
-    renameSync(temp, path);
-}
-const localPrimeAgentDirIo = {
-    read: (path) => (existsSync(path) ? readFileSync(path, "utf8") : undefined),
-    write: (path, data) => writePrimeAgentFile(path, data),
-};
-/** The fork's continual-harness store, the only agent-dir file a materialization reads. */
-export function primeHarnessStatePath(agentDir) {
-    return join(agentDir, PRIME_HARNESS_DIR_NAME, PRIME_HARNESS_STATE_FILE);
-}
-/**
- * Materialize the validated controls and return the extra spawn args that bind
- * them. Runs before every spawn (same place models.json is materialized), so a
- * continual agent dir is re-pinned to the current profile on each fresh prime
- * process.
- */
-export function materializePrimeProfileControls(agentDir, controls, options = {}) {
-    const { flagFileRoot = agentDir, warn, io = localPrimeAgentDirIo } = options;
-    const args = [];
-    const profileDir = join(flagFileRoot, PRIME_PROFILE_DIR_NAME);
-    if (controls.systemPrompt !== undefined) {
-        const promptPath = join(profileDir, PRIME_SYSTEM_PROMPT_FILE);
-        io.write(promptPath, controls.systemPrompt);
-        args.push("--system-prompt", promptPath);
-    }
-    if (controls.appendSystemPrompt !== undefined) {
-        const appendPath = join(profileDir, PRIME_APPEND_SYSTEM_PROMPT_FILE);
-        io.write(appendPath, controls.appendSystemPrompt);
-        args.push("--append-system-prompt", appendPath);
-    }
-    if (controls.instructions !== undefined) {
-        io.write(join(agentDir, PRIME_CONTEXT_FILE), `${controls.instructions}\n`);
-    }
-    if (controls.skills.length > 0) {
-        const skillsRoot = join(profileDir, PRIME_SKILLS_DIR_NAME);
-        for (const skill of controls.skills) {
-            io.write(join(skillsRoot, skill.name, "SKILL.md"), normalizeSkillMd(skill.name, skill.content));
-        }
-        args.push("--skill", skillsRoot);
-    }
-    seedPrimeProfileSubagents(agentDir, controls.subagents, warn, io);
-    return args;
-}
-/**
- * Remove the files a PREVIOUS materialization of this lowering wrote, so a
- * profile that shrank cannot leave a stale instruction file or skill behind for
- * the next run against the same dirs.
- *
- * Only the paths this lowering NAMES are removed. There is deliberately no
- * manifest: a manifest would live where the agent can write it, and reading a
- * delete list out of agent-writable state turns pruning into an arbitrary-path
- * delete.
- */
-export function prunePrimeProfileMaterial(agentDir, options = {}) {
-    const { flagFileRoot = agentDir } = options;
-    rmSync(join(flagFileRoot, PRIME_PROFILE_DIR_NAME), {
-        recursive: true,
-        force: true,
-    });
-    rmSync(join(agentDir, PRIME_CONTEXT_FILE), { force: true });
-}
-/**
- * Upsert profile subagent specs into the fork's global continual-harness
- * store and remove profile-sourced entries the current profile no longer
- * declares. Agent-written entries (`source: "agent"`) — and every top-level
- * key this lowering does not manage — are preserved untouched.
- *
- * A store that exists but no longer parses raises
- * {@link PrimeHarnessStateError}: the file is the agent's own self-modification
- * state, and overwriting it destroys what the run was supposed to observe.
- */
-export function seedPrimeProfileSubagents(agentDir, subagents, warn, io = localPrimeAgentDirIo) {
-    const statePath = primeHarnessStatePath(agentDir);
-    let state = {};
-    const stored = io.read(statePath);
-    if (stored !== undefined) {
-        let parsed;
-        try {
-            parsed = JSON.parse(stored);
-        }
-        catch (err) {
-            throw new PrimeHarnessStateError(statePath, err instanceof Error ? err.message : String(err));
-        }
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            throw new PrimeHarnessStateError(statePath, "the store is not a JSON object");
-        }
-        state = parsed;
-    }
-    else if (subagents.length === 0) {
-        // Nothing to pin and nothing stale to remove.
-        return;
-    }
-    const rawEntries = state.entries;
-    const entries = rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
-        ? rawEntries
-        : {};
-    for (const kind of PRIME_HARNESS_KINDS) {
-        const records = entries[kind];
-        if (!records || typeof records !== "object" || Array.isArray(records)) {
-            entries[kind] = {};
-        }
-    }
-    const existing = entries.subagent;
-    const desiredIds = new Set(subagents.map((s) => primeSubagentEntryId(s.name)));
-    let changed = false;
-    for (const [id, entry] of Object.entries(existing)) {
-        const source = entry?.source;
-        const isLegacy = typeof source === "string" &&
-            PRIME_LEGACY_PROFILE_ENTRY_SOURCES.includes(source);
-        if (isLegacy) {
-            warn?.("prime: adopting a subagent entry left by a pre-shared executor", {
-                statePath,
-                id,
-                source,
-            });
-        }
-        if ((source === PRIME_PROFILE_ENTRY_SOURCE || isLegacy) &&
-            !desiredIds.has(id)) {
-            delete existing[id];
-            changed = true;
-        }
-    }
-    const now = new Date().toISOString();
-    for (const spec of subagents) {
-        const id = primeSubagentEntryId(spec.name);
-        const content = [spec.description?.trim(), spec.prompt?.trim()]
-            .filter((part) => !!part)
-            .join("\n\n");
-        const previous = existing[id];
-        if (previous &&
-            previous.source === PRIME_PROFILE_ENTRY_SOURCE &&
-            previous.title === spec.name &&
-            previous.content === content) {
-            continue;
-        }
-        existing[id] = {
-            id,
-            kind: "subagent",
-            title: spec.name,
-            content,
-            path: PRIME_PROFILE_ENTRY_SOURCE,
-            scope: "global",
-            reference: {},
-            arguments: {},
-            metadata: spec.metadata ?? {},
-            source: PRIME_PROFILE_ENTRY_SOURCE,
-            created_at: previous?.created_at ?? now,
-            updated_at: now,
-            version: previous && typeof previous.version === "number"
-                ? previous.version + 1
-                : 1,
-        };
-        changed = true;
-    }
-    if (!changed)
-        return;
-    io.write(statePath, `${JSON.stringify({
-        ...state,
-        schema: typeof state.schema === "number" ? state.schema : 1,
-        entries,
-        refinements: Array.isArray(state.refinements) ? state.refinements : [],
-    }, null, 2)}\n`);
-}
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { PrimeHarnessStateError } from "./prime-fork.js";
-import { PRIME_APPEND_SYSTEM_PROMPT_FILE, PRIME_CONTEXT_FILE, PRIME_HARNESS_DIR_NAME, PRIME_HARNESS_KINDS, PRIME_HARNESS_STATE_FILE, PRIME_LEGACY_PROFILE_ENTRY_SOURCES, PRIME_PROFILE_DIR_NAME, PRIME_PROFILE_ENTRY_SOURCE, PRIME_SKILLS_DIR_NAME, PRIME_SYSTEM_PROMPT_FILE, primeSubagentEntryId, } from "./prime-profile.js";
-import { normalizeSkillMd } from "./resource-resolution.js";

package/dist/prime-fork.d.ts

@@ -1,155 +0,0 @@
-/**
- * Fork FACTS for prime-agent (PrimeIntellect-ai/prime-agent) — the constants,
- * dialects and refusal reasons every executor that drives the fork needs, with
- * no `node:fs` and no executor assumptions. The agent-dir MATERIALIZATION that
- * consumes them lives in `./index.ts`; both consumers (cli-bridge's host-spawn
- * backend on `--mode rpc`, sdk-provider-prime's in-sandbox adapter on
- * `--mode acp`) read these instead of each keeping a private copy, because a
- * fork bump must move one file, not two repositories.
- *
- * Every value here was read from PrimeIntellect-ai/prime-agent 0.7.0
- * (be9e2fa0); a fork bump re-reads them against the new clone.
- */
-/**
- * Env vars the agent resolves its config dir from, most-specific first.
- *
- * The fork derives the name from its own package identity —
- * `ENV_AGENT_DIR = \`${envPrefix}_CODING_AGENT_DIR\`` where `envPrefix` comes
- * from `package.json` `piConfig.name` (config.ts:485-498) — so the fork reads
- * `PRIME_AGENT_CODING_AGENT_DIR` and upstream pi reads `PI_CODING_AGENT_DIR`.
- * An executor that sets only the fork's name has its isolation SILENTLY
- * disabled when the binary on PATH turns out to be upstream pi: `getAgentDir()`
- * falls back to `homedir()/<CONFIG_DIR_NAME>` (config.ts:520-527), one shared
- * dir — and therefore one shared self-modifying `harness_state.json` — for
- * every session on the box. Setting BOTH names costs nothing and keeps the
- * isolation fail-closed under either binary.
- */
-export declare const PRIME_AGENT_DIR_ENV_VARS: readonly ["PRIME_AGENT_CODING_AGENT_DIR", "PI_CODING_AGENT_DIR"];
-/** Canonical agent-dir env var for the fork itself (config.ts:498). */
-export declare const PRIME_AGENT_DIR_ENV_VAR: "PRIME_AGENT_CODING_AGENT_DIR";
-/** Pin `agentDir` under every name the agent could resolve its config dir from. */
-export declare function primeAgentDirEnv(agentDir: string): Record<string, string>;
-/**
- * Operator knobs an executor forwards into the agent when they are set.
- *
- * `PRIME_AGENT_KERNEL_VENV` is load-bearing for any executor that also pins
- * HOME: the kernel venv defaults under `homedir()/.prime/agent/kernel-venv`
- * (kernel/bootstrap.ts:331-342), so a fresh HOME re-bootstraps it through uv on
- * every run unless the operator's venv path is forwarded
- * (bootstrap.ts:340 override, :358 branch).
- */
-export declare const PRIME_KERNEL_ENV_PASSTHROUGH: readonly ["PRIME_AGENT_INSTALL_UV", "PRIME_AGENT_KERNEL_PYTHON", "PRIME_AGENT_KERNEL_VENV"];
-/**
- * Env vars an executor must NEVER forward from its own environment.
- *
- * These re-point the self-modifying continual-harness store OUTSIDE the agent
- * dir (agent-session.ts:8805 hands the kernel its store location), which
- * defeats per-session isolation without changing anything an executor inspects.
- * Isolation is the fail-closed default; sharing state is an explicit opt-in
- * that names a directory, never an inherited env var.
- */
-export declare const PRIME_HARNESS_STATE_ENV_DENYLIST: readonly ["RLM_GLOBAL_HARNESS_STATE_DIR", "RLM_HARNESS_STATE_DIR"];
-/**
- * A prime-agent IPython kernel that dies is never re-provisioned headlessly —
- * every later `ipython` call fails with one of these markers until the process
- * is replaced. An executor that cannot recognize them either reports a generic
- * turn failure or burns its whole timeout against a permanently dead tool.
- *
- * Verified in `core/kernel/index.ts`: :723 ("forked kernel exited
- * unexpectedly"), :750 ("Kernel exited before resolving ports"), :779 ("Kernel
- * exited during startup"), :820/:837/:1172/:1295 ("Kernel has been shut down").
- */
-export declare const PRIME_KERNEL_DEAD_MARKERS: readonly string[];
-/** The first kernel-death marker present in `text`, or undefined. */
-export declare function matchPrimeKernelDeadMarker(text: string): string | undefined;
-/**
- * `--thinking` rungs the fork's argument parser accepts
- * (cli/args.ts:62 `VALID_THINKING_LEVELS`, rejected at :175). Read from the
- * fork itself rather than borrowed from upstream pi's measured table: the two
- * agreeing today is a coincidence this module must not depend on.
- */
-export declare const PRIME_THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type PrimeThinkingLevel = (typeof PRIME_THINKING_LEVELS)[number];
-/**
- * Map the portable reasoning ladder onto the fork's `--thinking` value.
- *
- * Throws on an effort with no rung instead of returning undefined: omitting the
- * flag runs the agent at its default thinking level while the caller believes
- * the requested effort is in force, which is a silently dropped control.
- */
-export declare function primeThinkingLevel(effort: string | null | undefined): PrimeThinkingLevel | undefined;
-/**
- * Why `profile.mcp` (and any hub connection that resolves to MCP) is refused.
- *
- * The fork's `mcpServers` settings surface IS read at startup
- * (settings-manager.ts:98-120,219) but a user-declared server never becomes
- * model-visible: the host McpManager registers OAuth providers and serves
- * mcp.config/refresh host-requests only (core/mcp/mcp-manager.ts:62-124),
- * skips stdio servers entirely (mcp-manager.ts:73), and nothing generates a
- * skill or prompt section for one. Model-visible MCP is exactly the built-in
- * catalog skills, which are hand-written Python `McpIntegration` subclasses
- * (prime-agent-runtime/src/rlm/mcp_base.py:112-125; only linear and notion
- * ship). Materializing a per-run entry would run the agent WITHOUT the
- * requested tools while the config on disk says otherwise.
- */
-export declare const PRIME_MCP_UNSUPPORTED_REASON: string;
-/** Which half of a profile refusal this is: a fork limit, or a bad declaration. */
-export type PrimeProfileErrorKind = "unsupported" | "invalid";
-/**
- * Refusal raised by the shared prime lowering, carrying the control and the
- * reason separately so each executor can render them in its own error contract
- * (an HTTP backend's typed `BackendError`, an SDK adapter's plain `Error`)
- * without the reason text — which is where the fork evidence lives — being
- * rewritten per repository.
- */
-export declare class PrimeProfileError extends Error {
-    readonly kind: PrimeProfileErrorKind;
-    readonly control: string;
-    readonly reason: string;
-    constructor(kind: PrimeProfileErrorKind, control: string, reason: string);
-}
-/** Raise the "the fork cannot honor this control" half of the refusal. */
-export declare function rejectPrimeControl(control: string, reason: string): never;
-/** Raise the "this declaration is malformed" half of the refusal. */
-export declare function rejectPrimeDeclaration(control: string, reason: string): never;
-/**
- * The fork's continual-harness store exists but no longer parses.
- *
- * The store is the agent's own self-modification state — refinements, learned
- * prompts, subagents it created mid-session — so an executor that reseeds it
- * from empty destroys evidence and silently mutates the thing under study. The
- * turn is failed instead; the file is the operator's to repair or remove.
- */
-export declare class PrimeHarnessStateError extends Error {
-    readonly statePath: string;
-    constructor(statePath: string, detail: string);
-}
-/**
- * Strip `//` line comments and trailing commas, leaving string literals
- * untouched — byte-for-byte the fork's own `stripJsonComments`
- * (core/model-registry.ts), so a models.json the agent accepts is never refused
- * by an executor and vice versa.
- */
-export declare function stripPrimeJsonComments(input: string): string;
-/**
- * Parse a models.json with the fork's own laxness and assert the one structural
- * invariant it requires (a `providers` object). Throws naming `sourcePath`.
- *
- * This is the SHAPE and DIALECT only. Producing the file is deliberately not
- * shared: an executor holding real operator credentials copies an
- * operator-authored file and forwards only the env var names its `apiKey`
- * entries reference, while an in-sandbox executor synthesizes a one-provider
- * entry with a literal key that is a proxy dummy. Same schema, opposite threat
- * models.
- */
-export declare function parsePrimeModelsJson(text: string, sourcePath: string): Record<string, unknown>;
-/**
- * Environment variables a models.json names as `apiKey` sources.
- *
- * prime resolves an `apiKey` value env-var first and LITERAL second
- * (core/resolve-config-value.ts), so an executor that forwards exactly the
- * named variables lets an operator keep secrets out of the file — and an
- * executor that forwards NONE of them silently turns the variable name itself
- * into the credential string.
- */
-export declare function primeApiKeyEnvNames(modelsConfig: Record<string, unknown>): string[];

package/dist/prime-fork.js

@@ -1,262 +0,0 @@
-/**
- * Fork FACTS for prime-agent (PrimeIntellect-ai/prime-agent) — the constants,
- * dialects and refusal reasons every executor that drives the fork needs, with
- * no `node:fs` and no executor assumptions. The agent-dir MATERIALIZATION that
- * consumes them lives in `./index.ts`; both consumers (cli-bridge's host-spawn
- * backend on `--mode rpc`, sdk-provider-prime's in-sandbox adapter on
- * `--mode acp`) read these instead of each keeping a private copy, because a
- * fork bump must move one file, not two repositories.
- *
- * Every value here was read from PrimeIntellect-ai/prime-agent 0.7.0
- * (be9e2fa0); a fork bump re-reads them against the new clone.
- */
-/**
- * Env vars the agent resolves its config dir from, most-specific first.
- *
- * The fork derives the name from its own package identity —
- * `ENV_AGENT_DIR = \`${envPrefix}_CODING_AGENT_DIR\`` where `envPrefix` comes
- * from `package.json` `piConfig.name` (config.ts:485-498) — so the fork reads
- * `PRIME_AGENT_CODING_AGENT_DIR` and upstream pi reads `PI_CODING_AGENT_DIR`.
- * An executor that sets only the fork's name has its isolation SILENTLY
- * disabled when the binary on PATH turns out to be upstream pi: `getAgentDir()`
- * falls back to `homedir()/<CONFIG_DIR_NAME>` (config.ts:520-527), one shared
- * dir — and therefore one shared self-modifying `harness_state.json` — for
- * every session on the box. Setting BOTH names costs nothing and keeps the
- * isolation fail-closed under either binary.
- */
-export const PRIME_AGENT_DIR_ENV_VARS = [
-    "PRIME_AGENT_CODING_AGENT_DIR",
-    "PI_CODING_AGENT_DIR",
-];
-/** Canonical agent-dir env var for the fork itself (config.ts:498). */
-export const PRIME_AGENT_DIR_ENV_VAR = PRIME_AGENT_DIR_ENV_VARS[0];
-/** Pin `agentDir` under every name the agent could resolve its config dir from. */
-export function primeAgentDirEnv(agentDir) {
-    const env = {};
-    for (const name of PRIME_AGENT_DIR_ENV_VARS)
-        env[name] = agentDir;
-    return env;
-}
-/**
- * Operator knobs an executor forwards into the agent when they are set.
- *
- * `PRIME_AGENT_KERNEL_VENV` is load-bearing for any executor that also pins
- * HOME: the kernel venv defaults under `homedir()/.prime/agent/kernel-venv`
- * (kernel/bootstrap.ts:331-342), so a fresh HOME re-bootstraps it through uv on
- * every run unless the operator's venv path is forwarded
- * (bootstrap.ts:340 override, :358 branch).
- */
-export const PRIME_KERNEL_ENV_PASSTHROUGH = [
-    /** "1" lets a headless first run install uv itself; "0" forbids it. */
-    "PRIME_AGENT_INSTALL_UV",
-    /** Offline escape hatch: pin the kernel venv python instead of uv-provisioning. */
-    "PRIME_AGENT_KERNEL_PYTHON",
-    /** Reuse an operator-provisioned kernel venv instead of re-bootstrapping it. */
-    "PRIME_AGENT_KERNEL_VENV",
-];
-/**
- * Env vars an executor must NEVER forward from its own environment.
- *
- * These re-point the self-modifying continual-harness store OUTSIDE the agent
- * dir (agent-session.ts:8805 hands the kernel its store location), which
- * defeats per-session isolation without changing anything an executor inspects.
- * Isolation is the fail-closed default; sharing state is an explicit opt-in
- * that names a directory, never an inherited env var.
- */
-export const PRIME_HARNESS_STATE_ENV_DENYLIST = [
-    "RLM_GLOBAL_HARNESS_STATE_DIR",
-    "RLM_HARNESS_STATE_DIR",
-];
-/**
- * A prime-agent IPython kernel that dies is never re-provisioned headlessly —
- * every later `ipython` call fails with one of these markers until the process
- * is replaced. An executor that cannot recognize them either reports a generic
- * turn failure or burns its whole timeout against a permanently dead tool.
- *
- * Verified in `core/kernel/index.ts`: :723 ("forked kernel exited
- * unexpectedly"), :750 ("Kernel exited before resolving ports"), :779 ("Kernel
- * exited during startup"), :820/:837/:1172/:1295 ("Kernel has been shut down").
- */
-export const PRIME_KERNEL_DEAD_MARKERS = [
-    "Kernel has been shut down",
-    "Kernel exited before resolving ports",
-    "Kernel exited during startup",
-    "forked kernel exited unexpectedly",
-];
-/** The first kernel-death marker present in `text`, or undefined. */
-export function matchPrimeKernelDeadMarker(text) {
-    return PRIME_KERNEL_DEAD_MARKERS.find((marker) => text.includes(marker));
-}
-/**
- * `--thinking` rungs the fork's argument parser accepts
- * (cli/args.ts:62 `VALID_THINKING_LEVELS`, rejected at :175). Read from the
- * fork itself rather than borrowed from upstream pi's measured table: the two
- * agreeing today is a coincidence this module must not depend on.
- */
-export const PRIME_THINKING_LEVELS = [
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-];
-/** Canonical portable effort → fork `--thinking` rung. */
-const PRIME_THINKING_BY_EFFORT = {
-    none: "off",
-    minimal: "minimal",
-    low: "low",
-    medium: "medium",
-    high: "high",
-    xhigh: "xhigh",
-    // The fork carries `max` above `xhigh`, so the ceiling level reaches it.
-    ultracode: "max",
-};
-/**
- * Map the portable reasoning ladder onto the fork's `--thinking` value.
- *
- * Throws on an effort with no rung instead of returning undefined: omitting the
- * flag runs the agent at its default thinking level while the caller believes
- * the requested effort is in force, which is a silently dropped control.
- */
-export function primeThinkingLevel(effort) {
-    if (effort === undefined || effort === null || effort === "")
-        return undefined;
-    const level = PRIME_THINKING_BY_EFFORT[effort];
-    if (level === undefined) {
-        throw new PrimeProfileError("invalid", "model.reasoningEffort", `prime-agent has no --thinking rung for ${JSON.stringify(effort)} ` +
-            `(fork cli/args.ts:62 accepts ${PRIME_THINKING_LEVELS.join(", ")}).`);
-    }
-    return level;
-}
-/**
- * Why `profile.mcp` (and any hub connection that resolves to MCP) is refused.
- *
- * The fork's `mcpServers` settings surface IS read at startup
- * (settings-manager.ts:98-120,219) but a user-declared server never becomes
- * model-visible: the host McpManager registers OAuth providers and serves
- * mcp.config/refresh host-requests only (core/mcp/mcp-manager.ts:62-124),
- * skips stdio servers entirely (mcp-manager.ts:73), and nothing generates a
- * skill or prompt section for one. Model-visible MCP is exactly the built-in
- * catalog skills, which are hand-written Python `McpIntegration` subclasses
- * (prime-agent-runtime/src/rlm/mcp_base.py:112-125; only linear and notion
- * ship). Materializing a per-run entry would run the agent WITHOUT the
- * requested tools while the config on disk says otherwise.
- */
-export const PRIME_MCP_UNSUPPORTED_REASON = "a user-declared mcpServers entry is read from the fork's settings.json at startup but never " +
-    "becomes model-visible: the host only registers OAuth/config for it (fork core/mcp/" +
-    "mcp-manager.ts:62-124), skips stdio servers entirely (mcp-manager.ts:73), and generates no " +
-    "skill or prompt section for it. Model-visible MCP is exactly the built-in Python " +
-    "McpIntegration catalog skills (prime-agent-runtime/src/rlm/mcp_base.py:112-125), which no " +
-    "per-run configuration creates — so materializing it would be a silently dropped control.";
-/**
- * Refusal raised by the shared prime lowering, carrying the control and the
- * reason separately so each executor can render them in its own error contract
- * (an HTTP backend's typed `BackendError`, an SDK adapter's plain `Error`)
- * without the reason text — which is where the fork evidence lives — being
- * rewritten per repository.
- */
-export class PrimeProfileError extends Error {
-    kind;
-    control;
-    reason;
-    constructor(kind, control, reason) {
-        super(kind === "unsupported"
-            ? `prime does not support AgentProfile ${control}: ${reason}`
-            : `prime cannot accept AgentProfile ${control}: ${reason}`);
-        this.name = "PrimeProfileError";
-        this.kind = kind;
-        this.control = control;
-        this.reason = reason;
-    }
-}
-/** Raise the "the fork cannot honor this control" half of the refusal. */
-export function rejectPrimeControl(control, reason) {
-    throw new PrimeProfileError("unsupported", control, reason);
-}
-/** Raise the "this declaration is malformed" half of the refusal. */
-export function rejectPrimeDeclaration(control, reason) {
-    throw new PrimeProfileError("invalid", control, reason);
-}
-/**
- * The fork's continual-harness store exists but no longer parses.
- *
- * The store is the agent's own self-modification state — refinements, learned
- * prompts, subagents it created mid-session — so an executor that reseeds it
- * from empty destroys evidence and silently mutates the thing under study. The
- * turn is failed instead; the file is the operator's to repair or remove.
- */
-export class PrimeHarnessStateError extends Error {
-    statePath;
-    constructor(statePath, detail) {
-        super(`prime harness state ${statePath} is not valid JSON and may hold agent self-modification ` +
-            `state; refusing to overwrite it — repair or remove the file to continue (${detail})`);
-        this.name = "PrimeHarnessStateError";
-        this.statePath = statePath;
-    }
-}
-/**
- * Strip `//` line comments and trailing commas, leaving string literals
- * untouched — byte-for-byte the fork's own `stripJsonComments`
- * (core/model-registry.ts), so a models.json the agent accepts is never refused
- * by an executor and vice versa.
- */
-export function stripPrimeJsonComments(input) {
-    return input
-        .replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => (m[0] === '"' ? m : ""))
-        .replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail !== undefined ? tail : m[0] === '"' ? m : "");
-}
-/**
- * Parse a models.json with the fork's own laxness and assert the one structural
- * invariant it requires (a `providers` object). Throws naming `sourcePath`.
- *
- * This is the SHAPE and DIALECT only. Producing the file is deliberately not
- * shared: an executor holding real operator credentials copies an
- * operator-authored file and forwards only the env var names its `apiKey`
- * entries reference, while an in-sandbox executor synthesizes a one-provider
- * entry with a literal key that is a proxy dummy. Same schema, opposite threat
- * models.
- */
-export function parsePrimeModelsJson(text, sourcePath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(stripPrimeJsonComments(text));
-    }
-    catch (err) {
-        throw new Error(`prime models.json ${sourcePath} is not valid JSON: ${err.message}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error(`prime models.json ${sourcePath} must be a JSON object`);
-    }
-    const providers = parsed.providers;
-    if (!providers || typeof providers !== "object" || Array.isArray(providers)) {
-        throw new Error(`prime models.json ${sourcePath} must carry a "providers" object (prime's models.json schema)`);
-    }
-    return parsed;
-}
-/**
- * Environment variables a models.json names as `apiKey` sources.
- *
- * prime resolves an `apiKey` value env-var first and LITERAL second
- * (core/resolve-config-value.ts), so an executor that forwards exactly the
- * named variables lets an operator keep secrets out of the file — and an
- * executor that forwards NONE of them silently turns the variable name itself
- * into the credential string.
- */
-export function primeApiKeyEnvNames(modelsConfig) {
-    const names = [];
-    const providers = modelsConfig.providers;
-    if (!providers || typeof providers !== "object")
-        return names;
-    for (const provider of Object.values(providers)) {
-        if (!provider || typeof provider !== "object")
-            continue;
-        const key = provider.apiKey;
-        if (typeof key !== "string" || !/^[A-Z_][A-Z0-9_]*$/.test(key))
-            continue;
-        if (!names.includes(key))
-            names.push(key);
-    }
-    return names;
-}

package/dist/prime-profile.d.ts

@@ -1,88 +0,0 @@
-export declare const PRIME_PROFILE_DIR_NAME = "profile";
-export declare const PRIME_SKILLS_DIR_NAME = "skills";
-export declare const PRIME_SYSTEM_PROMPT_FILE = "system-prompt.md";
-export declare const PRIME_APPEND_SYSTEM_PROMPT_FILE = "append-system-prompt.md";
-/** Agent-dir global context file the fork reads (resource-loader.ts:59,86). */
-export declare const PRIME_CONTEXT_FILE = "AGENTS.md";
-/** Fork continual-harness store location under the agent dir (refinement.ts:269-279). */
-export declare const PRIME_HARNESS_DIR_NAME = "harness";
-export declare const PRIME_HARNESS_STATE_FILE = "harness_state.json";
-export declare const PRIME_HARNESS_KINDS: readonly ["prompt", "memory", "skill", "subagent"];
-/**
- * Provenance marker for entries pinned from the profile. Stale removal keys on
- * it, so agent-written (`source: "agent"`) and user-written entries are never
- * touched.
- */
-export declare const PRIME_PROFILE_ENTRY_SOURCE = "profile";
-/**
- * Provenance markers written by executors that predate this shared lowering.
- *
- * Pruning keys on the source tag, so an executor that switches to the shared
- * implementation would otherwise leave its own earlier entries behind forever:
- * they match no current profile and no current source, and the model's
- * spawnable roster silently accumulates duplicates of every subagent. They are
- * adopted (pruned or replaced) on the first shared run instead.
- */
-export declare const PRIME_LEGACY_PROFILE_ENTRY_SOURCES: readonly string[];
-export interface PrimeProfileSkill {
-    name: string;
-    content: string;
-}
-export interface PrimeProfileSubagent {
-    name: string;
-    description?: string;
-    prompt?: string;
-    metadata?: Record<string, unknown>;
-}
-/** Validated, materialization-ready view of the profile controls prime applies. */
-export interface PrimeProfileControls {
-    systemPrompt?: string;
-    appendSystemPrompt?: string;
-    /** Composed caller instructions, lowered to the agent dir's AGENTS.md. */
-    instructions?: string;
-    skills: PrimeProfileSkill[];
-    subagents: PrimeProfileSubagent[];
-}
-/** True when the controls materialize anything at all. */
-export declare function hasPrimeProfileMaterial(controls: PrimeProfileControls): boolean;
-/**
- * True when the controls must WRITE INTO the agent dir itself.
- *
- * Prompt files and skill dirs are named by a flag, so they can live anywhere
- * the agent can read (`--system-prompt` / `--append-system-prompt` resolve a
- * path when it exists, fork resource-loader.ts:41-56; `--skill` takes an
- * arbitrary dir, :437-442). The context file and the continual-harness store
- * are located BY the agent dir and have no flag, so they cannot move.
- *
- * An executor pointed at an agent dir it does not own (an operator's shared
- * dir) uses this to refuse exactly the controls it would have to write there,
- * while still binding the ones it can materialize elsewhere.
- */
-export declare function primeProfileNeedsAgentDir(controls: PrimeProfileControls): boolean;
-/**
- * Validate and extract the profile controls the prime agent-dir lowering
- * materializes. Throws {@link PrimeProfileError} on any control (or control
- * facet) the fork has no verified read path for — partial acceptance would
- * silently drop the rest.
- */
-export declare function readPrimeProfileControls(profile: AgentProfile | undefined): PrimeProfileControls;
-/**
- * Refuse a run whose selected model disagrees with the profile's own.
- *
- * One authority per run: a profile names the model it was written and scored
- * against, so running it on a different one silently scores a different agent.
- * Both sides go through {@link modelIdsMatch}, so the qualification level a
- * caller happened to use is not a conflict.
- *
- * `provider` is the executor's PROVIDER SELECTION, and is compared only when
- * the executor's provider is part of model identity. An executor whose
- * provider key is merely a namespace inside the agent dir passes it as
- * undefined and gets the model-name comparison alone.
- */
-export declare function assertPrimeModelAgreement(profile: AgentProfile | undefined, selected: {
-    provider?: string;
-    model: string;
-}): void;
-/** Deterministic harness-state entry id for a profile subagent name. */
-export declare function primeSubagentEntryId(name: string): string;
-import type { AgentProfile } from "@tangle-network/agent-interface";