om-memory-system 4.29.1 → 4.31.1

package/dist/core/skill-operation-reply.js

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/** Helpers that `skill-operations.ts` and `skill-agent-modes.ts` share. */
+export function reply(mode, success, code, text, data) {
+    return data ? { success, mode, code, text, data } : { success, mode, code, text };
+}
+export function expandHome(path) {
+    return path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
+}
+/**
+ * The `SKILL.md` path for a skill name or path, or the reply that explains
+ * why there is none: no skill of that name, or more than one.
+ */
+export function resolveSkillPath(mode, skill, index) {
+    if (/[/\\]/.test(skill))
+        return { path: resolve(expandHome(skill)) };
+    const matches = index.entries.filter((e) => e.name === skill);
+    if (matches.length === 0) {
+        return reply(mode, false, "not-found", `No watched skill is named ${skill}. Run list to see the watched skills.`);
+    }
+    if (matches.length > 1) {
+        const paths = matches.map((e) => `- ${e.path}`).join("\n");
+        return reply(mode, false, "ambiguous", `More than one skill is named ${skill}. Give skill as one of these paths:\n${paths}`, { paths: matches.map((e) => e.path) });
+    }
+    return { path: matches[0].path };
+}
+/** `folder` when it is one of the watched folders, or the reply that lists them. */
+export function watchedTarget(mode, folders, folder) {
+    const watched = folders.map((f) => resolve(expandHome(f)));
+    const target = folder ? resolve(expandHome(folder)) : null;
+    if (target && watched.includes(target))
+        return { folder: target };
+    const known = watched.map((f) => `- ${f}`).join("\n") || "(none)";
+    return reply(mode, false, "not-watched", `Give folder as one of the watched folders:\n${known}`);
+}

package/dist/core/skill-operations.d.ts

@@ -0,0 +1,58 @@
+import { type SkillIdea, type SkillModel } from "../services/skill-learning/drafting.js";
+import type { SkillStore } from "../services/skill-learning/store.js";
+/**
+ * The `skills` tool and the `om-memory-system skills` command share these
+ * mode handlers and replies (design §8). The caller builds the deps from the
+ * config; `services/skill-learning/operations-deps.ts` does that.
+ */
+export declare const SKILL_OPERATION_MODES: readonly ["list", "ideas", "draft", "evidence", "propose", "proposals", "show", "apply", "reject", "undo", "help"];
+export type SkillOperationMode = (typeof SKILL_OPERATION_MODES)[number];
+export interface SkillOperationArgs {
+    /** Draft: a skill name, or the full path of its `SKILL.md`. */
+    skill?: string;
+    /** Draft a new skill: an idea from `ideas`. Needs `folder`. */
+    idea?: Partial<SkillIdea>;
+    /** Draft a new skill: the watched folder to put it in. */
+    folder?: string;
+    /** Show, apply, reject: the proposal id. */
+    id?: string;
+    /** Proposals: only proposals in this state. */
+    state?: string;
+    /** List: `uses` (default) or `attention`. */
+    order?: string;
+    /** Evidence: how many recorded turns, 1 to 20 (default 10). */
+    limit?: number | string;
+    /** Propose: the full new `SKILL.md`. */
+    content?: string;
+    /** Propose: what changed and why. */
+    summary?: string;
+    /** Propose: the turn ids that show the need, as numbers, `T12` labels or `12,14`. */
+    evidence?: Array<number | string> | string;
+}
+export interface SkillOperationsDeps {
+    /** `skillLearning` in the config. */
+    enabled: boolean;
+    store: SkillStore;
+    /** The watched skill folders. */
+    folders: readonly string[];
+    model: SkillModel;
+    /** Recorded on apply: `agent` for the host tools, `person` for the terminal. */
+    appliedBy: "person" | "agent";
+    now?: () => number;
+}
+export interface SkillOperationResult {
+    success: boolean;
+    mode: string;
+    /** A fixed outcome code, such as `ok`, `recording-off` or `not-found`. */
+    code: string;
+    /** The plain-English reply for an agent or a terminal. */
+    text: string;
+    /** Structured data for JSON output. */
+    data?: Record<string, unknown>;
+}
+export declare const RECORDING_OFF_TEXT = "Skill learning is off, so OMMS records no turns for skills. Turn it on in Settings \u2192 Skill learning, or set `skillLearning: true` in the global config.";
+/**
+ * Runs one `skills` mode. Expected outcomes return a result with a code;
+ * an unexpected error returns `success: false` with code `error`.
+ */
+export declare function runSkillOperation(mode: string | undefined, args: SkillOperationArgs, deps: SkillOperationsDeps): Promise<SkillOperationResult>;

