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

package/dist/plan-types.d.ts

@@ -1,341 +0,0 @@
-export type { HarnessId } from "./harness.js";
-/** The executor-owned root that receives a materialized file. */
-export type PlanFileRoot = "workspace" | "agent";
-export interface PlanFile {
-    relPath: string;
-    content: string;
-    /** Defaults to the run workspace. `agent` is the harness's private agent directory. */
-    root?: PlanFileRoot;
-    /** chmod mode (e.g. 0o755 for hook scripts); default 0o644. */
-    mode?: number;
-    /**
-     * Provenance of this entry. `"generated"` = the materializer synthesized the
-     * content itself (native harness config, merged settings, lowered prompt/MCP/
-     * hooks/subagents). `"user"` = the exact bytes of a profile-declared resource
-     * ref (`resources.files`/`tools`/`agents`/`skills`/`commands`), passed through
-     * verbatim at the path the profile author chose.
-     *
-     * A consumer that needs to reinterpret a SPECIFIC generated file (e.g. parse
-     * `opencode.json` as the synthetic native config) MUST gate on
-     * `source === "generated"` at that relPath — matching by relPath alone cannot
-     * tell a harness-authored config apart from a user resource mount that
-     * happens to share the same conventional path, and treating arbitrary user
-     * content as trusted generated config is a fail-open bug, not a fallback.
-     *
-     * Optional: callers that hand-construct a {@link WorkspacePlan} directly for
-     * {@link applyWorkspacePlan} (tests, ad hoc writes) are not materializer
-     * output and have no provenance to report. `materializeProfile` always sets
-     * this on every file it emits.
-     */
-    source?: "user" | "generated";
-    /**
-     * Who owns the PATH — which decides whether an existing file there may be
-     * replaced.
-     *
-     * `"materializer"` = a path whose generated content is wholly this
-     * package's output: a name this package invented, the generated context file
-     * (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `HERMES.md`), or `opencode.json`,
-     * which carries only the registrations generated from the profile. A file
-     * already there is this materializer's own output from an earlier application
-     * into the same workspace, and replacing it is how turn two of a resumed
-     * session — or the first turn of a branched one — gets the current profile
-     * instead of the previous one. Application replaces it only when the existing
-     * bytes prove that provenance — by the name for an invented path, by a marker
-     * line committing to the body digest for a context file, by the content for
-     * `opencode.json`.
-     *
-     * `"shared"` (the default, and every other file) = a path the user or the
-     * harness also owns. `.gemini/system.md` is a documented, user-authorable
-     * name whose content this package cannot tell from its own, and so is a
-     * context file mounted as an explicit profile resource rather than generated.
-     * An existing file there may be the caller's own work, so it is never
-     * replaced.
-     *
-     * Optional because hand-constructed plans have no path provenance to report;
-     * absent reads as `"shared"`, the safe answer.
-     */
-    ownership?: "materializer" | "shared";
-    /**
-     * Secret leaves in a generated JSON document. `content` contains `null` at
-     * each path until the private executor resolves the named reference. The
-     * public plan, its digest, and its receipt retain only these references.
-     */
-    secretSlots?: PlanFileSecretSlot[];
-}
-export interface PlanFileSecretSlot {
-    path: Array<string | number>;
-    ref: AgentProfileSecretRef;
-}
-export interface WorkspacePlanSecretSegment {
-    kind: "secret";
-    ref: AgentProfileSecretRef;
-    /** Encoding applied after private resolution. */
-    encoding: "raw" | "json-string";
-}
-/** A launch argument whose private leaves are resolved immediately before spawn. */
-export interface WorkspacePlanArgumentTemplate {
-    kind: "workspace-plan-argument-template";
-    segments: Array<string | WorkspacePlanSecretSegment>;
-}
-export type WorkspacePlanArgument = string | WorkspacePlanArgumentTemplate;
-/** Public bytes stay strings; secret references stay opaque until application. */
-export type WorkspacePlanConfigValue = string | AgentProfileSecretRef;
-export interface Unsupported {
-    dimension: "files" | "skills" | "mcp" | "hooks" | "subagents" | "commands" | "instructions" | "systemPrompt" | "appendSystemPrompt" | "connections" | "confidential" | "permissions" | "tools" | "modes" | "extensions";
-    reason: string;
-}
-/**
- * The subset of {@link BINDABLE_LAUNCH_CONTROLS} the plan HANDS OVER rather than
- * executes: controls a caller reaches only by composing the harness's own
- * configuration, so no file, flag or env var the plan writes can touch them.
- *
- *   - `opencode.agent-prompt` — opencode's `agent.<name>.prompt` config field,
- *     the one control that replaces its built-in provider prompt. It binds to a
- *     SINGLE agent, and the agent is chosen at launch. A caller that builds
- *     opencode's config itself and picks the agent there reads neither
- *     `plan.files` nor `plan.flags`, so for that one the plan names the control
- *     and hands over the text in {@link WorkspacePlan.systemPromptBinding}.
- *
- * Every other bindable control names a capability the plan still lowers itself
- * once the caller has declared the plan's launch inputs really reach the spawn.
- */
-export declare const EXECUTOR_SYSTEM_PROMPT_BINDINGS: readonly ["opencode.agent-prompt"];
-export type ExecutorSystemPromptBinding = (typeof EXECUTOR_SYSTEM_PROMPT_BINDINGS)[number];
-/**
- * A system-prompt intent handed to the launcher that declared it owns the
- * control, instead of being lowered into the workspace.
- *
- * Distinct from {@link WorkspacePlan.systemPrompt} — a launch ARGUMENT the
- * executor hands to a harness flag — and from the file/flag/env lowerings the
- * plan performs on its own. This names the exact control that must receive the
- * text and which of the two intents it is, so the launcher cannot apply it to
- * the wrong channel. Never written into an additive channel and never dropped:
- * a caller that has not declared it owns `control` gets the plan's own lowering
- * (or a refusal where the harness has no control at all) instead of this field.
- */
-export interface WorkspacePlanSystemPromptBinding {
-    /** Which of the two prompt intents this is — never inferred from presence. */
-    intent: "replace";
-    /** The exact launcher control that must receive `systemPrompt`. */
-    control: ExecutorSystemPromptBinding;
-    /** Exact text the control receives. */
-    systemPrompt: string;
-}
-/** One file applied by a plan, with the executor root kept explicit. */
-export interface WorkspacePlanWrittenFile {
-    root: PlanFileRoot;
-    relPath: string;
-}
-/**
- * The dimensions `materializeProfile`'s `skip` option honors.
- *
- * Every other dimension is materialized unconditionally: generated plan files are pushed through
- * a single site that carries no dimension tag, so there is nothing to gate them on. Naming the
- * honored set keeps `skip: ["hooks"]` a loud rejection instead of a silent no-op.
- */
-export declare const SKIPPABLE_DIMENSIONS: readonly ["mcp", "extensions"];
-export type SkippableDimension = (typeof SKIPPABLE_DIMENSIONS)[number];
-export declare function isSkippableDimension(value: string): value is SkippableDimension;
-/** Reject a dimension `materializeProfile` would not actually skip, rather than ignoring it. */
-export declare function assertSkippableDimensions(skip: readonly string[] | undefined): readonly SkippableDimension[];
-/**
- * Launcher controls an executor can declare it OWNS via `materializeProfile`'s
- * `binds` option.
- *
- * Some harness controls live outside any workspace: opencode's exact
- * system-prompt replacement (`agent.<name>.prompt`) binds to the ONE agent
- * whoever starts the process selects, which a plan-forwarding executor cannot
- * guarantee — so the plan refuses the intent (harnessSystemPromptIntents in
- * @tangle-network/agent-interface answers `replace: false` for opencode).
- *
- * The replacement declarations describe the executor shapes that can reach it;
- * each gets the lowering it can apply. Codex launchers separately declare
- * `codex.developer-instructions` to consume ordinary instructions as additive
- * context; undeclared callers retain workspace files:
- *
- *   - `systemPrompt` — the executor applies the plan's launch flags to the
- *     spawn it owns, so the plan writes the generated `mode: primary` agent and
- *     selects it with `--agent`.
- *   - `opencode.agent-prompt` — the executor composes opencode's own config and
- *     picks the agent there, reading neither plan files nor plan flags, so the
- *     plan hands the text over in {@link WorkspacePlan.systemPromptBinding}
- *     instead of writing a workspace agent that would never be selected.
- *
- * The replacement declarations are mutually exclusive: declaring both is a
- * caller bug, not a broader capability.
- */
-export declare const BINDABLE_LAUNCH_CONTROLS: readonly ["systemPrompt", "codex.developer-instructions", "opencode.agent-prompt"];
-export type BindableLaunchControl = (typeof BINDABLE_LAUNCH_CONTROLS)[number];
-/** Reject a binding declaration this materializer has no lowering for, rather than ignoring it. */
-export declare function assertBindableLaunchControls(binds: readonly string[] | undefined): ReadonlySet<BindableLaunchControl>;
-/** The plan a caller writes into the run cwd, then applies to the spawn. */
-export interface WorkspacePlan {
-    harness: HarnessId;
-    /** Files to write relative to the run workspace (cwd). */
-    files: PlanFile[];
-    /** Env vars to set on the spawned process (for harnesses needing them). */
-    env: Record<string, WorkspacePlanConfigValue>;
-    /** Extra CLI flags to pass (e.g. claude --mcp-config <path>). */
-    flags: WorkspacePlanArgument[];
-    /**
-     * Exact text that REPLACES the harness's own system prompt, for harnesses
-     * whose replacement control takes it as a launch argument the executor
-     * supplies (claude-code `--system-prompt`, pi `--system-prompt`).
-     *
-     * Absent does NOT mean "no replacement was requested": a harness whose
-     * control reads a file (codex, gemini) carries the replacement in
-     * {@link WorkspacePlan.files} plus a flag or env var instead. Present means
-     * the executor MUST bind it to that harness's replacement control — never to
-     * an additive one, which would leave the built-in prompt in force.
-     */
-    systemPrompt?: string;
-    /**
-     * Text added to the harness context; its own system prompt stays intact.
-     *
-     * Claude Code and Pi bind their additive system-prompt control. Codex binds
-     * ordinary profile instructions to developer_instructions, composed once
-     * with host context; this is not a privileged system-prompt append. Authored
-     * Codex appendSystemPrompt remains unsupported. Never fold this into an exact
-     * system-prompt replacement, which carries the caller's unchanged bytes.
-     */
-    appendSystemPrompt?: string;
-    /**
-     * A prompt intent no workspace file, flag, or env var can execute, addressed
-     * to the launcher control that can — see
-     * {@link WorkspacePlanSystemPromptBinding}.
-     *
-     * Present ONLY when the caller declared it owns the named control, so a plan
-     * built by a caller that forwards it to someone else's launcher never carries
-     * one; that caller gets the intent in {@link WorkspacePlan.unsupported}
-     * instead. Whoever reads it must bind it or throw — {@link
-     * takeSystemPromptBinding} does both.
-     */
-    systemPromptBinding?: WorkspacePlanSystemPromptBinding;
-    /** Dimensions requested but with NO cwd path on this harness — fail-closed record. */
-    unsupported: Unsupported[];
-    /**
-     * Prerequisites the workspace files CANNOT establish on their own.
-     *
-     * A plan is a set of files, an env map, and flags. Some harness capabilities need more than
-     * that to actually function: pi's MCP support is not built in, it arrives from an extension
-     * that must be installed into the harness's own package directory and permitted to load. No
-     * file written into a run workspace can make either true.
-     *
-     * Writing the config anyway and hoping is the failure this field exists to prevent: the
-     * harness starts, silently has no MCP, and the agent runs without the tools it was configured
-     * with while nothing reports a problem. So the plan states the requirement and the executor —
-     * which knows where its harness is installed and how it spawns — verifies or refuses it.
-     *
-     * Optional because this is an additive field on a published type: a plan built before it
-     * existed, or by a caller that does not construct one, is still a valid plan with no
-     * prerequisites. Every plan this package builds sets it.
-     */
-    requires?: PlanRequirement[];
-}
-/**
- * One prerequisite a {@link WorkspacePlan} depends on but cannot create.
- *
- * Declarative on purpose: this package builds plans and never probes a filesystem, spawns a
- * process, or reaches the network. The executor holds that context and does the checking.
- */
-export interface PlanRequirement {
-    /** The only kind so far: a harness extension/plugin that must be loaded for a dimension to work. */
-    kind: "harness-extension";
-    /** Dimension that produced the requirement, so a refusal can name what will not work. */
-    dimension: Unsupported["dimension"];
-    /** Package spec in the harness's own vocabulary, e.g. `npm:pi-mcp-adapter`. */
-    id: string;
-    /** Why the plan needs it — goes verbatim into the executor's refusal message. */
-    reason: string;
-    /** The exact command that satisfies it, so a failure is actionable without a doc lookup. */
-    remedy: string;
-}
-/**
- * Proof of the profile workspace inputs applied before a harness is spawned.
- * `workspacePlanDigest` covers only the {@link WorkspacePlan}; it is not an
- * execution-plan digest and does not attest unrelated files in `workspaceDir`.
- */
-export interface WorkspacePlanReceipt {
-    workspacePlanDigest: string;
-    /** Public launch identity only; secret values never enter this receipt. */
-    env: Record<string, WorkspacePlanConfigValue>;
-    /** Public launch identity only; templates retain opaque secret references. */
-    flags: WorkspacePlanArgument[];
-    systemPrompt?: string;
-    appendSystemPrompt?: string;
-    /** The launcher-bound intent, so a receipt says which control owed the work. */
-    systemPromptBinding?: WorkspacePlanSystemPromptBinding;
-    unsupported: Unsupported[];
-    /**
-     * Workspace-root paths, for consumers that mount the workspace only.
-     * Agent-root files are available in `writtenFiles` and are never encoded as
-     * an `agent:` path because that spelling is legal in the workspace root.
-     */
-    written: string[];
-    /** Every applied file, including its executor-owned root. */
-    writtenFiles: WorkspacePlanWrittenFile[];
-}
-/** Private values handed directly to the provider spawn, never to receipts. */
-export interface WorkspacePlanSpawnInputs {
-    env: Record<string, string>;
-    flags: string[];
-    systemPrompt?: string;
-    appendSystemPrompt?: string;
-    /** Read it with {@link takeSystemPromptBinding}, which refuses a foreign control. */
-    systemPromptBinding?: WorkspacePlanSystemPromptBinding;
-    /**
-     * Absolute dirs of the profile's declared executable `reference/` tools in
-     * the immutable revision the launch runs from. The provider puts them on
-     * the launch PATH in place of the app's own tool dirs (bindLaunchToolBinDirs),
-     * so a profile names its CLI bare.
-     */
-    toolBinDirs?: string[];
-}
-/** Result of applying a public plan at the private executor boundary. */
-export interface WorkspacePlanApplication {
-    receipt: WorkspacePlanReceipt;
-    spawn: WorkspacePlanSpawnInputs;
-    /** Resolved generated files intentionally consumed in memory by the runtime. */
-    runtimeOnlyFiles: Record<string, string>;
-}
-/** The plan was applied, but one or more private staging files remain. */
-export declare class WorkspacePlanCleanupError extends AggregateError {
-    readonly receipt: WorkspacePlanReceipt;
-    readonly temporaryPaths: readonly string[];
-    constructor(errors: readonly unknown[], receipt: WorkspacePlanReceipt, temporaryPaths: readonly string[]);
-}
-export interface ApplyWorkspacePlanOptions {
-    /** Plan files consumed in memory by the runtime and never persisted to cwd. */
-    runtimeOnlyFiles?: readonly string[];
-    /** Absolute private agent directory required by files whose root is `agent`. */
-    agentDir?: string;
-    /** Own newly written workspace files as the process that will read them. */
-    ownership?: {
-        uid: number;
-        gid: number;
-    };
-    /** Existing workspace paths are either exact idempotent inputs or forbidden. */
-    existingFiles?: "allow-identical" | "reject";
-    /**
-     * `workspacePlanDigest` of a plan a prior call already applied into this
-     * workspace. When it equals this plan's digest, application changes no file
-     * content. It can repair ownership on unchanged materializer-owned files.
-     * A file the agent edited or removed stays exactly as the agent left it.
-     * Env, flags, prompt intents, and the receipt are still produced. A different
-     * digest applies normally, so a changed plan still meets the existing-file
-     * refusal.
-     */
-    appliedPlanDigest?: string;
-    /**
-     * Write every JSON file secret slot as an `{env:NAME}` reference (OpenCode
-     * config substitution) and never its value, so file bytes and every digest
-     * over them stay identical when only a secret's value changes. The value
-     * lands here under NAME for the executor alone: never put it in the launch
-     * environment, argv or any file the native process reads, because that
-     * process hands everything it holds to every tool it runs. A value that
-     * could not be substituted safely is refused.
-     */
-    secretFileSlotReferences?: Record<string, string>;
-}
-import type { AgentProfileSecretRef } from "@tangle-network/agent-interface";
-import type { HarnessId } from "./harness.js";

