agent-sin 0.1.0

package/dist/core/input-schema.js

@@ -0,0 +1,156 @@
+import { l } from "./i18n.js";
+export function validateSkillArgs(manifest, args) {
+    try {
+        const value = validateValue(args, manifest.input?.schema || { type: "object" }, "input");
+        if (!isPlainObject(value)) {
+            throw new Error(l("input must be an object", "input は object である必要があります"));
+        }
+        return value;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(l(`Invalid input for ${manifest.id}: ${message}`, `${manifest.id} の入力が不正です: ${message}`));
+    }
+}
+function validateValue(value, schema, label) {
+    if (value === undefined) {
+        if ("default" in schema) {
+            return schema.default;
+        }
+        return value;
+    }
+    if (schema.enum && !schema.enum.some((item) => deepEqual(item, value))) {
+        throw new Error(l(`${label} must be one of: ${schema.enum.map(String).join(", ")}`, `${label} は次のいずれかである必要があります: ${schema.enum.map(String).join(", ")}`));
+    }
+    const type = firstType(schema);
+    if (!type && (schema.properties || schema.required)) {
+        return validateObject(value, schema, label);
+    }
+    switch (type) {
+        case "object":
+            return validateObject(value, schema, label);
+        case "array":
+            return validateArray(value, schema, label);
+        case "string":
+            return validateString(value, schema, label);
+        case "integer":
+            return validateNumber(value, schema, label, true);
+        case "number":
+            return validateNumber(value, schema, label, false);
+        case "boolean":
+            return validateBoolean(value, label);
+        case undefined:
+            return value;
+        default:
+            throw new Error(l(`${label} uses unsupported schema type: ${type}`, `${label} は未対応の schema type です: ${type}`));
+    }
+}
+function validateObject(value, schema, label) {
+    if (!isPlainObject(value)) {
+        throw new Error(l(`${label} must be an object`, `${label} は object である必要があります`));
+    }
+    const source = value;
+    const result = {};
+    const properties = schema.properties || {};
+    const required = schema.required || [];
+    for (const key of required) {
+        if (!(key in source) || source[key] === undefined) {
+            throw new Error(l(`${label}.${key} is required`, `${label}.${key} は必須です`));
+        }
+    }
+    for (const [key, itemSchema] of Object.entries(properties)) {
+        if (key in source) {
+            result[key] = validateValue(source[key], itemSchema, `${label}.${key}`);
+        }
+        else if ("default" in itemSchema) {
+            result[key] = itemSchema.default;
+        }
+    }
+    for (const [key, item] of Object.entries(source)) {
+        if (key in properties) {
+            continue;
+        }
+        if (schema.additionalProperties === false) {
+            throw new Error(l(`${label}.${key} is not allowed`, `${label}.${key} は許可されていません`));
+        }
+        result[key] = item;
+    }
+    return result;
+}
+function validateArray(value, schema, label) {
+    if (!Array.isArray(value)) {
+        throw new Error(l(`${label} must be an array`, `${label} は array である必要があります`));
+    }
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        throw new Error(l(`${label} must contain at least ${schema.minItems} item(s)`, `${label} は最低 ${schema.minItems} 件必要です`));
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        throw new Error(l(`${label} must contain at most ${schema.maxItems} item(s)`, `${label} は最大 ${schema.maxItems} 件までです`));
+    }
+    if (!schema.items) {
+        return value;
+    }
+    return value.map((item, index) => validateValue(item, schema.items, `${label}[${index}]`));
+}
+function validateString(value, schema, label) {
+    let normalized;
+    if (typeof value === "string") {
+        normalized = value;
+    }
+    else if (typeof value === "number" || typeof value === "boolean") {
+        normalized = String(value);
+    }
+    else {
+        throw new Error(l(`${label} must be a string`, `${label} は string である必要があります`));
+    }
+    if (schema.minLength !== undefined && normalized.length < schema.minLength) {
+        throw new Error(l(`${label} must be at least ${schema.minLength} character(s)`, `${label} は最低 ${schema.minLength} 文字必要です`));
+    }
+    if (schema.maxLength !== undefined && normalized.length > schema.maxLength) {
+        throw new Error(l(`${label} must be at most ${schema.maxLength} character(s)`, `${label} は最大 ${schema.maxLength} 文字までです`));
+    }
+    return normalized;
+}
+function validateNumber(value, schema, label, integer) {
+    let normalized = value;
+    if (typeof normalized === "string" && normalized.trim() !== "") {
+        normalized = Number(normalized);
+    }
+    if (typeof normalized !== "number" || !Number.isFinite(normalized)) {
+        throw new Error(l(`${label} must be a ${integer ? "integer" : "number"}`, `${label} は ${integer ? "integer" : "number"} である必要があります`));
+    }
+    if (integer && !Number.isInteger(normalized)) {
+        throw new Error(l(`${label} must be an integer`, `${label} は integer である必要があります`));
+    }
+    if (schema.minimum !== undefined && normalized < schema.minimum) {
+        throw new Error(l(`${label} must be at least ${schema.minimum}`, `${label} は ${schema.minimum} 以上である必要があります`));
+    }
+    if (schema.maximum !== undefined && normalized > schema.maximum) {
+        throw new Error(l(`${label} must be at most ${schema.maximum}`, `${label} は ${schema.maximum} 以下である必要があります`));
+    }
+    return normalized;
+}
+function validateBoolean(value, label) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    throw new Error(l(`${label} must be a boolean`, `${label} は boolean である必要があります`));
+}
+function firstType(schema) {
+    if (Array.isArray(schema.type)) {
+        return schema.type[0];
+    }
+    return schema.type;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}

