@amalgm/agents 0.1.1 → 0.1.2

package/PURPOSE.md

@@ -13,6 +13,8 @@ and UI. This package stores references to those products and delegates
 execution to an injected driver; it does not duplicate their state.
 It also discovers installed agent skills across the canonical project and
 harness roots so every transport presents the same available skill catalog.
+Rich harness configuration is stored inside the same immutable definition and
+projected onto its executable fields; it is not a second agent registry.
 
 ## Primitives
 
@@ -37,6 +39,8 @@ harness roots so every transport presents the same available skill catalog.
    none is a second implementation.
 7. An unchanged current definition is idempotent; every actual change creates
    a new immutable revision, even when its content matches an earlier revision.
+8. Agent configuration and its executable projection change atomically in one
+   immutable revision; native imports never ingest credentials or MCP config.
 
 ## Consequences
 

package/README.md

@@ -83,6 +83,23 @@ The scanner reads the same canonical project, shared, Codex, Claude Code, and
 OpenCode roots as Engine. Hosts inject `skillRoots` when they need a selected
 project or an isolated home.
 
+Rich harness configuration remains part of the agent's immutable definition:
+
+```ts
+import { updateAgentConfig } from '@amalgm/agents';
+
+const { config } = updateAgentConfig(agents, 'reviewer', {
+  instructions: 'Review against the measured contract.',
+  skills: [{ name: 'parity', content: 'Run the parity meter.' }],
+  hooks: [{ event: 'Stop', type: 'command', command: 'npm test' }],
+});
+```
+
+The REST adapter also serves `/agent-config`, `/agent-config/get`,
+`/agent-config/update`, and `/agent-config/import-native`. Native import reads
+only instructions, skills, command hooks, and agent markdown from an injected
+home; credentials and MCP configuration never enter Agents.
+
 ## CLI
 
 ```bash

package/dist/bin/rest.js

@@ -6,12 +6,17 @@ import { fatal } from './fatal.js';
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (args.flags.has('help')) {
-        process.stdout.write('Usage: amalgm-agents-rest [--host 127.0.0.1] [--port 4317] [--token value]\n');
+        process.stdout.write('Usage: amalgm-agents-rest [--host 127.0.0.1] [--port 4317] [--token value] [--native-home dir]\n');
         return;
     }
     const agents = await openAgents(args);
     const token = flag(args, 'token') || process.env.AMALGM_AGENTS_TOKEN;
-    const rest = createRestServer({ agents, ...(token ? { token } : {}) });
+    const nativeHomeDir = flag(args, 'native-home') || process.env.AMALGM_NATIVE_HOME;
+    const rest = createRestServer({
+        agents,
+        ...(token ? { token } : {}),
+        ...(nativeHomeDir ? { nativeHomeDir } : {}),
+    });
     const address = await rest.listen(Number(flag(args, 'port') || 4317), flag(args, 'host') || '127.0.0.1');
     process.stderr.write(`amalgm-agents REST listening on http://${address.address}:${address.port}\n`);
     const close = () => void rest.close().then(() => agents.close()).catch(fatal);

package/dist/config/import.d.ts

@@ -0,0 +1,14 @@
+import type { Agents } from '../agents.js';
+import type { AgentRecord } from '../types.js';
+import type { AgentConfig } from './types.js';
+export declare function importAgentConfig(agents: Agents, agentId: string, options?: {
+    homeDir?: string;
+    replace?: boolean;
+}): {
+    config: AgentConfig;
+    importedAgents: {
+        created: boolean;
+        agent: AgentRecord;
+    }[];
+    sources: string[];
+};

package/dist/config/import.js

