@iamem/amem 0.1.2 → 0.1.3

package/dist/cli.js

@@ -3,7 +3,7 @@ import { mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { buildAttestReport, formatAttestHuman } from "./attest.js";
 import { handleApi, logContextUsage } from "./api/routes.js";
-import { closeDb, getRepoByCwd, getRepoByName, renameWorkspace, listClaims, listComponents, listFlows, requireRepo, setReportedOnLatest, setReportedTokensSaved, touchSession, upsertRepo, upsertSetupState, wipeAllRepos, wipeRepo, openDb, } from "./db.js";
+import { closeDb, getRepoByCwd, getRepoByName, renameWorkspace, listClaims, listComponents, listFlows, listRepos, listTasks, listTasksAll, insertTask, updateTask, completeTask, deleteTask, findTaskAnyRepo, normalizeTaskStatus, requireRepo, setReportedOnLatest, setReportedTokensSaved, touchSession, upsertRepo, upsertSetupState, wipeAllRepos, wipeRepo, openDb, } from "./db.js";
 import { handleHookPayload } from "./hook.js";
 import { installClaude, claudeInstallHealth } from "./install/claude.js";
 import { installCursor, cursorInstallHealth } from "./install/cursor.js";
@@ -28,6 +28,8 @@ import { embedIndexIssues, embedStatus, reindexAllEmbeds, setEmbedBackend, } fro
 import { acceptSafeCleanups, decayStaleClaims, hygieneReport, mergeDuplicate, runScheduledHygiene } from "./hygiene.js";
 import { hygieneSchedulePath, installHygieneSchedule, isHygieneScheduleInstalled, uninstallHygieneSchedule, writeHygieneHelperScript, } from "./hygiene-schedule.js";
 import { syncPinnedRules } from "./rules-sync.js";
+import { listSkillDrafts } from "./db.js";
+import { deleteSkill, findSkillOnDisk, importSkillFromPath, isValidSkillName, listIndexedSkills, readSkillBody, renderSkillMarkdown, skillsDir, slugifySkillName, syncSkillIndex, writeSkill, } from "./skills.js";
 import { buildSbom, writeItPack } from "./it-pack.js";
 function usage() {
     console.log(`amem — local personal agent memory
@@ -43,6 +45,11 @@ Usage:
   amem context "<query>" [--workspace <name>] [--platform cursor|claude|luna]
   amem remember "<text>" [--workspace <name>] [--kind session] [--anchor <path>]
   amem recipe [--json]
+  amem task [list] [--status <backlog|next|doing|blocked|done>] [--include-done] [--all] [--json]
+  amem task add <title> [--body <notes>] [--status <status>] [--anchor <file>]
+  amem task update <id> [--title <title>] [--body <notes>] [--status <status>]
+  amem task complete <id>
+  amem task delete <id>
   amem propose validate <file.json>
   amem propose diff <file.json>
   amem propose apply <file.json>
@@ -60,6 +67,8 @@ Usage:
   amem hygiene schedule [--hour <0-23>]
   amem hygiene unschedule
   amem rules sync
+  amem skills list|show <name>|new <name> [--desc <text>]|rm <name>|sync|import <path>
+  amem skills drafts|approve <id>|dismiss <id>
   amem it-pack [--out <dir>]
   amem doctor [--attest] [--sbom] [--json]
   amem session touch --platform cursor|claude [--session-id <id>]
@@ -691,6 +700,235 @@ async function main() {
                 console.log("Keep this file out of shared git if it contains personal notes.");
                 break;
             }
+            case "task":
+            case "tasks": {
+                const sub = positional[1] || "list";
+                if (sub === "list") {
+                    const isAll = Boolean(flags.get("all"));
+                    const statusRaw = flagString(flags, "status");
+                    const status = statusRaw ? (normalizeTaskStatus(statusRaw) ?? undefined) : undefined;
+                    const includeDone = Boolean(flags.get("include-done") || flags.get("all") || status === "done");
+                    let tasks;
+                    if (isAll) {
+                        tasks = listTasksAll({ status, includeDone });
+                    }
+                    else {
+                        let repo;
+                        try {
+                            repo = resolveBinding(flags);
+                        }
+                        catch {
+                            repo = getRepoByCwd() || ensurePersonalWorkspace();
+                        }
+                        tasks = listTasks(repo.id, { status, includeDone });
+                    }
+                    if (flags.get("json")) {
+                        console.log(JSON.stringify({ tasks }, null, 2));
+                        break;
+                    }
+                    if (tasks.length === 0) {
+                        console.log("No tasks found.");
+                        break;
+                    }
+                    const repoMap = new Map(listRepos().map((r) => [r.id, r.repo_name]));
+                    for (const t of tasks) {
+                        const repoLabel = isAll ? ` [${repoMap.get(t.repo_id) || "repo"}]` : "";
+                        const body = t.body ? ` — ${t.body}` : "";
+                        console.log(`[${t.status}] ${t.title}${body}${repoLabel} (${t.id})`);
+                    }
+                    break;
+                }
+                if (sub === "add") {
+                    const title = positional.slice(2).join(" ") || flagString(flags, "title");
+                    if (!title || !title.trim()) {
+                        throw new Error("Usage: amem task add <title> [--body <notes>] [--status <status>] [--anchor <file>]");
+                    }
+                    let repo;
+                    try {
+                        repo = resolveBinding(flags);
+                    }
+                    catch {
+                        repo = getRepoByCwd() || ensurePersonalWorkspace();
+                    }
+                    const body = flagString(flags, "body") || "";
+                    const status = flagString(flags, "status") || "backlog";
+                    const anchor = flagString(flags, "anchor");
+                    const anchors = anchor ? [anchor] : undefined;
+                    const task = insertTask({
+                        repoId: repo.id,
+                        title: title.trim(),
+                        body,
+                        status,
+                        anchors,
+                        source: "cli",
+                    });
+                    console.log(`Created task ${task.id} [${task.status}]: ${task.title}`);
+                    break;
+                }
+                if (sub === "update") {
+                    const id = positional[2];
+                    if (!id)
+                        throw new Error("Usage: amem task update <id> [--title <title>] [--body <notes>] [--status <status>]");
+                    const found = findTaskAnyRepo(id);
+                    if (!found)
+                        throw new Error(`Task not found: ${id}`);
+                    const title = flagString(flags, "title");
+                    const body = flagString(flags, "body");
+                    const status = flagString(flags, "status");
+                    const anchor = flagString(flags, "anchor");
+                    const anchors = anchor ? [anchor] : undefined;
+                    const updated = updateTask(found.repo_id, id, {
+                        title,
+                        body,
+                        status,
+                        anchors,
+                    });
+                    if (!updated)
+                        throw new Error(`Task not found: ${id}`);
+                    console.log(`Updated task ${updated.id} [${updated.status}]: ${updated.title}`);
+                    break;
+                }
+                if (sub === "complete" || sub === "done") {
+                    const id = positional[2];
+                    if (!id)
+                        throw new Error("Usage: amem task complete <id>");
+                    const found = findTaskAnyRepo(id);
+                    if (!found)
+                        throw new Error(`Task not found: ${id}`);
+                    const completed = completeTask(found.repo_id, id);
+                    if (!completed)
+                        throw new Error(`Task not found: ${id}`);
+                    console.log(`Completed task ${completed.id}: ${completed.title}`);
+                    break;
+                }
+                if (sub === "rm" || sub === "delete") {
+                    const id = positional[2];
+                    if (!id)
+                        throw new Error("Usage: amem task delete <id>");
+                    const found = findTaskAnyRepo(id);
+                    if (!found)
+                        throw new Error(`Task not found: ${id}`);
+                    const ok = deleteTask(found.repo_id, id);
+                    if (!ok)
+                        throw new Error(`Task not found: ${id}`);
+                    console.log(`Deleted task ${id}`);
+                    break;
+                }
+                throw new Error("Usage: amem task list|add|update|complete|delete");
+            }
+            case "skills": {
+                const sub = positional[1] || "list";
+                if (sub === "list") {
+                    const skills = listIndexedSkills();
+                    if (skills.length === 0) {
+                        console.log(`No skills yet. Create one with: amem skills new <name>`);
+                        console.log(`Skills live in ${skillsDir()}`);
+                        break;
+                    }
+                    for (const s of skills) {
+                        const flag = s.modified ? " (edited)" : "";
+                        const used = s.uses > 0 ? ` · used ${s.uses}×` : "";
+                        console.log(`${s.name}${flag}${used}`);
+                        if (s.description)
+                            console.log(`  ${s.description}`);
+                    }
+                    console.log(`\n${skills.length} skill(s) in ${skillsDir()}`);
+                    break;
+                }
+                if (sub === "show") {
+                    const name = positional[2];
+                    if (!name)
+                        throw new Error("Usage: amem skills show <name>");
+                    const body = readSkillBody(name);
+                    if (body === null)
+                        throw new Error(`Skill not found: ${name}`);
+                    console.log(body);
+                    break;
+                }
+                if (sub === "new") {
+                    const name = positional[2];
+                    if (!name)
+                        throw new Error("Usage: amem skills new <name> [--desc <text>]");
+                    const slug = slugifySkillName(name);
+                    if (!isValidSkillName(slug))
+                        throw new Error(`Invalid skill name: ${name}`);
+                    if (findSkillOnDisk(slug))
+                        throw new Error(`Skill already exists: ${slug}`);
+                    const markdown = renderSkillMarkdown({
+                        name: slug,
+                        description: flagString(flags, "desc") || `Procedure: ${slug.replace(/[-_]+/g, " ")}`,
+                    });
+                    const written = writeSkill(slug, markdown);
+                    syncSkillIndex();
+                    console.log(`Created ${written.path}`);
+                    console.log("Edit it, then agents will see it in their skill index.");
+                    break;
+                }
+                if (sub === "rm") {
+                    const name = positional[2];
+                    if (!name)
+                        throw new Error("Usage: amem skills rm <name>");
+                    if (!deleteSkill(name))
+                        throw new Error(`Skill not found: ${name}`);
+                    syncSkillIndex();
+                    console.log(`Deleted skill ${slugifySkillName(name)}`);
+                    break;
+                }
+                if (sub === "sync") {
+                    const skills = syncSkillIndex();
+                    console.log(`Indexed ${skills.length} skill(s) from ${skillsDir()}`);
+                    const edited = skills.filter((s) => s.modified);
+                    if (edited.length > 0) {
+                        console.log(`${edited.length} locally edited: ${edited.map((s) => s.name).join(", ")}`);
+                    }
+                    break;
+                }
+                if (sub === "drafts") {
+                    const drafts = listSkillDrafts({ status: "pending", limit: 50 });
+                    if (drafts.length === 0) {
+                        console.log("No pending skill drafts.");
+                        break;
+                    }
+                    for (const d of drafts) {
+                        const label = d.kind === "revision" ? `revise ${d.target_skill}` : d.kind === "create" ? "staged" : "suggestion";
+                        console.log(`${d.id}  [${label}]  ${d.title}`);
+                        const why = JSON.parse(d.reasons || "[]");
+                        if (Array.isArray(why) && why.length)
+                            console.log(`  why: ${why.join(", ")}`);
+                    }
+                    console.log(`\n${drafts.length} pending · approve with: amem skills approve <id>`);
+                    break;
+                }
+                if (sub === "approve" || sub === "dismiss") {
+                    const id = positional[2];
+                    if (!id)
+                        throw new Error(`Usage: amem skills ${sub} <draft-id>`);
+                    const path = sub === "approve" ? "/api/skills/drafts/apply" : "/api/skills/drafts/dismiss";
+                    const result = handleApi({
+                        method: "POST",
+                        pathname: path,
+                        searchParams: new URLSearchParams(),
+                        body: { id },
+                        cwd: process.cwd(),
+                    });
+                    if (result.status >= 400) {
+                        throw new Error(String(result.body?.error || "Failed"));
+                    }
+                    console.log(sub === "approve" ? `Applied ${id}` : `Dismissed ${id}`);
+                    break;
+                }
+                if (sub === "import") {
+                    const src = positional[2];
+                    if (!src)
+                        throw new Error("Usage: amem skills import <path-to-skill-dir>");
+                    const result = importSkillFromPath(src, flagString(flags, "name"));
+                    syncSkillIndex();
+                    console.log(`Imported ${result.name} → ${result.path}`);
+                    console.log("Review it before trusting: skills are instructions agents follow.");
+                    break;
+                }
+                throw new Error("Usage: amem skills list|show|new|rm|sync|import");
+            }
             case "it-pack": {
                 const out = resolve(flagString(flags, "out") || join(amemHome(), "it-pack"));
                 const result = writeItPack(out);
@@ -919,7 +1157,8 @@ async function main() {
                     break;
                 }
                 if (sub === "activate") {
-                    throw new Error("Self-activate is disabled. Buy Pro/IT at https://getamem.com then: amem license apply --file <amem-license.json>");
+                    console.log("amem is 100% free and open — all features are already unlocked.");
+                    break;
                 }
                 if (sub === "clear") {
                     clearLicense();

package/dist/context.d.ts

@@ -1,5 +1,6 @@
-import { type ClaimRow, type ComponentRow, type ConversationNoteRow, type FlowRow, type UsageEventRow } from "./db.js";
+import { type AgentTaskRow, type ClaimRow, type ComponentRow, type ConversationNoteRow, type FlowRow, type UsageEventRow, type SkillDraftRow } from "./db.js";
 import { type ClaimFreshness } from "./freshness.js";
+import { type RankedSkill } from "./skills.js";
 export type RankedClaim = ClaimRow & {
     score: number;
     freshness: ClaimFreshness;
@@ -14,12 +15,20 @@ export type ContextPacket = {
     notes: Array<ConversationNoteRow & {
         score: number;
     }>;
+    /** Deferred Kanban tasks (non-done), compact for agents. */
+    tasks: AgentTaskRow[];
+    /** Index-only skill matches; bodies load on demand via `amem_skill_view`. */
+    skills: RankedSkill[];
+    /** At most one pending "worth writing up" nudge from a previous session. */
+    skillDrafts: SkillDraftRow[];
 };
 export type BuildContextOptions = {
     limit?: number;
     rootPath?: string;
     /** Include cross-repo personal prefs (default true). */
     includePersonal?: boolean;
+    /** Include the ranked skill index (default true). */
+    includeSkills?: boolean;
 };
 export declare function buildContext(repoId: string, query: string, limitOrOpts?: number | BuildContextOptions): ContextPacket;
 export type ShowdownClaim = {

package/dist/context.js

@@ -1,10 +1,25 @@
-import { getRepoByName, listClaims, listComponents, listConversationNotes, listEdges, listFlows, openDb, } from "./db.js";
+import { getRepoByName, listClaims, listComponents, listConversationNotes, listEdges, listFlows, listOpenTasksForContext, listTasks, openDb, listSkillDrafts, } from "./db.js";
 import { assessClaimFreshness, freshnessScoreMultiplier, } from "./freshness.js";
 import { kindRankBoost } from "./kinds.js";
 import { ftsBoostFromBm25, keywordScoreClaim, searchClaimsFts, tokenize, } from "./search.js";
 import { embedBoostFromScore, searchClaimsEmbed, searchClaimsEmbedLive } from "./embed.js";
 import { FEATURE_LOCAL_EMBED, hasFeature } from "./license.js";
 import { PERSONAL_SLUG } from "./personal.js";
+import { listIndexedSkills, rankSkills } from "./skills.js";
+import { loadPolicy } from "./policy.js";
+/** Reasons are stored as JSON; a malformed row must not break the whole packet. */
+function safeReasons(raw) {
+    try {
+        const list = JSON.parse(raw);
+        if (Array.isArray(list) && list.length > 0) {
+            return ` (${list.filter((r) => typeof r === "string").join(", ")})`;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return "";
+}
 function scoreNote(note, queryTokens) {
     if (queryTokens.length === 0)
         return 0;
@@ -16,6 +31,17 @@ function scoreNote(note, queryTokens) {
     }
     return score;
 }
+function scoreTask(task, queryTokens) {
+    if (queryTokens.length === 0)
+        return 0;
+    const hay = `${task.title} ${task.body} ${task.anchors || ""}`.toLowerCase();
+    let score = 0;
+    for (const token of queryTokens) {
+        if (hay.includes(token))
+            score += token.length > 4 ? 3 : 2;
+    }
+    return score;
+}
 function rankClaims(claims, query, queryTokens, opts) {
     return claims.map((c) => {
         const freshness = assessClaimFreshness(opts.rootPath, c);
@@ -152,7 +178,44 @@ export function buildContext(repoId, query, limitOrOpts = 12) {
     const notes = notesRaw.length > 0
         ? notesRaw
         : listConversationNotes(repoId, 5).map((n) => ({ ...n, score: 0 }));
-    return { query, claims: selected, flows, components, notes };
+    const openTasks = listOpenTasksForContext(repoId, 8);
+    const doneTasks = queryTokens.length > 0
+        ? listTasks(repoId, { status: "done", includeDone: true, limit: 20 })
+            .map((t) => ({ ...t, score: scoreTask(t, queryTokens) }))
+            .filter((t) => t.score > 0)
+            .sort((a, b) => b.score - a.score || b.updated_at.localeCompare(a.updated_at))
+            .slice(0, 4)
+        : [];
+    const tasks = [...openTasks, ...doneTasks];
+    const skillsOn = opts.includeSkills !== false && loadPolicy().policy.skills_enabled;
+    const skills = skillsOn ? rankSkillsForQuery(query) : [];
+    const skillDrafts = skillsOn ? pendingSkillNudges(repoId) : [];
+    return { query, claims: selected, flows, components, notes, tasks, skills, skillDrafts };
+}
+/**
+ * amem has no model, so it cannot write a skill itself. The nudge is how a session-end
+ * detection reaches an agent that can. One at a time — this rides in every packet.
+ */
+function pendingSkillNudges(repoId) {
+    try {
+        return listSkillDrafts({ status: "pending", repoId, limit: 1 });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Progressive disclosure, level 0. Only names and descriptions reach the packet; the
+ * agent pulls a body with `amem_skill_view` if it decides the procedure applies. A skills
+ * directory that cannot be read must never break context, so this stays best-effort.
+ */
+function rankSkillsForQuery(query) {
+    try {
+        return rankSkills(listIndexedSkills(), query, 3);
+    }
+    catch {
+        return [];
+    }
 }
 function toShowdownClaims(ranked) {
     return ranked.map((c) => ({
@@ -258,7 +321,11 @@ export function decorateUsageEvents(events) {
 }
 export function renderContextMarkdown(packet) {
     const lines = ["# Agent Memory Context", "", `Query: ${packet.query}`, ""];
-    if (packet.claims.length === 0 && packet.notes.length === 0) {
+    if (packet.claims.length === 0 &&
+        packet.notes.length === 0 &&
+        (packet.tasks?.length ?? 0) === 0 &&
+        (packet.skills?.length ?? 0) === 0 &&
+        (packet.skillDrafts?.length ?? 0) === 0) {
         lines.push("No claims stored for this repository yet.", "");
         lines.push("Seed memory with the `amem-bootstrap` skill or `amem propose apply <file>`.");
         return lines.join("\n");
@@ -266,6 +333,41 @@ export function renderContextMarkdown(packet) {
     if (packet.claims.length === 0) {
         lines.push("No durable claims yet — using recent conversation memory.", "");
     }
+    if (packet.tasks && packet.tasks.length > 0) {
+        const hasDone = packet.tasks.some((t) => t.status === "done");
+        const hasOpen = packet.tasks.some((t) => t.status !== "done");
+        const header = hasDone && !hasOpen ? "## Completed tasks" : (hasDone ? "## Tasks (open & completed)" : "## Open tasks");
+        lines.push(header, "");
+        lines.push("_Project Kanban tasks. Use `amem_task_*` to add/update/complete._", "");
+        for (const task of packet.tasks) {
+            const body = task.body ? ` — ${task.body.replace(/\s+/g, " ").slice(0, 120)}` : "";
+            lines.push(`- **[${task.status}]** ${task.title}${body} (\`${task.id}\`)`);
+        }
+        lines.push("");
+    }
+    if (packet.skills && packet.skills.length > 0) {
+        lines.push("## Relevant skills", "");
+        lines.push("_Procedures that may apply. Only the index is shown — call `amem_skill_view` with the name to load one before following it._", "");
+        for (const skill of packet.skills) {
+            const desc = skill.description
+                ? ` — ${skill.description.replace(/\s+/g, " ").slice(0, 140)}`
+                : "";
+            lines.push(`- **${skill.name}**${desc}`);
+        }
+        lines.push("");
+    }
+    const nudge = packet.skillDrafts?.[0];
+    if (nudge) {
+        const why = safeReasons(nudge.reasons);
+        if (nudge.kind === "revision" && nudge.target_skill) {
+            lines.push("## Skill worth revising", "");
+            lines.push(`_You followed **${nudge.target_skill}** in a recent session and the work still went sideways${why}. If you learned what it was missing, update it with \`amem_skill_save\`._`, "");
+        }
+        else {
+            lines.push("## Worth saving as a skill", "");
+            lines.push(`_A recent session looked like a repeatable procedure: "${nudge.title}"${why}. If you can write it up, save it with \`amem_skill_save\` so the next agent does not rediscover it._`, "");
+        }
+    }
     const staleCount = packet.claims.filter((c) => c.freshness.status === "stale").length;
     if (staleCount > 0) {
         lines.push(`_${staleCount} claim(s) marked stale — anchored files changed after the claim was written. Verify before trusting._`, "");

package/dist/db.d.ts

@@ -96,6 +96,21 @@ export type SetupStateRow = {
     setup_completed_at: string | null;
     updated_at: string;
 };
+export type AgentTaskStatus = "backlog" | "next" | "doing" | "blocked" | "done";
+export type AgentTaskRow = {
+    repo_id: string;
+    id: string;
+    title: string;
+    body: string;
+    status: AgentTaskStatus;
+    anchors: string;
+    source: string;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+};
+export declare const AGENT_TASK_STATUSES: readonly AgentTaskStatus[];
+export declare function normalizeTaskStatus(raw: unknown): AgentTaskStatus | null;
 export declare function openDb(): Database.Database;
 export declare function closeDb(): void;
 declare function nowIso(): string;
@@ -189,4 +204,130 @@ export declare function listProposalDraftsAll(opts?: {
 export declare function countProposalDrafts(repoId: string, status?: string): number;
 export declare function countProposalDraftsAll(status?: string): number;
 export declare function setProposalDraftStatus(id: string, status: "pending" | "applied" | "dismissed"): ProposalDraftRow | null;
+export type SkillRow = {
+    name: string;
+    path: string;
+    description: string;
+    version: string | null;
+    tags: string;
+    repo_id: string | null;
+    content_hash: string;
+    origin_hash: string | null;
+    source: string;
+    uses: number;
+    last_used_at: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function listSkillRows(): SkillRow[];
+export declare function getSkillRow(name: string): SkillRow | null;
+/**
+ * Index one skill found on disk. Disk is the source of truth, so this only ever refreshes
+ * derived columns — it must not clobber the repo tag or usage counters a user built up.
+ */
+export declare function upsertSkillRow(input: {
+    name: string;
+    path: string;
+    description?: string;
+    version?: string | null;
+    tags?: string[];
+    contentHash: string;
+    source?: string;
+    repoId?: string | null;
+}): SkillRow;
+/** Optional memory tag. Skills are a global library; the tag is only a filter hint. */
+export declare function setSkillRepo(name: string, repoId: string | null): void;
+export declare function deleteSkillRow(name: string): boolean;
+/** Drop index rows whose skill is no longer on disk. */
+export declare function pruneSkillRows(keepNames: string[]): number;
+export declare function recordSkillUse(name: string, ctx?: {
+    repoId?: string | null;
+    sessionId?: string | null;
+}): void;
+/**
+ * Skills used recently in a repo. MCP clients do not always carry a session id, so
+ * recency in the same memory is the fallback for correlating a view to a session.
+ */
+export declare function listRecentSkillUses(repoId: string, minutes?: number, limit?: number): string[];
+export declare function listSkillsUsedInSession(sessionId: string, limit?: number): string[];
+export type SkillDraftRow = {
+    id: string;
+    repo_id: string | null;
+    name: string | null;
+    title: string;
+    summary: string;
+    content: string | null;
+    kind: string;
+    target_skill: string | null;
+    status: string;
+    source: string;
+    session_id: string | null;
+    reasons: string;
+    created_at: string;
+    updated_at: string;
+};
+export declare function insertSkillDraft(input: {
+    repoId?: string | null;
+    name?: string | null;
+    title: string;
+    summary?: string;
+    content?: string | null;
+    kind?: "suggestion" | "create" | "revision";
+    targetSkill?: string | null;
+    source?: string;
+    sessionId?: string | null;
+    reasons?: string[];
+}): SkillDraftRow;
+export declare function getSkillDraft(id: string): SkillDraftRow | null;
+export declare function listSkillDrafts(opts?: {
+    status?: string;
+    repoId?: string;
+    limit?: number;
+}): SkillDraftRow[];
+export declare function setSkillDraftStatus(id: string, status: string): SkillDraftRow | null;
+export declare function skillDraftExists(source: string): boolean;
+export declare function getTask(repoId: string, id: string): AgentTaskRow | null;
+export declare function listTasks(repoId: string, opts?: {
+    status?: AgentTaskStatus;
+    includeDone?: boolean;
+    limit?: number;
+}): AgentTaskRow[];
+/**
+ * Tasks across every memory. The UI's "All memory" scope needs this because agents file
+ * tasks against whatever repo they were working in, which is often not the repo the UI
+ * was launched from — without it those tasks are invisible.
+ */
+export declare function listTasksAll(opts?: {
+    status?: AgentTaskStatus;
+    includeDone?: boolean;
+    limit?: number;
+}): AgentTaskRow[];
+export declare function countTasksAll(opts?: {
+    status?: AgentTaskStatus;
+    openOnly?: boolean;
+}): number;
+/** Find a task without knowing its repo, so all-memory edits can resolve their owner. */
+export declare function findTaskAnyRepo(id: string): AgentTaskRow | null;
+/** Open tasks for context injection — prefer doing/next/blocked, then backlog. */
+export declare function listOpenTasksForContext(repoId: string, limit?: number): AgentTaskRow[];
+export declare function countTasks(repoId: string, opts?: {
+    status?: AgentTaskStatus;
+    openOnly?: boolean;
+}): number;
+export declare function insertTask(input: {
+    repoId: string;
+    title: string;
+    body?: string;
+    status?: AgentTaskStatus | string;
+    anchors?: string[];
+    source?: string;
+}): AgentTaskRow;
+export declare function updateTask(repoId: string, id: string, patch: {
+    title?: string;
+    body?: string;
+    status?: AgentTaskStatus | string;
+    anchors?: string[];
+}): AgentTaskRow | null;
+export declare function completeTask(repoId: string, id: string): AgentTaskRow | null;
+export declare function deleteTask(repoId: string, id: string): boolean;
 export { nowIso };