package/dist/plan-types.js

@@ -1,105 +0,0 @@
-/**
- * The subset of {@link BINDABLE_LAUNCH_CONTROLS} the plan HANDS OVER rather than
- * executes: controls a caller reaches only by composing the harness's own
- * configuration, so no file, flag or env var the plan writes can touch them.
- *
- *   - `opencode.agent-prompt` — opencode's `agent.<name>.prompt` config field,
- *     the one control that replaces its built-in provider prompt. It binds to a
- *     SINGLE agent, and the agent is chosen at launch. A caller that builds
- *     opencode's config itself and picks the agent there reads neither
- *     `plan.files` nor `plan.flags`, so for that one the plan names the control
- *     and hands over the text in {@link WorkspacePlan.systemPromptBinding}.
- *
- * Every other bindable control names a capability the plan still lowers itself
- * once the caller has declared the plan's launch inputs really reach the spawn.
- */
-export const EXECUTOR_SYSTEM_PROMPT_BINDINGS = [
-    "opencode.agent-prompt",
-];
-/**
- * The dimensions `materializeProfile`'s `skip` option honors.
- *
- * Every other dimension is materialized unconditionally: generated plan files are pushed through
- * a single site that carries no dimension tag, so there is nothing to gate them on. Naming the
- * honored set keeps `skip: ["hooks"]` a loud rejection instead of a silent no-op.
- */
-export const SKIPPABLE_DIMENSIONS = [
-    "mcp",
-    "extensions",
-];
-const SKIPPABLE_DIMENSION_SET = new Set(SKIPPABLE_DIMENSIONS);
-export function isSkippableDimension(value) {
-    return SKIPPABLE_DIMENSION_SET.has(value);
-}
-/** Reject a dimension `materializeProfile` would not actually skip, rather than ignoring it. */
-export function assertSkippableDimensions(skip) {
-    if (!skip)
-        return [];
-    const unsupportedSkips = skip.filter((dimension) => !isSkippableDimension(dimension));
-    if (unsupportedSkips.length > 0) {
-        throw new Error(`materializeProfile: cannot skip ${unsupportedSkips.join(", ")}. ` +
-            `Skippable dimensions are: ${SKIPPABLE_DIMENSIONS.join(", ")}.`);
-    }
-    return skip;
-}
-/**
- * Launcher controls an executor can declare it OWNS via `materializeProfile`'s
- * `binds` option.
- *
- * Some harness controls live outside any workspace: opencode's exact
- * system-prompt replacement (`agent.<name>.prompt`) binds to the ONE agent
- * whoever starts the process selects, which a plan-forwarding executor cannot
- * guarantee — so the plan refuses the intent (harnessSystemPromptIntents in
- * @tangle-network/agent-interface answers `replace: false` for opencode).
- *
- * The replacement declarations describe the executor shapes that can reach it;
- * each gets the lowering it can apply. Codex launchers separately declare
- * `codex.developer-instructions` to consume ordinary instructions as additive
- * context; undeclared callers retain workspace files:
- *
- *   - `systemPrompt` — the executor applies the plan's launch flags to the
- *     spawn it owns, so the plan writes the generated `mode: primary` agent and
- *     selects it with `--agent`.
- *   - `opencode.agent-prompt` — the executor composes opencode's own config and
- *     picks the agent there, reading neither plan files nor plan flags, so the
- *     plan hands the text over in {@link WorkspacePlan.systemPromptBinding}
- *     instead of writing a workspace agent that would never be selected.
- *
- * The replacement declarations are mutually exclusive: declaring both is a
- * caller bug, not a broader capability.
- */
-export const BINDABLE_LAUNCH_CONTROLS = [
-    "systemPrompt",
-    "codex.developer-instructions",
-    ...EXECUTOR_SYSTEM_PROMPT_BINDINGS,
-];
-const BINDABLE_LAUNCH_CONTROL_SET = new Set(BINDABLE_LAUNCH_CONTROLS);
-/** Reject a binding declaration this materializer has no lowering for, rather than ignoring it. */
-export function assertBindableLaunchControls(binds) {
-    if (!binds)
-        return new Set();
-    const unknown = binds.filter((control) => !BINDABLE_LAUNCH_CONTROL_SET.has(control));
-    if (unknown.length > 0) {
-        throw new Error(`materializeProfile: cannot bind ${unknown.join(", ")}. ` +
-            `Bindable launch controls are: ${BINDABLE_LAUNCH_CONTROLS.join(", ")}.`);
-    }
-    const declared = new Set(binds);
-    const handedOver = [...EXECUTOR_SYSTEM_PROMPT_BINDINGS].filter((control) => declared.has(control));
-    if (declared.has("systemPrompt") && handedOver.length > 0) {
-        throw new Error(`materializeProfile: cannot bind systemPrompt together with ${handedOver.join(", ")}. ` +
-            "The first says the plan's launch flags reach the spawn; the second says " +
-            "the caller composes the harness config itself and reads neither.");
-    }
-    return declared;
-}
-/** The plan was applied, but one or more private staging files remain. */
-export class WorkspacePlanCleanupError extends AggregateError {
-    receipt;
-    temporaryPaths;
-    constructor(errors, receipt, temporaryPaths) {
-        super(errors, "Applied workspace plan but failed to remove temporary files");
-        this.name = "WorkspacePlanCleanupError";
-        this.receipt = receipt;
-        this.temporaryPaths = Object.freeze([...temporaryPaths]);
-    }
-}