@@ -0,0 +1,59 @@
+import { AgentError } from '../errors.js';
+import { importNativeConfig } from './native.js';
+import { normalizeAgentConfig, stableConfigId } from './schema.js';
+import { configFromAgent, updateAgentConfig } from './store.js';
+function mergeById(existing, incoming) {
+    return [...new Map([...existing, ...incoming].map((item) => [item.id, item])).values()];
+}
+function mergeSubagents(existing, incoming) {
+    return [...new Map([...existing, ...incoming].map((item) => [item.agentId, item])).values()];
+}
+function importedId(parent, name) {
+    return stableConfigId('imported-agent', `${parent.id}-${name || 'subagent'}`);
+}
+function ensureImportedAgent(agents, parent, native) {
+    const id = importedId(parent, native.name);
+    const existing = agents.getAgent(id) || agents.listAgents().find((item) => item.definition.name === native.name);
+    if (existing) {
+        updateAgentConfig(agents, existing.id, {
+            instructions: native.instructions || existing.definition.instructions,
+        });
+        return { agent: agents.getAgent(existing.id), created: false };
+    }
+    const agent = agents.createAgent({
+        id, name: native.name, description: native.description,
+        driver: { ...parent.definition.driver, id: native.driverId }, model: parent.definition.model,
+        authRef: parent.definition.authRef, instructions: native.instructions,
+        resources: { files: [], skills: [], subagents: [] },
+        toolbox: { toolIds: [], actionIds: [] }, workspace: parent.definition.workspace,
+        metadata: { importedFrom: native.source },
+    });
+    updateAgentConfig(agents, agent.id, { instructions: native.instructions });
+    return { agent: agents.getAgent(agent.id), created: true };
+}
+function mergedConfig(existing, imported, subagents, replace) {
+    if (replace)
+        return normalizeAgentConfig({ ...existing, ...imported, subagents }, existing);
+    return normalizeAgentConfig({
+        ...existing,
+        instructions: existing.instructions || imported.instructions || '',
+        skills: mergeById(existing.skills, imported.skills || []),
+        hooks: mergeById(existing.hooks, imported.hooks || []),
+        subagents: mergeSubagents(existing.subagents, subagents),
+    }, existing);
+}
+// Engine reference: amalgm-mcp/agent-config/rest.js handleImportNative.
+export function importAgentConfig(agents, agentId, options = {}) {
+    const parent = agents.getAgent(agentId);
+    if (!parent)
+        throw new AgentError('not_found', `Agent not found: ${agentId}`);
+    const imported = importNativeConfig(parent.definition.driver.id, options.homeDir);
+    const importedAgents = imported.agents.map((native) => ensureImportedAgent(agents, parent, native));
+    const references = importedAgents.map(({ agent }, index) => ({
+        id: stableConfigId('subagent', agent.id), agentId: agent.id,
+        name: agent.definition.name, description: agent.definition.description, enabled: true,
+        source: imported.agents[index]?.source || { kind: 'native-import' },
+    }));
+    const config = mergedConfig(configFromAgent(parent), imported.config, references, options.replace === true);
+    return { config: updateAgentConfig(agents, agentId, config).config, importedAgents, sources: imported.sources };
+}

package/dist/config/native.d.ts

@@ -0,0 +1,2 @@
+import type { NativeConfigImport } from './types.js';
+export declare function importNativeConfig(driverId: string, homeDir?: string): NativeConfigImport;