package/dist/core/skill-operations.js

@@ -0,0 +1,296 @@
+import { applyProposal } from "../services/skill-learning/apply.js";
+import { draftImprovement, draftNewSkill, findSkillIdeas, } from "../services/skill-learning/drafting.js";
+import { getProposal, listProposals, updateProposalState, } from "../services/skill-learning/proposal-store.js";
+import { SKILL_ORDERS, rankSkills, } from "../services/skill-learning/ranking.js";
+import { getSkillIndex } from "../services/skill-learning/skill-index.js";
+import { evidence, propose, undo } from "./skill-agent-modes.js";
+import { reply, resolveSkillPath, watchedTarget } from "./skill-operation-reply.js";
+/**
+ * The `skills` tool and the `om-memory-system skills` command share these
+ * mode handlers and replies (design §8). The caller builds the deps from the
+ * config; `services/skill-learning/operations-deps.ts` does that.
+ */
+export const SKILL_OPERATION_MODES = [
+    "list",
+    "ideas",
+    "draft",
+    "evidence",
+    "propose",
+    "proposals",
+    "show",
+    "apply",
+    "reject",
+    "undo",
+    "help",
+];
+const PROPOSAL_STATES = [
+    "pending",
+    "applied",
+    "stale",
+    "rejected",
+    "undone",
+];
+export const RECORDING_OFF_TEXT = "Skill learning is off, so OMMS records no turns for skills. Turn it on in Settings → Skill learning, or set `skillLearning: true` in the global config.";
+const HELP = [
+    {
+        mode: "list",
+        args: "order?",
+        description: "Skills ranked by use in the last 30 days, or by attention with order attention",
+    },
+    { mode: "ideas", args: "", description: "Up to three new skill ideas from recorded turns" },
+    {
+        mode: "draft",
+        args: "skill | idea + folder",
+        description: "Draft an improvement for a skill, or a new skill from an idea",
+    },
+    {
+        mode: "evidence",
+        args: "skill, limit?",
+        description: "A skill's SKILL.md, its numbers and its recorded turns, failed ones first",
+    },
+    {
+        mode: "propose",
+        args: "skill | idea + folder, content, summary, evidence?",
+        description: "Save your own fixed SKILL.md as a pending proposal; no external API call",
+    },
+    { mode: "proposals", args: "state?", description: "List proposals, newest first" },
+    { mode: "show", args: "id", description: "One proposal with its summary, evidence and diff" },
+    { mode: "apply", args: "id", description: "Write a pending proposal to its SKILL.md" },
+    { mode: "reject", args: "id", description: "Reject a pending proposal" },
+    { mode: "undo", args: "id", description: "Restore the file an applied proposal changed" },
+    { mode: "help", args: "", description: "This list" },
+];
+function day(ms) {
+    return ms === null ? "never" : new Date(ms).toISOString().slice(0, 10);
+}
+function plural(count, word) {
+    return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function rankingLine(skill) {
+    const parts = [
+        plural(skill.uses, "use"),
+        plural(skill.failedTurns, "failed turn"),
+        `last used ${day(skill.lastUsedAt)}`,
+        `attention ${skill.attention.toFixed(2)}`,
+        skill.mode,
+    ];
+    if (skill.suggested)
+        parts.push("Suggested");
+    if (skill.notInWatchedFolder)
+        parts.push("Not in a watched folder");
+    const line = `- ${skill.name}: ${parts.join(", ")}`;
+    return skill.path ? `${line}\n  ${skill.path}` : line;
+}
+function proposalLine(p) {
+    const summary = p.summary ? `: ${p.summary}` : "";
+    return `- ${p.id} ${p.state} ${p.kind} ${p.skillName} (${day(p.createdAt)})${summary}`;
+}
+function stateNote(p) {
+    if (p.state === "pending" && p.draftedBy === "agent")
+        return "Written by the agent";
+    if (p.state === "stale")
+        return "Stale: the file changed since this draft";
+    if (p.state === "applied" && p.appliedBy === "automatic")
+        return "Applied automatically";
+    if (p.state === "applied" && p.appliedBy)
+        return `Applied by ${p.appliedBy}`;
+    return null;
+}
+function proposalText(p) {
+    const lines = [
+        `Proposal ${p.id}`,
+        `Skill: ${p.skillName} (${p.kind === "new" ? "new skill" : "improvement"})`,
+        `File: ${p.skillPath ?? "none"}`,
+        `State: ${p.state}`,
+    ];
+    const note = stateNote(p);
+    if (note)
+        lines.push(note);
+    lines.push(`Summary: ${p.summary || "none"}`);
+    const evidence = p.evidenceTurnIds.map((id) => `T${id}`).join(", ");
+    lines.push(`Evidence turns: ${evidence || "none"}`);
+    lines.push("", "Diff:", p.diff || "(no diff)");
+    return lines.join("\n");
+}
+function draftReply(mode, result) {
+    if (!result.ok)
+        return reply(mode, false, result.code, result.message);
+    if (result.code === "no-change")
+        return reply(mode, true, "no-change", result.message);
+    const p = result.proposal;
+    return reply(mode, true, "proposed", `Saved pending proposal ${p.id} for ${p.skillName}. Review it with show, then apply or reject it.`, { proposal: p });
+}
+async function list(args, deps, now) {
+    const order = (args.order ?? "uses");
+    if (!SKILL_ORDERS.includes(order)) {
+        return reply("list", false, "invalid-args", `order must be one of: ${SKILL_ORDERS.join(", ")}.`);
+    }
+    const skills = await rankSkills(deps.store, getSkillIndex(deps.folders, now), now, order);
+    if (skills.length === 0) {
+        return reply("list", true, "ok", "No skills found in the watched folders.", {
+            skills,
+            folders: deps.folders,
+        });
+    }
+    const heading = order === "attention" ? "Skills by attention" : "Skills by use";
+    const text = [`${heading} in the last 30 days:`, ...skills.map(rankingLine)].join("\n");
+    return reply("list", true, "ok", text, { skills });
+}
+async function ideas(deps, now) {
+    const result = await findSkillIdeas(draftDeps(deps, now));
+    if (!result.ok)
+        return reply("ideas", false, result.code, result.message);
+    if (result.ideas.length === 0) {
+        return reply("ideas", true, "ok", "No new skill ideas in the recorded turns.", { ideas: [] });
+    }
+    const lines = result.ideas.map((idea, i) => {
+        const evidence = idea.evidenceTurnIds.map((id) => `T${id}`).join(", ") || "none";
+        return `${i + 1}. ${idea.name}: ${idea.description}\n   Why: ${idea.reason}\n   Evidence turns: ${evidence}`;
+    });
+    lines.push("To draft one, call draft with the idea and a watched folder.");
+    return reply("ideas", true, "ok", lines.join("\n"), { ideas: result.ideas });
+}
+function draftDeps(deps, now) {
+    return {
+        store: deps.store,
+        index: getSkillIndex(deps.folders, now),
+        model: deps.model,
+        now: () => now,
+    };
+}
+async function draftNew(args, deps, now) {
+    const { idea, folder } = args;
+    if (!idea?.name || !idea.description) {
+        return reply("draft", false, "invalid-args", "An idea needs a name and a description.");
+    }
+    const target = watchedTarget("draft", deps.folders, folder);
+    if (isReply(target))
+        return target;
+    await deps.store.init();
+    const full = {
+        name: idea.name,
+        description: idea.description,
+        reason: idea.reason ?? "",
+        evidenceTurnIds: idea.evidenceTurnIds ?? [],
+    };
+    return draftReply("draft", await draftNewSkill(full, target.folder, draftDeps(deps, now)));
+}
+async function draft(args, deps, now) {
+    if (args.idea)
+        return draftNew(args, deps, now);
+    const skill = args.skill?.trim();
+    if (!skill)
+        return reply("draft", false, "invalid-args", "Give skill, or idea and folder.");
+    const index = getSkillIndex(deps.folders, now);
+    const found = resolveSkillPath("draft", skill, index);
+    if (isReply(found))
+        return found;
+    await deps.store.init();
+    return draftReply("draft", await draftImprovement(found.path, { ...draftDeps(deps, now), index }));
+}
+async function proposals(args, deps) {
+    const state = args.state;
+    if (state && !PROPOSAL_STATES.includes(state)) {
+        return reply("proposals", false, "invalid-args", `state must be one of: ${PROPOSAL_STATES.join(", ")}.`);
+    }
+    const found = await listProposals(deps.store, state ? { state } : {});
+    const text = found.length === 0
+        ? `No ${state ? `${state} ` : ""}proposals.`
+        : ["Proposals, newest first:", ...found.map(proposalLine)].join("\n");
+    return reply("proposals", true, "ok", text, { proposals: found });
+}
+/** The proposal for `args.id`, or the reply that explains why there is none. */
+async function findProposal(mode, args, deps) {
+    if (!args.id)
+        return reply(mode, false, "invalid-args", "Give the proposal id.");
+    const proposal = await getProposal(deps.store, args.id);
+    return proposal ?? reply(mode, false, "not-found", `No proposal ${args.id}.`);
+}
+function isReply(value) {
+    return "code" in value;
+}
+async function show(args, deps) {
+    const found = await findProposal("show", args, deps);
+    if (isReply(found))
+        return found;
+    return reply("show", true, "ok", proposalText(found), { proposal: found });
+}
+async function apply(args, deps, now) {
+    const found = await findProposal("apply", args, deps);
+    if (isReply(found))
+        return found;
+    await deps.store.init();
+    const result = await applyProposal(found.id, deps.appliedBy, {
+        store: deps.store,
+        folders: deps.folders,
+        now: () => now,
+    });
+    if (!result.ok)
+        return reply("apply", false, result.code, result.message);
+    return reply("apply", true, "applied", `Applied proposal ${found.id} to ${result.path}.`, {
+        proposal: result.proposal,
+        path: result.path,
+    });
+}
+async function reject(args, deps, now) {
+    const found = await findProposal("reject", args, deps);
+    if (isReply(found))
+        return found;
+    if (found.state !== "pending") {
+        return reply("reject", false, "not-pending", `Proposal ${found.id} is ${found.state}. Only a pending proposal can be rejected.`);
+    }
+    await deps.store.init();
+    await updateProposalState(deps.store, found.id, "rejected", now);
+    return reply("reject", true, "rejected", `Rejected proposal ${found.id}.`, {
+        proposal: { ...found, state: "rejected", updatedAt: now },
+    });
+}
+function help() {
+    const lines = HELP.map((h) => `- ${h.mode}${h.args ? ` (${h.args})` : ""}: ${h.description}`);
+    return reply("help", true, "ok", ["Skills tool modes:", ...lines].join("\n"), { modes: HELP });
+}
+/** Modes that read recorded turns. They need skill learning on. */
+const RECORDING_MODES = new Set(["list", "ideas", "draft", "evidence"]);
+/**
+ * Runs one `skills` mode. Expected outcomes return a result with a code;
+ * an unexpected error returns `success: false` with code `error`.
+ */
+export async function runSkillOperation(mode, args, deps) {
+    const name = mode || "help";
+    if (!SKILL_OPERATION_MODES.includes(name)) {
+        return reply(name, false, "invalid-args", `Unknown mode ${name}. Use one of: ${SKILL_OPERATION_MODES.join(", ")}.`);
+    }
+    if (RECORDING_MODES.has(name) && !deps.enabled) {
+        return reply(name, false, "recording-off", RECORDING_OFF_TEXT);
+    }
+    const now = (deps.now ?? Date.now)();
+    try {
+        switch (name) {
+            case "list":
+                return await list(args, deps, now);
+            case "ideas":
+                return await ideas(deps, now);
+            case "draft":
+                return await draft(args, deps, now);
+            case "evidence":
+                return await evidence(args, deps, now);
+            case "propose":
+                return await propose(args, deps, now);
+            case "undo":
+                return await undo(args, deps, now);
+            case "proposals":
+                return await proposals(args, deps);
+            case "show":
+                return await show(args, deps);
+            case "apply":
+                return await apply(args, deps, now);
+            case "reject":
+                return await reject(args, deps, now);
+            case "help":
+                return help();
+        }
+    }
+    catch (error) {
+        return reply(name, false, "error", error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/core/skills-tool.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The `skills` tool that Pi and OpenCode register beside `memory` (design §8).
+ * The operations, their store and the model load with `import()` on the first
+ * call, so the plugin bundles stay light. A call records `agent` on apply.
+ */
+/** Same list as `SKILL_OPERATION_MODES`; a test keeps the two equal. */
+export declare const SKILLS_TOOL_MODES: readonly ["list", "ideas", "draft", "evidence", "propose", "proposals", "show", "apply", "reject", "undo", "help"];
+export declare const SKILLS_TOOL_DESCRIPTION: string;
+/** JSON Schema for the tool input; the V2 adapter passes it as is. */
+export declare const SKILLS_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["list", "ideas", "draft", "evidence", "propose", "proposals", "show", "apply", "reject", "undo", "help"];
+        };
+        readonly skill: {
+            readonly type: "string";
+        };
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly state: {
+            readonly type: "string";
+        };
+        readonly order: {
+            readonly type: "string";
+            readonly enum: readonly ["uses", "attention"];
+        };
+        readonly folder: {
+            readonly type: "string";
+        };
+        readonly idea: {
+            readonly type: "object";
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+                readonly reason: {
+                    readonly type: "string";
+                };
+                readonly evidenceTurnIds: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                    };
+                };
+            };
+        };
+        readonly limit: {
+            readonly type: "number";
+        };
+        readonly content: {
+            readonly type: "string";
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly evidence: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
+export interface SkillsToolArgs {
+    mode?: string;
+    skill?: string;
+    id?: string;
+    state?: string;
+    order?: string;
+    folder?: string;
+    idea?: {
+        name?: string;
+        description?: string;
+        reason?: string;
+        evidenceTurnIds?: number[];
+    };
+    limit?: number;
+    content?: string;
+    summary?: string;
+    evidence?: number[];
+}
+/** Run one `skills` tool call for the project in `directory`; returns the result as JSON. */
+export declare function runSkillsTool(args: SkillsToolArgs, directory: string): Promise<string>;

package/dist/core/skills-tool.js

@@ -0,0 +1,64 @@
+/**
+ * The `skills` tool that Pi and OpenCode register beside `memory` (design §8).
+ * The operations, their store and the model load with `import()` on the first
+ * call, so the plugin bundles stay light. A call records `agent` on apply.
+ */
+/** Same list as `SKILL_OPERATION_MODES`; a test keeps the two equal. */
+export const SKILLS_TOOL_MODES = [
+    "list",
+    "ideas",
+    "draft",
+    "evidence",
+    "propose",
+    "proposals",
+    "show",
+    "apply",
+    "reject",
+    "undo",
+    "help",
+];
+export const SKILLS_TOOL_DESCRIPTION = [
+    "Lists this project's skills ranked by use, drafts improvements as reviewable proposals, and applies a proposal only when the user asks.",
+    'mode "list" (order "uses" or "attention"): skills ranked by use in the last 30 days, or by attention. "ideas": up to three new skill ideas from recorded turns.',
+    '"draft" (skill, or an idea from "ideas" {name, description, reason, evidenceTurnIds} with folder): the external API drafts a pending proposal; it changes no file.',
+    'To fix a skill yourself: call "evidence" (skill, limit) for its SKILL.md and recorded turns, write the fixed SKILL.md, then call "propose" (skill, or idea with folder; content, summary, evidence turn ids). Show the user the diff.',
+    "This path makes no external API call, but the recorded turn text enters this session.",
+    '"proposals" (state), "show" (id): review proposals and their diffs.',
+    '"apply" (id): write a pending proposal to its SKILL.md, only when the user asks. "reject" (id), "undo" (id), "help".',
+].join(" ");
+/** JSON Schema for the tool input; the V2 adapter passes it as is. */
+export const SKILLS_TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        mode: { type: "string", enum: [...SKILLS_TOOL_MODES] },
+        skill: { type: "string" },
+        id: { type: "string" },
+        state: { type: "string" },
+        order: { type: "string", enum: ["uses", "attention"] },
+        folder: { type: "string" },
+        idea: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                description: { type: "string" },
+                reason: { type: "string" },
+                evidenceTurnIds: { type: "array", items: { type: "number" } },
+            },
+        },
+        limit: { type: "number" },
+        content: { type: "string" },
+        summary: { type: "string" },
+        evidence: { type: "array", items: { type: "number" } },
+    },
+    additionalProperties: false,
+};
+/** Run one `skills` tool call for the project in `directory`; returns the result as JSON. */
+export async function runSkillsTool(args, directory) {
+    const [{ runSkillOperation }, { skillOperationsDeps }] = await Promise.all([
+        import("./skill-operations.js"),
+        import("../services/skill-learning/operations-deps.js"),
+    ]);
+    const { mode, ...rest } = args;
+    const result = await runSkillOperation(mode, rest, skillOperationsDeps(directory, "agent"));
+    return JSON.stringify(result);
+}