package/dist/prime-agent-dir.d.ts

@@ -1,64 +0,0 @@
-export declare function writePrimeAgentFile(path: string, data: string, mode?: number): void;
-/**
- * File access on a prime agent dir. The default reads and writes the local
- * filesystem as the calling process. An executor whose agent dir belongs to
- * another user (a root sidecar that demotes prime-agent) passes reads it took
- * as that user and replays the writes as that user, so it never touches the
- * agent's files with its own rights.
- */
-export interface PrimeAgentDirIo {
-    /** The file's text, or undefined when it does not exist. */
-    read(path: string): string | undefined;
-    /** Replace the whole file: atomic and owner-only. */
-    write(path: string, data: string): void;
-}
-/** The fork's continual-harness store, the only agent-dir file a materialization reads. */
-export declare function primeHarnessStatePath(agentDir: string): string;
-export interface PrimeMaterializeOptions {
-    /**
-     * Where the FLAG-NAMED files go — the prompt files and the skills root.
-     * Defaults to `agentDir`. An executor that does not own the agent dir points
-     * this at a per-run directory of its own, so binding a profile's prompts and
-     * skills writes nothing into a dir it must not modify. The context file and
-     * the harness store have no flag and always land in `agentDir`; refuse those
-     * with {@link primeProfileNeedsAgentDir} instead.
-     */
-    flagFileRoot?: string;
-    /**
-     * Reports state the executor should see but that does not fail the run
-     * (currently: adopting entries a pre-shared executor left behind).
-     */
-    warn?: (msg: string, meta?: Record<string, unknown>) => void;
-    /** Agent-dir file access; the local filesystem when omitted. */
-    io?: PrimeAgentDirIo;
-}
-/**
- * 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 declare function materializePrimeProfileControls(agentDir: string, controls: PrimeProfileControls, options?: PrimeMaterializeOptions): string[];
-/**
- * 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 declare function prunePrimeProfileMaterial(agentDir: string, options?: Pick<PrimeMaterializeOptions, "flagFileRoot">): void;
-/**
- * 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 declare function seedPrimeProfileSubagents(agentDir: string, subagents: PrimeProfileSubagent[], warn?: (msg: string, meta?: Record<string, unknown>) => void, io?: PrimeAgentDirIo): void;
-import type { PrimeProfileControls, PrimeProfileSubagent } from "./prime-profile.js";