package/dist/config/native.js

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseSkillFrontmatter } from '../skills/scanner.js';
+import { stableConfigId } from './schema.js';
+function readText(file, maxBytes = 128 * 1024) {
+    try {
+        const stat = fs.statSync(file);
+        return stat.isFile() && stat.size <= maxBytes ? fs.readFileSync(file, 'utf8') : '';
+    }
+    catch {
+        return '';
+    }
+}
+function readJson(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function directories(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map((entry) => path.join(root, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+function markdownFiles(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+            const file = path.join(root, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.'))
+                return markdownFiles(file);
+            return entry.isFile() && entry.name.toLowerCase().endsWith('.md') ? [file] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function skillsFrom(root, provider) {
+    return directories(root).flatMap((directory) => {
+        const file = path.join(directory, 'SKILL.md');
+        const content = readText(file);
+        if (!content)
+            return [];
+        const parsed = parseSkillFrontmatter(content);
+        const name = parsed.name || path.basename(directory);
+        return [{
+                id: stableConfigId('skill', `${provider}-${name}`), name,
+                description: parsed.description || '', content, enabled: true,
+                source: { kind: 'native-import', provider, path: file },
+            }];
+    });
+}
+function agentsFrom(root, provider) {
+    return markdownFiles(root).flatMap((file) => {
+        const content = readText(file);
+        if (!content)
+            return [];
+        const parsed = parseSkillFrontmatter(content);
+        const end = content.startsWith('---\n') ? content.indexOf('\n---', 4) : -1;
+        const body = end >= 0 ? content.slice(end + 4).replace(/^\r?\n/, '').trim() : content.trim();
+        return [{
+                name: parsed.name || path.basename(file, path.extname(file)),
+                description: parsed.description || '', driverId: provider, instructions: body,
+                source: { kind: 'native-import', provider, path: file },
+            }];
+    });
+}
+function appendHook(hooks, provider, sourcePath, event, value, matcher = '') {
+    const command = typeof value.command === 'string' ? value.command.trim() : '';
+    if (!command)
+        return;
+    const timeout = Number(value.timeout);
+    const phases = {
+        UserPromptSubmit: 'userSubmit', UserSubmit: 'userSubmit', Stop: 'responseComplete',
+        ResponseComplete: 'responseComplete',
+    };
+    hooks.push({
+        id: `${provider}:${sourcePath}:${event}:${hooks.length}`,
+        name: command.split(/\s+/).slice(0, 3).join(' '), enabled: true,
+        event, phase: phases[event] || event, matcher, type: 'command', command,
+        ...(Number.isFinite(timeout) && timeout > 0 ? { timeout } : {}),
+        ...(typeof value.statusMessage === 'string' && value.statusMessage.trim()
+            ? { statusMessage: value.statusMessage.trim() } : {}),
+        source: { kind: 'native-import', provider, path: sourcePath },
+    });
+}
+function extractHooks(value, hooks, provider, sourcePath, event, matcher = '') {
+    if (typeof value === 'string') {
+        appendHook(hooks, provider, sourcePath, event, { command: value }, matcher);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item) => extractHooks(item, hooks, provider, sourcePath, event, matcher));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const object = value;
+    const nextEvent = typeof object.event === 'string' ? object.event : event;
+    const nextMatcher = typeof object.matcher === 'string' ? object.matcher : matcher;
+    appendHook(hooks, provider, sourcePath, nextEvent, object, nextMatcher);
+    if (Array.isArray(object.hooks)) {
+        extractHooks(object.hooks, hooks, provider, sourcePath, nextEvent, nextMatcher);
+    }
+}
+function hooksFrom(files, provider) {
+    const hooks = [];
+    for (const file of files) {
+        const data = readJson(file);
+        const raw = data?.hooks ?? data;
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            continue;
+        for (const [event, value] of Object.entries(raw)) {
+            extractHooks(value, hooks, provider, file, event);
+        }
+    }
+    return hooks;
+}
+// Engine references: agent-config/importers/* and agents/hooks.js. Only
+// instructions, skills, command hooks, and agent markdown cross this boundary.
+export function importNativeConfig(driverId, homeDir = os.homedir()) {
+    if (driverId === 'codex') {
+        const root = path.join(homeDir, '.codex');
+        const instructions = readText(path.join(root, 'AGENTS.md'));
+        const hooksFile = path.join(root, 'hooks.json');
+        const skills = skillsFrom(path.join(root, 'skills'), driverId);
+        const hooks = hooksFrom([hooksFile], driverId);
+        return {
+            config: { ...(instructions ? { instructions } : {}), ...(skills.length ? { skills } : {}),
+                ...(hooks.length ? { hooks } : {}) },
+            agents: [], sources: [path.join(root, 'AGENTS.md'), path.join(root, 'skills'), hooksFile],
+        };
+    }
+    if (driverId === 'claude_code') {
+        const root = path.join(homeDir, '.claude');
+        const settings = ['settings.json', 'settings.local.json'].map((name) => path.join(root, name));
+        const instructions = readText(path.join(root, 'CLAUDE.md')) || readText(path.join(homeDir, 'CLAUDE.md'));
+        const configRoot = path.join(homeDir, '.config', 'claude');
+        const skills = [...skillsFrom(path.join(root, 'skills'), driverId),
+            ...skillsFrom(path.join(configRoot, 'skills'), driverId)];
+        const hooks = hooksFrom([...settings, path.join(homeDir, '.claude.json')], driverId);
+        const agents = [...agentsFrom(path.join(root, 'agents'), driverId),
+            ...agentsFrom(path.join(configRoot, 'agents'), driverId)];
+        return {
+            config: { ...(instructions ? { instructions } : {}), ...(skills.length ? { skills } : {}),
+                ...(hooks.length ? { hooks } : {}) },
+            agents,
+            sources: [path.join(root, 'CLAUDE.md'), path.join(root, 'skills'), path.join(root, 'agents'), ...settings],
+        };
+    }
+    if (driverId === 'opencode') {
+        const config = path.join(homeDir, '.config', 'opencode');
+        const dot = path.join(homeDir, '.opencode');
+        const data = readJson(path.join(config, 'opencode.json')) || readJson(path.join(config, 'config.json'))
+            || readJson(path.join(dot, 'opencode.json')) || {};
+        const instructions = ['instructions', 'systemPrompt', 'prompt']
+            .map((key) => data[key]).find((value) => typeof value === 'string');
+        const instructionText = instructions || readText(path.join(dot, 'AGENTS.md'));
+        const skills = [...skillsFrom(path.join(config, 'skills'), driverId),
+            ...skillsFrom(path.join(dot, 'skills'), driverId)];
+        return {
+            config: { ...(instructionText ? { instructions: instructionText } : {}),
+                ...(skills.length ? { skills } : {}) },
+            agents: [...agentsFrom(path.join(config, 'agents'), driverId), ...agentsFrom(path.join(dot, 'agents'), driverId)],
+            sources: [path.join(config, 'opencode.json'), path.join(config, 'skills'), path.join(config, 'agents'),
+                path.join(dot, 'AGENTS.md'), path.join(dot, 'skills'), path.join(dot, 'agents')],
+        };
+    }
+    return { config: {}, agents: [], sources: [] };
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig, AgentConfigInput } from './types.js';
+export declare function stableConfigId(prefix: string, seed: string): string;
+export declare function normalizeAgentConfig(input?: AgentConfigInput, fallback?: AgentConfigInput): AgentConfig;

package/dist/config/schema.js

@@ -0,0 +1,135 @@
+import crypto from 'node:crypto';
+import { isObject } from '../json.js';
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function clone(value, fallback) {
+    return isObject(value) ? JSON.parse(JSON.stringify(value)) : fallback;
+}
+function uniqueStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(text).filter(Boolean))];
+}
+export function stableConfigId(prefix, seed) {
+    const clean = text(seed).toLowerCase().replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '').slice(0, 80);
+    return clean ? `${prefix}-${clean}` : `${prefix}-${crypto.randomUUID()}`;
+}
+function skill(value, index) {
+    if (typeof value === 'string') {
+        const name = text(value);
+        return name ? {
+            id: stableConfigId('skill', name), name, description: '', content: '', enabled: true,
+            source: { kind: 'amalgm' },
+        } : null;
+    }
+    if (!isObject(value))
+        return null;
+    const content = typeof value.content === 'string' ? value.content : '';
+    const name = text(value.name || value.id) || `Skill ${index + 1}`;
+    if (!name && !content)
+        return null;
+    return {
+        id: text(value.id) || stableConfigId('skill', name || content.slice(0, 80)),
+        name, description: typeof value.description === 'string' ? value.description : '', content,
+        enabled: value.enabled !== false, source: clone(value.source, { kind: 'amalgm' }),
+    };
+}
+function skills(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byId = new Map();
+    value.forEach((item, index) => {
+        const normalized = skill(item, index);
+        if (normalized)
+            byId.set(normalized.id, normalized);
+    });
+    return [...byId.values()];
+}
+function hook(value, index) {
+    if (!isObject(value))
+        return null;
+    const command = text(value.command);
+    const type = text(value.type) || (command ? 'command' : 'native');
+    if (type === 'command' && !command)
+        return null;
+    const event = text(value.event || value.phase) || 'UserPromptSubmit';
+    const name = text(value.name || value.label) || command.split(/\s+/).slice(0, 3).join(' ') || event;
+    const timeout = Number(value.timeout);
+    return {
+        id: text(value.id) || stableConfigId('hook', `${event}-${name}-${index}`),
+        name, enabled: value.enabled !== false, event, phase: text(value.phase) || event,
+        matcher: typeof value.matcher === 'string' ? value.matcher : '', type,
+        ...(command ? { command } : {}),
+        ...(Number.isFinite(timeout) && timeout > 0 ? { timeout } : {}),
+        ...(text(value.statusMessage) ? { statusMessage: text(value.statusMessage) } : {}),
+        source: clone(value.source, {
+            kind: value.source === 'native' ? 'native-import' : 'amalgm',
+            ...(text(value.harnessId) ? { harnessId: text(value.harnessId) } : {}),
+            ...(text(value.sourcePath) ? { path: text(value.sourcePath) } : {}),
+        }),
+    };
+}
+function hooks(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byId = new Map();
+    value.forEach((item, index) => {
+        const normalized = hook(item, index);
+        if (normalized)
+            byId.set(normalized.id, normalized);
+    });
+    return [...byId.values()];
+}
+function subagent(value, index) {
+    const raw = typeof value === 'string' ? { agentId: value } : value;
+    if (!isObject(raw))
+        return null;
+    const agentId = text(raw.agentId || raw.agent_id || raw.id);
+    if (!agentId)
+        return null;
+    return {
+        id: text(raw.id) || stableConfigId('subagent', `${agentId}-${index}`), agentId,
+        name: text(raw.name), description: typeof raw.description === 'string' ? raw.description : '',
+        enabled: raw.enabled !== false, source: clone(raw.source, { kind: 'amalgm' }),
+    };
+}
+function subagents(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byAgent = new Map();
+    value.forEach((item, index) => {
+        const normalized = subagent(item, index);
+        if (normalized)
+            byAgent.set(normalized.agentId, normalized);
+    });
+    return [...byAgent.values()];
+}
+function loadout(value, fallback) {
+    const raw = isObject(value) ? value : {};
+    const prior = isObject(fallback) ? fallback : {};
+    const aliases = (source) => source.toolIds || source.selectedToolIds
+        || source.selected || source.tools;
+    const explicit = ['toolIds', 'selectedToolIds', 'selected', 'tools']
+        .some((key) => Object.hasOwn(raw, key));
+    return { toolIds: uniqueStrings(explicit ? aliases(raw) : aliases(prior)) };
+}
+// Engine reference: amalgm-mcp/agent-config/schema.js.
+export function normalizeAgentConfig(input = {}, fallback = {}) {
+    const raw = isObject(input) ? input : {};
+    const prior = isObject(fallback) ? fallback : {};
+    const agentId = text(raw.agentId || raw.agent_id || prior.agentId);
+    const instructions = raw.instructions ?? raw.systemPrompt;
+    const instructionText = isObject(instructions) && typeof instructions.text === 'string'
+        ? instructions.text : instructions;
+    return {
+        version: 1, ...(agentId ? { agentId } : {}), runtimeHomeLayout: 'per-agent',
+        instructions: typeof instructionText === 'string'
+            ? instructionText : typeof prior.instructions === 'string' ? prior.instructions : '',
+        skills: skills(raw.skills ?? prior.skills ?? []),
+        loadout: loadout(raw.loadout ?? raw.toolset ?? raw.tools, prior.loadout ?? prior.tools),
+        hooks: hooks(raw.hooks ?? prior.hooks ?? []),
+        subagents: subagents(raw.subagents ?? prior.subagents ?? []),
+    };
+}

package/dist/config/store.d.ts

@@ -0,0 +1,9 @@
+import type { Agents } from '../agents.js';
+import type { AgentRecord } from '../types.js';
+import type { AgentConfig, AgentConfigInput } from './types.js';
+export declare function configFromAgent(agent: AgentRecord): AgentConfig;
+export declare function listAgentConfigs(agents: Agents): AgentConfig[];
+export declare function updateAgentConfig(agents: Agents, agentId: string, patch: AgentConfigInput): {
+    agent: AgentRecord;
+    config: AgentConfig;
+};

package/dist/config/store.js

@@ -0,0 +1,56 @@
+import { AgentError } from '../errors.js';
+import { isObject } from '../json.js';
+import { normalizeAgentConfig } from './schema.js';
+const METADATA_KEY = 'agentConfig';
+function configDocument(agent) {
+    const value = agent.definition.metadata[METADATA_KEY];
+    return isObject(value) ? value : {};
+}
+function same(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+// Engine reference: amalgm-mcp/agent-config/store.js. The immutable Agent
+// revision is the store here; no second agent_configs database is introduced.
+export function configFromAgent(agent) {
+    const stored = normalizeAgentConfig(configDocument(agent), {
+        agentId: agent.id,
+        instructions: agent.definition.instructions,
+        skills: agent.definition.resources.skills,
+        loadout: { toolIds: agent.definition.toolbox.toolIds },
+        subagents: agent.definition.resources.subagents,
+    });
+    const skillRefs = stored.skills.filter((item) => item.enabled).map((item) => item.name || item.id);
+    const subagentRefs = stored.subagents.filter((item) => item.enabled).map((item) => item.agentId);
+    return normalizeAgentConfig({
+        ...stored,
+        agentId: agent.id,
+        instructions: stored.instructions.trim() === agent.definition.instructions
+            ? stored.instructions : agent.definition.instructions,
+        skills: same(skillRefs, agent.definition.resources.skills)
+            ? stored.skills : agent.definition.resources.skills,
+        loadout: { toolIds: agent.definition.toolbox.toolIds },
+        subagents: same(subagentRefs, agent.definition.resources.subagents)
+            ? stored.subagents : agent.definition.resources.subagents,
+    }, stored);
+}
+export function listAgentConfigs(agents) {
+    return agents.listAgents().map(configFromAgent);
+}
+export function updateAgentConfig(agents, agentId, patch) {
+    const current = agents.getAgent(agentId);
+    if (!current)
+        throw new AgentError('not_found', `Agent not found: ${agentId}`);
+    const existing = configFromAgent(current);
+    const config = normalizeAgentConfig({ ...existing, ...patch, agentId }, existing);
+    const metadata = { ...current.definition.metadata, [METADATA_KEY]: config };
+    const projected = {
+        instructions: config.instructions,
+        resources: {
+            skills: config.skills.filter((item) => item.enabled).map((item) => item.name || item.id),
+            subagents: config.subagents.filter((item) => item.enabled).map((item) => item.agentId),
+        },
+        toolbox: { toolIds: config.loadout.toolIds },
+        metadata,
+    };
+    return { agent: agents.updateAgent(agentId, projected), config };
+}

package/dist/config/types.d.ts

@@ -0,0 +1,55 @@
+import type { JsonObject } from '../types.js';
+export interface ConfigSkill {
+    id: string;
+    name: string;
+    description: string;
+    content: string;
+    enabled: boolean;
+    source: JsonObject;
+}
+export interface ConfigHook {
+    id: string;
+    name: string;
+    enabled: boolean;
+    event: string;
+    phase: string;
+    matcher: string;
+    type: string;
+    command?: string;
+    timeout?: number;
+    statusMessage?: string;
+    source: JsonObject;
+}
+export interface ConfigSubagent {
+    id: string;
+    agentId: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    source: JsonObject;
+}
+export interface AgentConfig {
+    version: 1;
+    agentId?: string;
+    runtimeHomeLayout: 'per-agent';
+    instructions: string;
+    skills: ConfigSkill[];
+    loadout: {
+        toolIds: string[];
+    };
+    hooks: ConfigHook[];
+    subagents: ConfigSubagent[];
+}
+export interface NativeAgent {
+    name: string;
+    description: string;
+    driverId: string;
+    instructions: string;
+    source: JsonObject;
+}
+export interface NativeConfigImport {
+    config: Partial<AgentConfig>;
+    agents: NativeAgent[];
+    sources: string[];
+}
+export type AgentConfigInput = AgentConfig | Record<string, unknown>;

package/dist/config/types.js

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

package/dist/http/config-routes.d.ts

@@ -0,0 +1,2 @@
+import type { RouteContext } from '../http-types.js';
+export declare function routeAgentConfig(context: RouteContext): Promise<boolean>;

package/dist/http/config-routes.js

@@ -0,0 +1,46 @@
+import { isObject } from '../json.js';
+import { importAgentConfig } from '../config/import.js';
+import { configFromAgent, listAgentConfigs, updateAgentConfig } from '../config/store.js';
+function agentId(body) {
+    return typeof body.agent_id === 'string' ? body.agent_id.trim() : '';
+}
+export async function routeAgentConfig(context) {
+    const [resource, action, child] = context.path;
+    if (resource !== 'agent-config')
+        return false;
+    if (!action && context.method === 'GET') {
+        context.json(200, { configs: listAgentConfigs(context.agents) });
+        return true;
+    }
+    if (child || context.method !== 'POST')
+        return false;
+    const body = await context.body();
+    const id = agentId(body);
+    if (!id) {
+        context.json(400, { error: 'agent_id is required' });
+        return true;
+    }
+    const agent = context.agents.getAgent(id);
+    if (!agent) {
+        context.json(404, { error: `Agent not found: ${id}` });
+        return true;
+    }
+    if (action === 'get') {
+        context.json(200, { config: configFromAgent(agent) });
+        return true;
+    }
+    if (action === 'update') {
+        const config = isObject(body.config) ? body.config : {};
+        context.json(200, { ok: true, config: updateAgentConfig(context.agents, id, config).config });
+        return true;
+    }
+    if (action === 'import-native') {
+        const result = importAgentConfig(context.agents, id, {
+            ...(context.nativeHomeDir ? { homeDir: context.nativeHomeDir } : {}),
+            replace: body.replace === true,
+        });
+        context.json(200, { ok: true, ...result });
+        return true;
+    }
+    return false;
+}

package/dist/http/server.js

@@ -1,6 +1,7 @@
 import http from 'node:http';
 import { Agents } from '../agents.js';
 import { asAgentError } from '../errors.js';
+import { routeAgentConfig } from './config-routes.js';
 import { routeAgents } from './agent-routes.js';
 import { guardRequest, readJson, sendJson } from './request.js';
 import { routeSessions } from './session-routes.js';
@@ -44,10 +45,11 @@ export function createRestServer(options = {}) {
             path,
             url,
             skillRoots: options.skillRoots || {},
+            ...(options.nativeHomeDir ? { nativeHomeDir: options.nativeHomeDir } : {}),
             body: () => readJson(request, bodyLimit),
             json: (status, value) => sendJson(response, status, value),
         };
-        if (await routeSkills(context))
+        if (await routeAgentConfig(context) || await routeSkills(context))
             return;
         if (path.shift() !== 'v1') {
             sendJson(response, 404, { error: { code: 'not_found', message: 'Route not found.' } });

package/dist/http-types.d.ts

@@ -8,6 +8,7 @@ export interface RestServerOptions extends AgentsOptions {
     token?: string;
     bodyLimitBytes?: number;
     skillRoots?: SkillRootOptions;
+    nativeHomeDir?: string;
 }
 export interface RestServer {
     agents: Agents;
@@ -21,6 +22,7 @@ export interface RouteContext {
     path: string[];
     url: URL;
     skillRoots: SkillRootOptions;
+    nativeHomeDir?: string;
     body(): Promise<Record<string, unknown>>;
     json(status: number, value: unknown): void;
 }

package/dist/index.d.ts

@@ -8,3 +8,8 @@ export { buildCanonicalSkillRoots, classifySkillRoot } from './skills/roots.js';
 export type { SkillRootClassification, SkillRootOptions } from './skills/roots.js';
 export { parseSkillFrontmatter, scanInstalledSkills } from './skills/scanner.js';
 export type { InstalledSkill, SkillScanOptions } from './skills/scanner.js';
+export { normalizeAgentConfig, stableConfigId } from './config/schema.js';
+export { configFromAgent, listAgentConfigs, updateAgentConfig } from './config/store.js';
+export { importAgentConfig } from './config/import.js';
+export { importNativeConfig } from './config/native.js';
+export type * from './config/types.js';

package/dist/index.js

@@ -5,3 +5,7 @@ export { definitionHash, normalizeDefinition, patchDefinition } from './definiti
 export { messageText, normalizeMessage } from './messages.js';
 export { buildCanonicalSkillRoots, classifySkillRoot } from './skills/roots.js';
 export { parseSkillFrontmatter, scanInstalledSkills } from './skills/scanner.js';
+export { normalizeAgentConfig, stableConfigId } from './config/schema.js';
+export { configFromAgent, listAgentConfigs, updateAgentConfig } from './config/store.js';
+export { importAgentConfig } from './config/import.js';
+export { importNativeConfig } from './config/native.js';

package/dist/mcp/server.js

@@ -16,7 +16,7 @@ export function createMcpServer(options = {}) {
             return {
                 protocolVersion: message.params?.protocolVersion || '2024-11-05',
                 capabilities: { tools: { listChanged: false } },
-                serverInfo: { name: 'amalgm-agents', version: '0.1.1' },
+                serverInfo: { name: 'amalgm-agents', version: '0.1.2' },
             };
         }
         if (message.method === 'ping')

package/docs/REST.md

@@ -10,6 +10,19 @@ token receives the kernel's canonical 401 from `@amalgm/core/transport`,
 compared in constant time. `/healthz` is a minimal unauthenticated liveness
 response. JSON bodies default to a 512 KB limit.
 
+## Agent configuration
+
+| Method | Path | Result |
+|---|---|---|
+| `GET` | `/agent-config` | List normalized configs from live agent revisions |
+| `POST` | `/agent-config/get` | Read `{ agent_id }` |
+| `POST` | `/agent-config/update` | Atomically apply `{ agent_id, config }` |
+| `POST` | `/agent-config/import-native` | Import safe native fields for `{ agent_id, replace? }` |
+
+Set `nativeHomeDir` when embedding the server or `--native-home`/
+`AMALGM_NATIVE_HOME` with the REST binary. Native import intentionally ignores
+auth files, secrets, and MCP server configuration.
+
 ## Agents
 
 | Method | Path | Result |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/agents",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Local-first agent definitions, immutable revisions, and durable sessions.",
   "license": "UNLICENSED",
   "private": false,