package/dist/core/tool-input.d.ts

@@ -0,0 +1,7 @@
+/** Cut a formatted tool input to 100 characters plus "...", as memory capture expects. */
+export declare function boundToolInput(text: string): string;
+/**
+ * The full path field of a read-type call (`read`, `Read`, `view`), so skill
+ * detection sees a `SKILL.md` path that the bounded input cuts off.
+ */
+export declare function readToolPath(name: string, args: unknown): string | undefined;

package/dist/core/tool-input.js

@@ -0,0 +1,21 @@
+const MAX_TOOL_INPUT_LENGTH = 100;
+const READ_TOOLS = new Set(["read", "Read", "view"]);
+const READ_PATH_KEYS = ["file_path", "filePath", "path"];
+/** Cut a formatted tool input to 100 characters plus "...", as memory capture expects. */
+export function boundToolInput(text) {
+    return text.length > MAX_TOOL_INPUT_LENGTH
+        ? text.substring(0, MAX_TOOL_INPUT_LENGTH) + "..."
+        : text;
+}
+/**
+ * The full path field of a read-type call (`read`, `Read`, `view`), so skill
+ * detection sees a `SKILL.md` path that the bounded input cuts off.
+ */
+export function readToolPath(name, args) {
+    if (!READ_TOOLS.has(name) || !args || typeof args !== "object" || Array.isArray(args)) {
+        return undefined;
+    }
+    const record = args;
+    const key = READ_PATH_KEYS.find((candidate) => typeof record[candidate] === "string");
+    return key ? record[key] : undefined;
+}

