@hivemagnus/ardent 0.0.0-stage → 1.0.2

package/dist/config.d.ts

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+/** The host's IANA timezone, or UTC when it cannot be determined. */
+export declare function systemTimezone(): string;
+export declare const HiveMemConfigSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"hivemem">;
+    base_url: z.ZodString;
+    token_env: z.ZodString;
+    agent_id: z.ZodString;
+    workspace_id: z.ZodString;
+    default_scope: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        project: "project";
+    }>>;
+}, z.core.$strict>;
+export type HiveMemConfig = z.infer<typeof HiveMemConfigSchema>;
+export declare const ConfigSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    profile: z.ZodString;
+    name: z.ZodString;
+    product: z.ZodDefault<z.ZodString>;
+    timezone: z.ZodDefault<z.ZodString>;
+    identity: z.ZodDefault<z.ZodObject<{
+        soul_file: z.ZodDefault<z.ZodString>;
+        identity_file: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    execution: z.ZodObject<{
+        backend: z.ZodEnum<{
+            llamacpp: "llamacpp";
+            codex: "codex";
+        }>;
+        max_model_steps: z.ZodNumber;
+        max_tool_calls: z.ZodNumber;
+        max_parallel_tools: z.ZodNumber;
+        deadline_seconds: z.ZodNumber;
+        max_delegation_depth: z.ZodNumber;
+    }, z.core.$strict>;
+    providers: z.ZodObject<{
+        llamacpp: z.ZodObject<{
+            base_url: z.ZodString;
+            model: z.ZodString;
+            api_key_env: z.ZodString;
+            request_timeout_seconds: z.ZodNumber;
+            context_window_tokens: z.ZodOptional<z.ZodNumber>;
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$strict>;
+        codex: z.ZodObject<{
+            command: z.ZodString;
+            model: z.ZodString;
+            auth_mode: z.ZodDefault<z.ZodEnum<{
+                chatgpt: "chatgpt";
+                api_key: "api_key";
+            }>>;
+            approval_policy: z.ZodLiteral<"never">;
+            sandbox: z.ZodLiteral<"read-only">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    memory: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        provider: z.ZodLiteral<"none">;
+    }, z.core.$strict>, z.ZodObject<{
+        provider: z.ZodLiteral<"hivemem">;
+        base_url: z.ZodString;
+        token_env: z.ZodString;
+        agent_id: z.ZodString;
+        workspace_id: z.ZodString;
+        default_scope: z.ZodDefault<z.ZodEnum<{
+            private: "private";
+            project: "project";
+        }>>;
+    }, z.core.$strict>], "provider">>;
+    research: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        searxng_url: z.ZodDefault<z.ZodString>;
+        firecrawl_url: z.ZodDefault<z.ZodString>;
+        firecrawl_token_env: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        directories: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    a2a: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        protocol_version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+        bindings: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            jsonrpc: "jsonrpc";
+            "http-json": "http-json";
+            grpc: "grpc";
+        }>>>;
+        public_url: z.ZodDefault<z.ZodString>;
+        listen_host: z.ZodDefault<z.ZodString>;
+        listen_port: z.ZodOptional<z.ZodNumber>;
+        peers_file: z.ZodDefault<z.ZodString>;
+        hermes_compat: z.ZodDefault<z.ZodBoolean>;
+        skill: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            example: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    channels: z.ZodDefault<z.ZodObject<{
+        telegram: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            token_env: z.ZodDefault<z.ZodString>;
+            allowed_user_ids: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            allowed_chat_ids: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            receive_mode: z.ZodDefault<z.ZodLiteral<"polling">>;
+        }, z.core.$strict>>;
+        mattermost: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            base_url: z.ZodDefault<z.ZodString>;
+            token_env: z.ZodDefault<z.ZodString>;
+            allowed_user_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            allowed_channel_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            require_mention: z.ZodDefault<z.ZodBoolean>;
+            reply_mode: z.ZodDefault<z.ZodEnum<{
+                thread: "thread";
+                flat: "flat";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    integrations: z.ZodDefault<z.ZodObject<{
+        magnus_control: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            base_url: z.ZodDefault<z.ZodString>;
+            token_env: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    api: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        token_env: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ArdentConfig = z.infer<typeof ConfigSchema>;
+export type Profile = {
+    name: string;
+    path: string;
+};
+export type LoadedConfig = {
+    config: ArdentConfig;
+    revision: string;
+    text: string;
+    path: string;
+};
+export declare function ardentHome(env?: NodeJS.ProcessEnv): string;
+export declare const DEFAULT_PROFILE = "assistant";
+export declare function profilePath(name?: string, override?: string, env?: NodeJS.ProcessEnv): string;
+export declare function revision(text: string): string;
+export declare function parseConfig(text: string): ArdentConfig;
+export declare function loadConfig(dir: string): Promise<LoadedConfig>;
+export declare function resolveReference(value: string, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function runtimeProblems(config: ArdentConfig, env?: NodeJS.ProcessEnv): string[];
+export declare function redactedConfig(config: ArdentConfig): ArdentConfig;
+/** Optional Magnus Control read tools are enabled by config or `ARDENT_MAGNUS_CONTROL_TOOLS=true`. */
+export declare function magnusControlEnabled(config: ArdentConfig, env?: NodeJS.ProcessEnv): boolean;
+/** The bundled neutral profile template copied by `ardent init`. */
+export declare const PROFILE_TEMPLATE = "assistant";
+export declare function initProfile(dir: string, options?: {
+    profile?: string;
+    apiPort?: number;
+    template?: string;
+}): Promise<void>;
+export declare function saveConfig(dir: string, nextText: string, expectedRevision: string): Promise<string>;

package/dist/config.js

@@ -0,0 +1,244 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { readFile, writeFile, mkdir, rename, copyFile, chmod, cp, open, unlink, lstat, rm, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import { z } from 'zod';
+const envName = /^[A-Z][A-Z0-9_]*$/;
+const pathName = /^[A-Za-z0-9._-]+\.md$/;
+function safeUrl(value) {
+    try {
+        const url = new URL(value);
+        return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password && !url.hash && !url.search;
+    }
+    catch {
+        return false;
+    }
+}
+const urlReference = z.string().min(1).max(2048).refine(value => /^\$\{[A-Z][A-Z0-9_]*\}$/.test(value) || safeUrl(value), 'Expected an HTTP(S) URL without embedded credentials or an environment reference');
+const provider = z.object({ base_url: urlReference, model: z.string().min(1).max(200), api_key_env: z.string().regex(envName), request_timeout_seconds: z.number().int().min(1).max(600), context_window_tokens: z.number().int().min(2048).max(2_000_000).optional(), max_output_tokens: z.number().int().min(256).max(32768).optional(), reasoning_effort: z.enum(['none', 'low', 'medium', 'xhigh']).optional() }).strict();
+/** The host's IANA timezone, or UTC when it cannot be determined. */
+export function systemTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+const ianaTimezone = z.string().min(1).max(100).refine(value => {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, 'Unknown IANA timezone');
+const NoMemory = z.object({ provider: z.literal('none') }).strict();
+export const HiveMemConfigSchema = z.object({ provider: z.literal('hivemem'), base_url: urlReference, token_env: z.string().regex(envName), agent_id: z.string().min(1).max(100), workspace_id: z.string().min(1).max(100), default_scope: z.enum(['private', 'project']).default('private') }).strict();
+const TelegramChannel = z.object({ enabled: z.boolean().default(false), token_env: z.string().regex(envName).default('TELEGRAM_BOT_TOKEN'), allowed_user_ids: z.array(z.number().int().positive()).default([]), allowed_chat_ids: z.array(z.number().int()).default([]), receive_mode: z.literal('polling').default('polling') }).strict();
+const MattermostChannel = z.object({ enabled: z.boolean().default(false), base_url: urlReference.default('${MATTERMOST_URL}'), token_env: z.string().regex(envName).default('MATTERMOST_TOKEN'), allowed_user_ids: z.array(z.string().min(1)).default([]), allowed_channel_ids: z.array(z.string().min(1)).default([]), require_mention: z.boolean().default(true), reply_mode: z.enum(['thread', 'flat']).default('thread') }).strict();
+/** A plugin module specifier: an npm package name, or an absolute path / file URL to an ES module. */
+const pluginSpecifier = z.string().min(1).max(500).refine(value => /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*(?:\/[A-Za-z0-9._-]+)*$/.test(value) || value.startsWith('/') || value.startsWith('file://'), 'Expected an npm package name, an absolute path, or a file:// URL');
+const magnusControlDefault = { enabled: false, base_url: '${ARDENT_MAGNUS_API_URL}', token_env: 'ARDENT_MAGNUS_READ_TOKEN' };
+const a2aDefault = { enabled: false, protocol_version: '1.0', bindings: ['jsonrpc', 'http-json'], public_url: '${ARDENT_A2A_PUBLIC_URL}', listen_host: '127.0.0.1', peers_file: 'peers.yaml', hermes_compat: false };
+const researchDefault = { enabled: false, searxng_url: '${ARDENT_SEARXNG_URL}', firecrawl_url: '${ARDENT_FIRECRAWL_URL}', firecrawl_token_env: 'FIRECRAWL_API_KEY' };
+export const ConfigSchema = z.object({
+    schema_version: z.literal(1),
+    profile: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
+    name: z.string().min(1).max(100),
+    product: z.string().min(1).max(100).default('Ardent'),
+    /** IANA timezone for schedules and dates shown to the model. Defaults to the host zone. */
+    timezone: ianaTimezone.default(systemTimezone),
+    identity: z.object({ soul_file: z.string().regex(pathName).default('SOUL.md'), identity_file: z.string().regex(pathName).default('IDENTITY.md') }).strict().default({ soul_file: 'SOUL.md', identity_file: 'IDENTITY.md' }),
+    execution: z.object({ backend: z.enum(['llamacpp', 'codex']), max_model_steps: z.number().int().min(1).max(200), max_tool_calls: z.number().int().min(0).max(500), max_parallel_tools: z.number().int().min(1).max(16), deadline_seconds: z.number().int().min(1).max(86400), max_delegation_depth: z.number().int().min(0).max(8) }).strict(),
+    providers: z.object({ llamacpp: provider, codex: z.object({ command: z.string().min(1).max(500), model: z.string().min(1).max(200), auth_mode: z.enum(['chatgpt', 'api_key']).default('chatgpt'), approval_policy: z.literal('never'), sandbox: z.literal('read-only') }).strict() }).strict(),
+    /** Long-term memory. `none` (default) disables memory tools; `hivemem` uses a HiveMem server. */
+    memory: z.discriminatedUnion('provider', [NoMemory, HiveMemConfigSchema]).default({ provider: 'none' }),
+    research: z.object({ enabled: z.boolean().default(false), searxng_url: urlReference.default('${ARDENT_SEARXNG_URL}'), firecrawl_url: urlReference.default('${ARDENT_FIRECRAWL_URL}'), firecrawl_token_env: z.string().regex(envName).default('FIRECRAWL_API_KEY') }).strict().default(researchDefault),
+    skills: z.object({ directories: z.array(z.string().regex(/^[A-Za-z0-9._/-]+$/)).max(16).default(['skills']), enabled: z.array(z.string().min(1).max(100)).max(100).default([]) }).strict().default({ directories: ['skills'], enabled: [] }),
+    a2a: z.object({ enabled: z.boolean().default(false), protocol_version: z.literal('1.0').default('1.0'), bindings: z.array(z.enum(['jsonrpc', 'http-json', 'grpc'])).min(1).default(['jsonrpc', 'http-json']), public_url: urlReference.default('${ARDENT_A2A_PUBLIC_URL}'), listen_host: z.string().min(1).default('127.0.0.1'), listen_port: z.number().int().min(1).max(65534).optional(), peers_file: z.string().regex(/^[A-Za-z0-9._-]+\.yaml$/).default('peers.yaml'),
+        /** Serve Hermes Agent team-card discovery and slash-style JSON-RPC method aliases. */
+        hermes_compat: z.boolean().default(false),
+        /** Agent Card skill advertised to peers. */
+        skill: z.object({ id: z.string().regex(/^[a-z][a-z0-9-]{0,63}$/), name: z.string().min(1).max(100), description: z.string().min(1).max(500), tags: z.array(z.string().min(1).max(40)).max(10).default([]), example: z.string().min(1).max(300).optional() }).strict().optional() }).strict().default(a2aDefault),
+    channels: z.object({ telegram: TelegramChannel.default(TelegramChannel.parse({})), mattermost: MattermostChannel.default(MattermostChannel.parse({})) }).strict().default({ telegram: TelegramChannel.parse({}), mattermost: MattermostChannel.parse({}) }),
+    integrations: z.object({
+        /** Optional read-only Magnus Control tools. URL and token come only from config or the environment. */
+        magnus_control: z.object({ enabled: z.boolean().default(false), base_url: urlReference.default('${ARDENT_MAGNUS_API_URL}'), token_env: z.string().regex(envName).default('ARDENT_MAGNUS_READ_TOKEN') }).strict().default(magnusControlDefault)
+    }).strict().default({ magnus_control: magnusControlDefault }),
+    /** Plugin modules loaded by the gateway (npm package names, absolute paths, or file:// URLs). */
+    plugins: z.array(pluginSpecifier).max(32).default([]),
+    api: z.object({ host: z.string().min(1).default('127.0.0.1'), port: z.number().int().min(1).max(65535).default(9910), token_env: z.string().regex(envName).default('ARDENT_API_TOKEN') }).strict().default({ host: '127.0.0.1', port: 9910, token_env: 'ARDENT_API_TOKEN' })
+}).strict();
+export function ardentHome(env = process.env) {
+    return resolve(env.ARDENT_HOME ?? join(homedir(), '.ardent'));
+}
+export const DEFAULT_PROFILE = 'assistant';
+export function profilePath(name = DEFAULT_PROFILE, override, env = process.env) {
+    if (override) {
+        if (!isAbsolute(override))
+            throw new Error('Profile path override must be absolute');
+        return resolve(override);
+    }
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
+        throw new Error('Invalid profile name');
+    return join(ardentHome(env), 'profiles', name);
+}
+export function revision(text) { return createHash('sha256').update(text).digest('hex'); }
+export function parseConfig(text) {
+    const doc = YAML.parseDocument(text, { uniqueKeys: true });
+    if (doc.errors.length)
+        throw new Error(`Invalid YAML: ${doc.errors[0]?.message ?? 'unknown error'}`);
+    const value = doc.toJS();
+    const parsed = ConfigSchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`Invalid Ardent config: ${parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join('; ')}`);
+    return parsed.data;
+}
+export async function loadConfig(dir) {
+    const path = join(dir, 'config.yaml');
+    const text = await readFile(path, 'utf8');
+    return { config: parseConfig(text), revision: revision(text), text, path };
+}
+export function resolveReference(value, env = process.env) {
+    const match = /^\$\{([A-Z][A-Z0-9_]*)\}$/.exec(value);
+    if (!match)
+        return value;
+    return env[match[1] ?? ''];
+}
+export function runtimeProblems(config, env = process.env) {
+    const problems = [];
+    const need = (field, value) => {
+        const found = resolveReference(value, env);
+        if (!found)
+            problems.push(`${field} is unresolved`);
+        return found;
+    };
+    if (config.execution.backend === 'llamacpp') {
+        const base = need('providers.llamacpp.base_url', config.providers.llamacpp.base_url);
+        need('providers.llamacpp.model', config.providers.llamacpp.model);
+        if (base && !safeUrl(base))
+            problems.push('providers.llamacpp.base_url must be a credential-free HTTP(S) URL');
+    }
+    else
+        need('providers.codex.model', config.providers.codex.model);
+    if (config.channels.telegram.enabled && !env[config.channels.telegram.token_env])
+        problems.push('Telegram token is missing');
+    if (config.channels.mattermost.enabled && !env[config.channels.mattermost.token_env])
+        problems.push('Mattermost token is missing');
+    if (config.channels.mattermost.enabled)
+        need('channels.mattermost.base_url', config.channels.mattermost.base_url);
+    if (config.a2a.enabled)
+        need('a2a.public_url', config.a2a.public_url);
+    if (config.memory.provider === 'hivemem') {
+        need('memory.base_url', config.memory.base_url);
+        if (!env[config.memory.token_env])
+            problems.push('HiveMem token is missing');
+    }
+    if (config.research.enabled) {
+        need('research.searxng_url', config.research.searxng_url);
+        need('research.firecrawl_url', config.research.firecrawl_url);
+    }
+    if (magnusControlEnabled(config, env)) {
+        need('integrations.magnus_control.base_url', config.integrations.magnus_control.base_url);
+        if (!env[config.integrations.magnus_control.token_env])
+            problems.push('Magnus Control read token is missing');
+    }
+    return problems;
+}
+export function redactedConfig(config) {
+    return structuredClone(config); // Values are references only; no resolution is performed here.
+}
+/** Optional Magnus Control read tools are enabled by config or `ARDENT_MAGNUS_CONTROL_TOOLS=true`. */
+export function magnusControlEnabled(config, env = process.env) {
+    return config.integrations.magnus_control.enabled || env.ARDENT_MAGNUS_CONTROL_TOOLS === 'true';
+}
+const templates = fileURLToPath(new URL('../profiles/', import.meta.url));
+/** The bundled neutral profile template copied by `ardent init`. */
+export const PROFILE_TEMPLATE = 'assistant';
+export async function initProfile(dir, options = {}) {
+    const profile = options.profile ?? DEFAULT_PROFILE;
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(profile))
+        throw new Error('Invalid profile name');
+    const apiPort = options.apiPort ?? 9910;
+    if (!Number.isSafeInteger(apiPort) || apiPort < 1024 || apiPort > 65535)
+        throw new Error('Profile API port must be 1024-65535');
+    const target = resolve(dir);
+    const templateName = options.template ?? PROFILE_TEMPLATE;
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(templateName))
+        throw new Error('Invalid profile template');
+    const template = join(templates, templateName);
+    const parent = dirname(target);
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    const lockPath = join(parent, `.ardent-init-${createHash('sha256').update(target).digest('hex').slice(0, 24)}.lock`);
+    const lock = await open(lockPath, 'wx', 0o600).catch((error) => {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EEXIST')
+            throw new Error('Profile initialization is already in progress');
+        throw error;
+    });
+    const staged = join(parent, `.${profile}.${randomUUID()}.staging`);
+    try {
+        const existing = await lstat(target).catch((error) => {
+            if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (existing && (!existing.isDirectory() || (await readdir(target)).length > 0))
+            throw new Error('Profile path already exists');
+        await mkdir(staged, { mode: 0o700 });
+        for (const name of ['SOUL.md', 'IDENTITY.md', 'peers.yaml']) {
+            await copyFile(join(template, name), join(staged, name));
+            await chmod(join(staged, name), 0o600);
+        }
+        const document = YAML.parseDocument(await readFile(join(template, 'config.yaml'), 'utf8'));
+        document.set('profile', profile);
+        if (profile !== templateName)
+            document.set('name', profile);
+        if (!document.has('timezone'))
+            document.set('timezone', systemTimezone());
+        document.setIn(['api', 'port'], apiPort);
+        const text = String(document);
+        parseConfig(text);
+        await writeFile(join(staged, 'config.yaml'), text, { flag: 'wx', mode: 0o600 });
+        await writeFile(join(staged, '.env'), `ARDENT_API_TOKEN=${randomBytes(32).toString('hex')}\n`, { flag: 'wx', mode: 0o600 });
+        for (const name of ['workspace', 'state', 'artifacts', 'logs'])
+            await mkdir(join(staged, name), { mode: 0o700 });
+        await cp(join(template, 'skills'), join(staged, 'skills'), { recursive: true, force: false, errorOnExist: true });
+        await rename(staged, target);
+    }
+    finally {
+        await rm(staged, { recursive: true, force: true });
+        await lock.close();
+        await unlink(lockPath);
+    }
+}
+export async function saveConfig(dir, nextText, expectedRevision) {
+    const path = join(dir, 'config.yaml');
+    const lockPath = join(dir, '.config.write.lock');
+    const lock = await open(lockPath, 'wx', 0o600).catch((error) => {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EEXIST')
+            throw new Error('Configuration edit is already in progress');
+        throw error;
+    });
+    let tmp;
+    try {
+        const current = await loadConfig(dir);
+        if (current.revision !== expectedRevision)
+            throw new Error('Configuration revision conflict');
+        parseConfig(nextText);
+        tmp = join(dirname(path), `.config.${randomUUID()}.tmp`);
+        await writeFile(tmp, nextText, { mode: 0o600, flag: 'wx' });
+        await rename(tmp, path);
+        tmp = undefined;
+        return revision(nextText);
+    }
+    finally {
+        if (tmp)
+            await unlink(tmp).catch(() => { });
+        await lock.close();
+        await unlink(lockPath);
+    }
+}

package/dist/context-checkpoints.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { ChatMessage } from './llamacpp.js';
+import type { LoadedModelPolicy, ModelPolicy } from './model-policy.js';
+import type { Task, TaskStore } from './store.js';
+export declare const SummarySchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            status: "status";
+            observation: "observation";
+            decision: "decision";
+            open_item: "open_item";
+            correction: "correction";
+        }>;
+        text: z.ZodString;
+        source_message_ids: z.ZodArray<z.ZodNumber>;
+        historical_status: z.ZodLiteral<"historical_unverified">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ContextSummary = z.infer<typeof SummarySchema>;
+type ContextTask = Pick<Task, 'id' | 'session_id' | 'caller' | 'context' | 'prompt'>;
+export type CompactionCall = (route: ModelPolicy['compaction']['routes'][number], prompt: string, signal: AbortSignal) => Promise<string>;
+export declare function tokenEstimate(value: unknown): number;
+export declare class ContextCheckpoints {
+    readonly store: TaskStore;
+    readonly compactor: CompactionCall;
+    constructor(store: TaskStore, compactor: CompactionCall);
+    plainHistory(task: ContextTask): ChatMessage[];
+    private session;
+    private rows;
+    private exchanges;
+    private head;
+    status(sessionId: string, caller: string, context: string): Record<string, unknown>;
+    private record;
+    private history;
+    prepare(task: ContextTask, system: string, tools: unknown[], loaded: LoadedModelPolicy, signal: AbortSignal, options?: {
+        apply?: boolean;
+        force?: boolean;
+        expectedHead?: string | null;
+        expectedPolicyRevision?: number;
+        maxInputTokens?: number;
+        countTokens?: (messages: ChatMessage[], tools: unknown[]) => Promise<number | null>;
+    }): Promise<{
+        messages: ChatMessage[];
+        compacted: boolean;
+        status: Record<string, unknown>;
+        proposal: Record<string, unknown> | null;
+    }>;
+}
+export {};