package/dist/core/intent-router.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig } from "./config.js";
+import type { SkillManifest } from "./skill-registry.js";
+export type Intent = "chat" | "skill_create" | "skill_edit" | "skill_run" | "unclear";
+export interface IntentResult {
+    intent: Intent;
+    matched_skill_id?: string;
+    matched_draft_id?: string;
+    suggested_skill_id?: string;
+    confidence: "low" | "med" | "high";
+    reason: string;
+}
+export interface IntentRouterTurn {
+    role: "user" | "assistant" | "tool";
+    content: string;
+}
+export interface ClassifyOptions {
+    history?: IntentRouterTurn[];
+    modelId?: string;
+    drafts?: IntentDraftCandidate[];
+}
+export interface IntentDraftCandidate {
+    skill_id: string;
+    status?: string;
+    summary?: string;
+}
+export declare function classifyIntent(config: AppConfig, userText: string, skills: SkillManifest[], options?: ClassifyOptions): Promise<IntentResult>;
+export declare function buildRouterSystemPrompt(skills: SkillManifest[], drafts?: IntentDraftCandidate[]): string;

package/dist/core/intent-router.js

@@ -0,0 +1,160 @@
+import { getAiProvider } from "./ai-provider.js";
+const FALLBACK = {
+    intent: "chat",
+    confidence: "low",
+    reason: "router fallback",
+};
+export async function classifyIntent(config, userText, skills, options = {}) {
+    const trimmed = userText.trim();
+    if (!trimmed) {
+        return FALLBACK;
+    }
+    const system = buildRouterSystemPrompt(skills, options.drafts || []);
+    const messages = [{ role: "system", content: system }];
+    for (const turn of options.history || []) {
+        messages.push({
+            role: turn.role === "tool" ? "tool" : turn.role,
+            content: turn.content,
+        });
+    }
+    messages.push({
+        role: "user",
+        content: `Classify the following user input.\n\n<input>${trimmed}</input>\n\nReturn JSON only.`,
+    });
+    let response;
+    try {
+        response = await getAiProvider()(config, {
+            model_id: options.modelId || config.chat_model_id,
+            messages,
+            temperature: 0,
+        });
+    }
+    catch {
+        return FALLBACK;
+    }
+    const parsed = parseRouterJson(response.text);
+    if (!parsed) {
+        return FALLBACK;
+    }
+    return normalizeIntent(parsed, skills, options.drafts || []);
+}
+export function buildRouterSystemPrompt(skills, drafts = []) {
+    const lines = [
+        "You are Agent-Sin's intent router.",
+        "Classify the user's input as one of these:",
+        "- skill_create : intent to create a new reusable skill, automation, or tool",
+        "- skill_edit   : intent to modify, extend, or change behavior of an existing skill",
+        "- skill_run    : intent to run an existing skill as-is",
+        "- chat         : conversation, advice, question, research, or other input not intended as a skill",
+        "- unclear      : cannot determine",
+        "",
+        "Rules:",
+        "- If the user wants a reusable mechanism, automation, or something they can keep using, classify as skill_create or skill_edit.",
+        "- If requirements strongly match an existing skill, prefer skill_run or skill_edit.",
+        "- If requirements strongly match an in-progress draft, return skill_create with matched_draft_id and do not create a new suggested_skill_id.",
+        "- One-off task requests, opinions, and casual chat are chat.",
+        "- If unsure, choose chat rather than unclear.",
+        "",
+        "<skills>",
+    ];
+    if (skills.length === 0) {
+        lines.push("  <empty/>");
+    }
+    else {
+        for (const skill of skills) {
+            const desc = (skill.description || skill.name || "").replaceAll("\n", " ").slice(0, 200);
+            lines.push(`  <skill id="${escapeXml(skill.id)}">${escapeXml(desc)}</skill>`);
+        }
+    }
+    lines.push("</skills>");
+    lines.push("");
+    lines.push("<drafts>");
+    if (drafts.length === 0) {
+        lines.push("  <empty/>");
+    }
+    else {
+        for (const draft of drafts.slice(0, 30)) {
+            const summary = (draft.summary || "").replaceAll("\n", " ").slice(0, 200);
+            const status = (draft.status || "").replaceAll("\n", " ").slice(0, 40);
+            lines.push(`  <draft id="${escapeXml(draft.skill_id)}" status="${escapeXml(status)}">${escapeXml(summary)}</draft>`);
+        }
+    }
+    lines.push("</drafts>");
+    lines.push("");
+    lines.push("Return exactly one JSON object. No explanation and no ``` fences:");
+    lines.push('{"intent":"chat|skill_create|skill_edit|skill_run|unclear","matched_skill_id":"...","matched_draft_id":"...","suggested_skill_id":"...","confidence":"low|med|high","reason":"..."}');
+    lines.push("Include matched_skill_id only when it exactly matches an id in <skills>, matched_draft_id only when it exactly matches an id in <drafts>, and suggested_skill_id only for new skill creation as one kebab-case suggestion.");
+    return lines.join("\n");
+}
+function parseRouterJson(text) {
+    const stripped = text
+        .replace(/```json\s*/gi, "")
+        .replace(/```\s*$/g, "")
+        .trim();
+    const start = stripped.indexOf("{");
+    const end = stripped.lastIndexOf("}");
+    if (start < 0 || end <= start) {
+        return null;
+    }
+    const slice = stripped.slice(start, end + 1);
+    try {
+        const parsed = JSON.parse(slice);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function normalizeIntent(raw, skills, drafts = []) {
+    const intentRaw = String(raw.intent || "").trim().toLowerCase();
+    const intent = (["chat", "skill_create", "skill_edit", "skill_run", "unclear"].includes(intentRaw)
+        ? intentRaw
+        : "chat");
+    const confidenceRaw = String(raw.confidence || "low").trim().toLowerCase();
+    const confidence = (["low", "med", "high"].includes(confidenceRaw) ? confidenceRaw : "low");
+    const reason = typeof raw.reason === "string" ? raw.reason.slice(0, 240) : "";
+    const matchedRaw = typeof raw.matched_skill_id === "string" ? raw.matched_skill_id.trim() : "";
+    const matchedDraftRaw = typeof raw.matched_draft_id === "string" ? raw.matched_draft_id.trim() : "";
+    const suggestedRaw = typeof raw.suggested_skill_id === "string" ? raw.suggested_skill_id.trim() : "";
+    const matched = matchedRaw && skills.some((s) => s.id === matchedRaw) ? matchedRaw : undefined;
+    const matchedDraft = matchedDraftRaw && drafts.some((draft) => draft.skill_id === matchedDraftRaw)
+        ? matchedDraftRaw
+        : undefined;
+    const suggested = suggestedRaw ? sanitizeSkillId(suggestedRaw) : undefined;
+    if ((intent === "skill_run" || intent === "skill_edit") && !matched) {
+        return {
+            intent: intent === "skill_edit" ? "skill_create" : "chat",
+            suggested_skill_id: suggested,
+            confidence,
+            reason: reason || "matched_skill_id missing",
+        };
+    }
+    return {
+        intent,
+        matched_skill_id: matched,
+        matched_draft_id: matchedDraft,
+        suggested_skill_id: intent === "skill_create" ? suggested : undefined,
+        confidence,
+        reason,
+    };
+}
+function sanitizeSkillId(raw) {
+    const cleaned = raw
+        .toLowerCase()
+        .replaceAll("_", "-")
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+    return cleaned ? cleaned : undefined;
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,60 @@
+import type { AppConfig } from "./config.js";
+export interface RunLogRecord {
+    run_id: string;
+    skill_id: string;
+    status: string;
+    started_at: string;
+    finished_at: string;
+    attempts?: number;
+    input: unknown;
+    result?: unknown;
+    error?: string;
+    saved_outputs?: unknown[];
+    memory_path?: string;
+    dry_run?: boolean;
+    ctx_logs?: Array<{
+        level: "info" | "warn" | "error";
+        message: string;
+        ts?: string;
+    }>;
+}
+export type EventLogLevel = "info" | "warn" | "error";
+export type EventLogSource = "cli" | "chat" | "skill" | "setup" | "build" | "schedule" | "discord" | "telegram";
+export interface EventLogEntry {
+    ts?: string;
+    level: EventLogLevel;
+    source: EventLogSource;
+    event: string;
+    message?: string;
+    details?: Record<string, unknown>;
+}
+export interface ReadEventLogOptions {
+    tail?: number;
+    level?: EventLogLevel;
+    source?: EventLogSource;
+}
+export interface ReadEventLogResult extends EventLogEntry {
+    ts: string;
+    raw: string;
+}
+export declare function createRunId(): string;
+export declare function writeRunLog(config: AppConfig, record: RunLogRecord): Promise<string>;
+export declare function appendEventLog(config: AppConfig, entry: EventLogEntry): Promise<void>;
+export type ConversationLogSource = "chat" | "builder";
+export type ConversationLogRole = "user" | "assistant" | "system" | "tool";
+export interface ConversationLogEntry {
+    ts?: string;
+    source: ConversationLogSource;
+    role: ConversationLogRole;
+    content: string;
+    model_id?: string;
+    skill_id?: string;
+    session_id?: string;
+    details?: Record<string, unknown>;
+}
+export declare function appendConversationLog(config: AppConfig, entry: ConversationLogEntry): Promise<void>;
+export declare function dailyConversationMemoryFile(config: AppConfig, date?: Date): string;
+export declare function pruneOldLogs(config: AppConfig): Promise<void>;
+export declare function readEventLog(config: AppConfig, options?: ReadEventLogOptions): Promise<ReadEventLogResult[]>;
+export declare function listRunLogs(config: AppConfig, skillId?: string): Promise<RunLogRecord[]>;
+export declare function readRunLog(config: AppConfig, runId: string): Promise<RunLogRecord>;

package/dist/core/logger.js

@@ -0,0 +1,240 @@
+import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import crypto from "node:crypto";
+import path from "node:path";
+import { l } from "./i18n.js";
+export function createRunId() {
+    return crypto.randomUUID();
+}
+export async function writeRunLog(config, record) {
+    const runsDir = path.join(config.logs_dir, "runs");
+    await mkdir(runsDir, { recursive: true });
+    const file = path.join(runsDir, `${record.run_id}.json`);
+    await writeFile(file, JSON.stringify(record, null, 2), "utf8");
+    await appendFile(path.join(config.logs_dir, "app.log"), `${record.finished_at} ${record.status} ${record.skill_id} ${record.run_id}\n`, "utf8");
+    await appendEventLog(config, {
+        ts: record.finished_at,
+        level: record.status === "ok" ? "info" : record.status === "error" ? "error" : "warn",
+        source: "skill",
+        event: "run",
+        message: record.error || extractSummary(record.result),
+        details: {
+            run_id: record.run_id,
+            skill_id: record.skill_id,
+            status: record.status,
+            attempts: record.attempts,
+            saved: Array.isArray(record.saved_outputs) ? record.saved_outputs.length : 0,
+        },
+    });
+    return file;
+}
+export async function appendEventLog(config, entry) {
+    await mkdir(config.logs_dir, { recursive: true });
+    const ts = entry.ts || new Date().toISOString();
+    const line = JSON.stringify({ ...entry, ts });
+    await appendFile(path.join(config.logs_dir, "events.jsonl"), `${line}\n`, "utf8");
+}
+let conversationPruneAt = 0;
+export async function appendConversationLog(config, entry) {
+    const dir = path.join(config.logs_dir, "conversations");
+    await mkdir(dir, { recursive: true });
+    const ts = entry.ts || new Date().toISOString();
+    const day = ts.slice(0, 10);
+    const file = path.join(dir, `${day}.jsonl`);
+    await appendFile(file, `${JSON.stringify({ ...entry, ts })}\n`, "utf8");
+    await appendDailyConversationMemory(config, { ...entry, ts });
+    await maybePruneOldLogs(config);
+}
+export function dailyConversationMemoryFile(config, date = new Date()) {
+    const yyyy = String(date.getFullYear());
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    return path.join(config.memory_dir, "daily", yyyy, MM, `${yyyy}-${MM}-${dd}.md`);
+}
+async function appendDailyConversationMemory(config, entry) {
+    const date = new Date(entry.ts);
+    const file = Number.isNaN(date.getTime())
+        ? dailyConversationMemoryFile(config)
+        : dailyConversationMemoryFile(config, date);
+    const existing = await readTextIfExists(file);
+    const titleDate = path.basename(file, ".md");
+    const prefix = existing ? "" : `# ${titleDate}\n\n`;
+    await mkdir(path.dirname(file), { recursive: true });
+    await appendFile(file, `${prefix}${formatConversationMarkdownEntry(entry)}\n`, "utf8");
+}
+function formatConversationMarkdownEntry(entry) {
+    const label = [entry.source, entry.role].filter(Boolean).join(" ");
+    const content = entry.content.trim() || "(empty)";
+    return [`## ${entry.ts} ${label}`, "", content].join("\n");
+}
+async function readTextIfExists(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+async function maybePruneOldLogs(config) {
+    const now = Date.now();
+    if (now - conversationPruneAt < 60 * 60 * 1000) {
+        return;
+    }
+    conversationPruneAt = now;
+    try {
+        await pruneOldLogs(config);
+    }
+    catch {
+        // best-effort
+    }
+}
+export async function pruneOldLogs(config) {
+    const days = config.log_retention_days;
+    if (days && days > 0) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        await pruneFilesByMtime(path.join(config.logs_dir, "conversations"), cutoff);
+        await pruneFilesByMtime(path.join(config.logs_dir, "runs"), cutoff);
+    }
+    const eventDays = config.event_log_retention_days;
+    if (eventDays && eventDays > 0) {
+        const cutoff = Date.now() - eventDays * 24 * 60 * 60 * 1000;
+        await pruneLinesByLeadingTimestamp(path.join(config.logs_dir, "events.jsonl"), cutoff, (line) => {
+            try {
+                const parsed = JSON.parse(line);
+                return parsed.ts ? Date.parse(parsed.ts) : NaN;
+            }
+            catch {
+                return NaN;
+            }
+        });
+        await pruneLinesByLeadingTimestamp(path.join(config.logs_dir, "app.log"), cutoff, (line) => {
+            const head = line.slice(0, 32).split(/\s/, 1)[0];
+            return head ? Date.parse(head) : NaN;
+        });
+    }
+}
+async function pruneLinesByLeadingTimestamp(file, cutoff, extractTime) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return;
+    }
+    const lines = raw.split(/\r?\n/);
+    const kept = [];
+    let removed = 0;
+    for (const line of lines) {
+        if (line.length === 0) {
+            continue;
+        }
+        const ts = extractTime(line);
+        if (Number.isFinite(ts) && ts < cutoff) {
+            removed += 1;
+            continue;
+        }
+        kept.push(line);
+    }
+    if (removed === 0) {
+        return;
+    }
+    const next = kept.length > 0 ? `${kept.join("\n")}\n` : "";
+    await writeFile(file, next, "utf8");
+}
+async function pruneFilesByMtime(dir, cutoff) {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const file = path.join(dir, name);
+        try {
+            const info = await stat(file);
+            if (info.isFile() && info.mtimeMs < cutoff) {
+                await rm(file, { force: true });
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+export async function readEventLog(config, options = {}) {
+    const file = path.join(config.logs_dir, "events.jsonl");
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const entries = [];
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed.level || !parsed.source || !parsed.event) {
+            continue;
+        }
+        if (options.level && parsed.level !== options.level) {
+            continue;
+        }
+        if (options.source && parsed.source !== options.source) {
+            continue;
+        }
+        entries.push({ ...parsed, ts: parsed.ts || "", raw: line });
+    }
+    if (options.tail && options.tail > 0) {
+        return entries.slice(-options.tail);
+    }
+    return entries;
+}
+function extractSummary(result) {
+    if (!result || typeof result !== "object") {
+        return undefined;
+    }
+    const summary = result.summary;
+    if (typeof summary === "string" && summary.length > 0) {
+        return summary;
+    }
+    return undefined;
+}
+export async function listRunLogs(config, skillId) {
+    const runsDir = path.join(config.logs_dir, "runs");
+    let files;
+    try {
+        files = await readdir(runsDir);
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const file of files.filter((item) => item.endsWith(".json")).sort().reverse()) {
+        try {
+            const record = JSON.parse(await readFile(path.join(runsDir, file), "utf8"));
+            if (!skillId || record.skill_id === skillId) {
+                records.push(record);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return records;
+}
+export async function readRunLog(config, runId) {
+    const file = path.join(config.logs_dir, "runs", `${runId}.json`);
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        throw new Error(l(`Run log not found: ${runId}`, `実行ログが見つかりません: ${runId}`));
+    }
+}

package/dist/core/memory.d.ts

@@ -0,0 +1,10 @@
+import type { AppConfig } from "./config.js";
+import type { SkillManifest } from "./skill-registry.js";
+export interface SkillMemoryAccess {
+    namespace: string;
+    canRead: boolean;
+    canWrite: boolean;
+}
+export declare function skillMemoryAccess(manifest: SkillManifest): SkillMemoryAccess;
+export declare function loadSkillMemory(config: AppConfig, manifest: SkillManifest): Promise<Record<string, unknown>>;
+export declare function saveSkillMemoryUpdates(config: AppConfig, manifest: SkillManifest, updates: Record<string, unknown>): Promise<string | undefined>;