package/dist/core/tool-outcome.d.ts

@@ -0,0 +1,13 @@
+import type { CaptureToolCall } from "./host.js";
+export declare const MAX_TOOL_ERROR_LENGTH = 2000;
+type ToolOutcomeFields = Pick<CaptureToolCall, "outcome" | "error">;
+/** Error text as the host reported it, cut to at most 2,000 characters. */
+export declare function boundToolError(text: string): string;
+/** The outcome of a failed call, with its error text when the host gave one. */
+export declare function errorOutcome(text: unknown): ToolOutcomeFields;
+/**
+ * The outcome of an OpenCode tool part from its `state`. The live reader and
+ * the history import read the same part shape.
+ */
+export declare function opencodeToolOutcome(state: unknown): ToolOutcomeFields;
+export {};

package/dist/core/tool-outcome.js

@@ -0,0 +1,22 @@
+export const MAX_TOOL_ERROR_LENGTH = 2000;
+/** Error text as the host reported it, cut to at most 2,000 characters. */
+export function boundToolError(text) {
+    return text.length > MAX_TOOL_ERROR_LENGTH ? text.slice(0, MAX_TOOL_ERROR_LENGTH) : text;
+}
+/** The outcome of a failed call, with its error text when the host gave one. */
+export function errorOutcome(text) {
+    const error = typeof text === "string" ? text.trim() : "";
+    return error ? { outcome: "error", error: boundToolError(error) } : { outcome: "error" };
+}
+/**
+ * The outcome of an OpenCode tool part from its `state`. The live reader and
+ * the history import read the same part shape.
+ */
+export function opencodeToolOutcome(state) {
+    const { status, error } = (state && typeof state === "object" ? state : {});
+    if (status === "completed")
+        return { outcome: "ok" };
+    if (status === "error")
+        return errorOutcome(error);
+    return { outcome: "unknown" };
+}

package/dist/core/turn-outputs.d.ts

@@ -0,0 +1,30 @@
+import { type CaptureResult, type CaptureWorkUnit } from "./capture.js";
+import type { CaptureSummaryProvider } from "./host.js";
+/** Which outputs a finished turn goes to. */
+export interface TurnOutputs {
+    memories: boolean;
+    skills: boolean;
+}
+export interface TurnOutputDeps {
+    /** The capture model. Needed when `memories` is on. */
+    provider?: CaptureSummaryProvider;
+    /**
+     * The skill-turn output. Injected so `src/core/` imports nothing from
+     * `skill-learning`; the live sites build it from `skillTurnRecorder`.
+     */
+    recordSkillTurn?: (unit: CaptureWorkUnit) => Promise<unknown>;
+}
+/** The memory result, or `not-run` when the memory output was off for this turn. */
+export type TurnMemoryResult = CaptureResult | {
+    status: "not-run";
+};
+/**
+ * The one path for a finished turn (design decision 3). The skill output runs
+ * first and only logs its failures. The memory output is `captureConversation`
+ * unchanged: same result, same errors.
+ */
+export declare function handleFinishedTurn(unit: CaptureWorkUnit, outputs: {
+    memories: true;
+    skills: boolean;
+}, deps: TurnOutputDeps): Promise<CaptureResult>;
+export declare function handleFinishedTurn(unit: CaptureWorkUnit, outputs: TurnOutputs, deps: TurnOutputDeps): Promise<TurnMemoryResult>;

package/dist/core/turn-outputs.js

@@ -0,0 +1,22 @@
+import { log } from "../services/logger.js";
+import { captureConversation } from "./capture.js";
+export async function handleFinishedTurn(unit, outputs, deps) {
+    if (outputs.skills && deps.recordSkillTurn) {
+        try {
+            await deps.recordSkillTurn(unit);
+        }
+        catch (error) {
+            // Codes only: the error may quote turn text.
+            log("Skill turn record failed", {
+                host: unit.host,
+                code: "skill-record-failed",
+                error: error instanceof Error ? error.name : "unknown",
+            }, "warn");
+        }
+    }
+    if (!outputs.memories)
+        return { status: "not-run" };
+    if (!deps.provider)
+        throw new Error("handleFinishedTurn needs a provider for memories");
+    return captureConversation(unit, deps.provider);
+}