@iamem/amem 0.1.2 → 0.1.3

package/dist/db.js

@@ -6,6 +6,19 @@ import { detectRepoIdentity, newId, parseWorkspaceSlug, slugifyWorkspace } from
 import { ensureClaimsFts, reindexAllClaimsFts, reindexRepoClaimsFts, removeClaimFts, upsertClaimFts } from "./search.js";
 import { ensureClaimsEmbed, reindexRepoEmbeds, removeClaimEmbed, upsertClaimEmbed, } from "./embed.js";
 import { isDbEncryptedAtRest, resolvePassphrase, unlockDatabase } from "./crypto.js";
+export const AGENT_TASK_STATUSES = [
+    "backlog",
+    "next",
+    "doing",
+    "blocked",
+    "done",
+];
+export function normalizeTaskStatus(raw) {
+    const s = String(raw || "")
+        .trim()
+        .toLowerCase();
+    return AGENT_TASK_STATUSES.includes(s) ? s : null;
+}
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS repos (
   id TEXT PRIMARY KEY,
@@ -116,6 +129,61 @@ CREATE TABLE IF NOT EXISTS proposal_drafts (
   updated_at TEXT NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS agent_tasks (
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'backlog',
+  anchors TEXT NOT NULL DEFAULT '[]',
+  source TEXT NOT NULL DEFAULT 'ui',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  PRIMARY KEY(repo_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS skills (
+  name TEXT PRIMARY KEY,
+  path TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  version TEXT,
+  tags TEXT NOT NULL DEFAULT '[]',
+  repo_id TEXT REFERENCES repos(id) ON DELETE SET NULL,
+  content_hash TEXT NOT NULL,
+  origin_hash TEXT,
+  source TEXT NOT NULL DEFAULT 'local',
+  uses INTEGER NOT NULL DEFAULT 0,
+  last_used_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS skill_drafts (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT REFERENCES repos(id) ON DELETE CASCADE,
+  name TEXT,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  content TEXT,
+  kind TEXT NOT NULL DEFAULT 'suggestion',
+  target_skill TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  source TEXT NOT NULL DEFAULT 'session-end',
+  session_id TEXT,
+  reasons TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS skill_uses (
+  id TEXT PRIMARY KEY,
+  skill_name TEXT NOT NULL,
+  repo_id TEXT,
+  session_id TEXT,
+  created_at TEXT NOT NULL
+);
+
 CREATE INDEX IF NOT EXISTS claims_repo_idx ON claims(repo_id);
 CREATE INDEX IF NOT EXISTS edges_repo_idx ON edges(repo_id);
 CREATE INDEX IF NOT EXISTS components_repo_idx ON components(repo_id);
@@ -127,6 +195,11 @@ CREATE INDEX IF NOT EXISTS conversation_notes_repo_idx ON conversation_notes(rep
 CREATE INDEX IF NOT EXISTS conversation_notes_created_idx ON conversation_notes(created_at);
 CREATE INDEX IF NOT EXISTS proposal_drafts_repo_idx ON proposal_drafts(repo_id);
 CREATE INDEX IF NOT EXISTS proposal_drafts_status_idx ON proposal_drafts(status);
+CREATE INDEX IF NOT EXISTS agent_tasks_repo_idx ON agent_tasks(repo_id);
+CREATE INDEX IF NOT EXISTS agent_tasks_status_idx ON agent_tasks(repo_id, status);
+CREATE INDEX IF NOT EXISTS skills_repo_idx ON skills(repo_id);
+CREATE INDEX IF NOT EXISTS skill_drafts_status_idx ON skill_drafts(status);
+CREATE INDEX IF NOT EXISTS skill_uses_session_idx ON skill_uses(session_id);
 `;
 let cached = null;
 export function openDb() {
@@ -152,6 +225,7 @@ export function openDb() {
     ensureClaimsFts(db);
     migrateClaimsFtsBootstrap(db);
     ensureProposalDrafts(db);
+    ensureAgentTasks(db);
     ensureClaimsEmbed(db);
     cached = db;
     return db;
@@ -198,6 +272,25 @@ function ensureProposalDrafts(db) {
     CREATE INDEX IF NOT EXISTS proposal_drafts_status_idx ON proposal_drafts(status);
   `);
 }
+function ensureAgentTasks(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_tasks (
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'backlog',
+      anchors TEXT NOT NULL DEFAULT '[]',
+      source TEXT NOT NULL DEFAULT 'ui',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      completed_at TEXT,
+      PRIMARY KEY(repo_id, id)
+    );
+    CREATE INDEX IF NOT EXISTS agent_tasks_repo_idx ON agent_tasks(repo_id);
+    CREATE INDEX IF NOT EXISTS agent_tasks_status_idx ON agent_tasks(repo_id, status);
+  `);
+}
 /** One-shot FTS rebuild flag so upgrades populate the index. */
 function migrateClaimsFtsBootstrap(db) {
     db.exec(`
@@ -663,4 +756,309 @@ export function setProposalDraftStatus(id, status) {
         .run(status, ts, id);
     return getProposalDraft(id);
 }
+function encodeTaskAnchors(anchors) {
+    const list = (anchors ?? [])
+        .filter((a) => typeof a === "string" && Boolean(a.trim()))
+        .map((a) => a.trim().slice(0, 200))
+        .slice(0, 20);
+    return JSON.stringify(list);
+}
+const TASK_STATUS_ORDER = {
+    doing: 0,
+    next: 1,
+    blocked: 2,
+    backlog: 3,
+    done: 4,
+};
+export function listSkillRows() {
+    return openDb().prepare(`SELECT * FROM skills ORDER BY name`).all();
+}
+export function getSkillRow(name) {
+    return (openDb().prepare(`SELECT * FROM skills WHERE name = ?`).get(name) ??
+        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 function upsertSkillRow(input) {
+    const ts = nowIso();
+    const existing = getSkillRow(input.name);
+    const tags = JSON.stringify(input.tags ?? []);
+    if (existing) {
+        openDb()
+            .prepare(`UPDATE skills SET path = ?, description = ?, version = ?, tags = ?,
+         content_hash = ?, source = ?, updated_at = ? WHERE name = ?`)
+            .run(input.path, input.description ?? "", input.version ?? null, tags, input.contentHash, input.source ?? existing.source, ts, input.name);
+        if (input.repoId !== undefined)
+            setSkillRepo(input.name, input.repoId);
+        return getSkillRow(input.name);
+    }
+    openDb()
+        .prepare(`INSERT INTO skills (name, path, description, version, tags, repo_id, content_hash,
+        origin_hash, source, uses, last_used_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?)`)
+        .run(input.name, input.path, input.description ?? "", input.version ?? null, tags, input.repoId ?? null, input.contentHash, input.contentHash, input.source ?? "local", ts, ts);
+    return getSkillRow(input.name);
+}
+/** Optional memory tag. Skills are a global library; the tag is only a filter hint. */
+export function setSkillRepo(name, repoId) {
+    openDb()
+        .prepare(`UPDATE skills SET repo_id = ?, updated_at = ? WHERE name = ?`)
+        .run(repoId, nowIso(), name);
+}
+export function deleteSkillRow(name) {
+    const info = openDb().prepare(`DELETE FROM skills WHERE name = ?`).run(name);
+    return Number(info.changes || 0) > 0;
+}
+/** Drop index rows whose skill is no longer on disk. */
+export function pruneSkillRows(keepNames) {
+    const keep = new Set(keepNames);
+    let removed = 0;
+    for (const row of listSkillRows()) {
+        if (!keep.has(row.name)) {
+            deleteSkillRow(row.name);
+            removed += 1;
+        }
+    }
+    return removed;
+}
+export function recordSkillUse(name, ctx = {}) {
+    openDb()
+        .prepare(`UPDATE skills SET uses = uses + 1, last_used_at = ? WHERE name = ?`)
+        .run(nowIso(), name);
+    // Per-session trail so session-end can tell which procedures were actually followed.
+    openDb()
+        .prepare(`INSERT INTO skill_uses (id, skill_name, repo_id, session_id, created_at) VALUES (?, ?, ?, ?, ?)`)
+        .run(newId("skilluse"), name, ctx.repoId ?? null, ctx.sessionId ?? null, nowIso());
+}
+/**
+ * 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 function listRecentSkillUses(repoId, minutes = 120, limit = 5) {
+    const since = new Date(Date.now() - minutes * 60_000).toISOString();
+    const rows = openDb()
+        .prepare(`SELECT skill_name, MAX(created_at) AS last FROM skill_uses
+       WHERE repo_id = ? AND created_at >= ? GROUP BY skill_name ORDER BY last DESC LIMIT ?`)
+        .all(repoId, since, limit);
+    return rows.map((r) => r.skill_name);
+}
+export function listSkillsUsedInSession(sessionId, limit = 5) {
+    if (!sessionId)
+        return [];
+    const rows = openDb()
+        .prepare(`SELECT skill_name, MAX(created_at) AS last FROM skill_uses
+       WHERE session_id = ? GROUP BY skill_name ORDER BY last DESC LIMIT ?`)
+        .all(sessionId, limit);
+    return rows.map((r) => r.skill_name);
+}
+export function insertSkillDraft(input) {
+    const id = newId("skilldraft");
+    const ts = nowIso();
+    openDb()
+        .prepare(`INSERT INTO skill_drafts (id, repo_id, name, title, summary, content, kind, target_skill,
+        status, source, session_id, reasons, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?)`)
+        .run(id, input.repoId ?? null, input.name ?? null, input.title, input.summary ?? "", input.content ?? null, input.kind ?? "suggestion", input.targetSkill ?? null, input.source ?? "session-end", input.sessionId ?? null, JSON.stringify(input.reasons ?? []), ts, ts);
+    return getSkillDraft(id);
+}
+export function getSkillDraft(id) {
+    return (openDb().prepare(`SELECT * FROM skill_drafts WHERE id = ?`).get(id) ?? null);
+}
+export function listSkillDrafts(opts = {}) {
+    const limit = Math.min(200, Math.max(1, opts.limit ?? 50));
+    const where = [];
+    const args = [];
+    if (opts.status) {
+        where.push("status = ?");
+        args.push(opts.status);
+    }
+    if (opts.repoId) {
+        where.push("repo_id = ?");
+        args.push(opts.repoId);
+    }
+    const sql = `SELECT * FROM skill_drafts ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at DESC LIMIT ?`;
+    return openDb()
+        .prepare(sql)
+        .all(...args, limit);
+}
+export function setSkillDraftStatus(id, status) {
+    openDb()
+        .prepare(`UPDATE skill_drafts SET status = ?, updated_at = ? WHERE id = ?`)
+        .run(status, nowIso(), id);
+    return getSkillDraft(id);
+}
+export function skillDraftExists(source) {
+    const row = openDb()
+        .prepare(`SELECT 1 AS hit FROM skill_drafts WHERE source = ? LIMIT 1`)
+        .get(source);
+    return Boolean(row);
+}
+export function getTask(repoId, id) {
+    return (openDb()
+        .prepare(`SELECT * FROM agent_tasks WHERE repo_id = ? AND id = ?`)
+        .get(repoId, id) ?? null);
+}
+export function listTasks(repoId, opts = {}) {
+    const limit = Math.min(200, Math.max(1, opts.limit ?? 100));
+    let rows;
+    if (opts.status) {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks WHERE repo_id = ? AND status = ?
+         ORDER BY updated_at DESC LIMIT ?`)
+            .all(repoId, opts.status, limit);
+    }
+    else if (opts.includeDone) {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks WHERE repo_id = ?
+         ORDER BY updated_at DESC LIMIT ?`)
+            .all(repoId, limit);
+    }
+    else {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks WHERE repo_id = ? AND status != 'done'
+         ORDER BY updated_at DESC LIMIT ?`)
+            .all(repoId, limit);
+    }
+    return rows.sort((a, b) => (TASK_STATUS_ORDER[a.status] ?? 9) - (TASK_STATUS_ORDER[b.status] ?? 9) ||
+        b.updated_at.localeCompare(a.updated_at));
+}
+/**
+ * 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 function listTasksAll(opts = {}) {
+    const limit = Math.min(500, Math.max(1, opts.limit ?? 200));
+    let rows;
+    if (opts.status) {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks WHERE status = ? ORDER BY updated_at DESC LIMIT ?`)
+            .all(opts.status, limit);
+    }
+    else if (opts.includeDone) {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks ORDER BY updated_at DESC LIMIT ?`)
+            .all(limit);
+    }
+    else {
+        rows = openDb()
+            .prepare(`SELECT * FROM agent_tasks WHERE status != 'done' ORDER BY updated_at DESC LIMIT ?`)
+            .all(limit);
+    }
+    return rows.sort((a, b) => (TASK_STATUS_ORDER[a.status] ?? 9) - (TASK_STATUS_ORDER[b.status] ?? 9) ||
+        b.updated_at.localeCompare(a.updated_at));
+}
+export function countTasksAll(opts = {}) {
+    if (opts.status) {
+        const row = openDb()
+            .prepare(`SELECT COUNT(*) AS n FROM agent_tasks WHERE status = ?`)
+            .get(opts.status);
+        return Number(row?.n || 0);
+    }
+    if (opts.openOnly) {
+        const row = openDb()
+            .prepare(`SELECT COUNT(*) AS n FROM agent_tasks WHERE status != 'done'`)
+            .get();
+        return Number(row?.n || 0);
+    }
+    const row = openDb().prepare(`SELECT COUNT(*) AS n FROM agent_tasks`).get();
+    return Number(row?.n || 0);
+}
+/** Find a task without knowing its repo, so all-memory edits can resolve their owner. */
+export function findTaskAnyRepo(id) {
+    return (openDb().prepare(`SELECT * FROM agent_tasks WHERE id = ?`).get(id) ?? null);
+}
+/** Open tasks for context injection — prefer doing/next/blocked, then backlog. */
+export function listOpenTasksForContext(repoId, limit = 8) {
+    const rows = openDb()
+        .prepare(`SELECT * FROM agent_tasks WHERE repo_id = ? AND status != 'done'
+       ORDER BY updated_at DESC LIMIT ?`)
+        .all(repoId, Math.max(limit * 3, 24));
+    return rows
+        .sort((a, b) => (TASK_STATUS_ORDER[a.status] ?? 9) - (TASK_STATUS_ORDER[b.status] ?? 9) ||
+        b.updated_at.localeCompare(a.updated_at))
+        .slice(0, limit);
+}
+export function countTasks(repoId, opts = {}) {
+    if (opts.status) {
+        const row = openDb()
+            .prepare(`SELECT COUNT(*) AS n FROM agent_tasks WHERE repo_id = ? AND status = ?`)
+            .get(repoId, opts.status);
+        return Number(row?.n || 0);
+    }
+    if (opts.openOnly) {
+        const row = openDb()
+            .prepare(`SELECT COUNT(*) AS n FROM agent_tasks WHERE repo_id = ? AND status != 'done'`)
+            .get(repoId);
+        return Number(row?.n || 0);
+    }
+    const row = openDb()
+        .prepare(`SELECT COUNT(*) AS n FROM agent_tasks WHERE repo_id = ?`)
+        .get(repoId);
+    return Number(row?.n || 0);
+}
+export function insertTask(input) {
+    const title = String(input.title || "")
+        .trim()
+        .slice(0, 200);
+    if (!title)
+        throw new Error("title is required");
+    const status = normalizeTaskStatus(input.status) || "backlog";
+    const id = newId("task");
+    const ts = nowIso();
+    const completed = status === "done" ? ts : null;
+    openDb()
+        .prepare(`INSERT INTO agent_tasks (
+         repo_id, id, title, body, status, anchors, source, created_at, updated_at, completed_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(input.repoId, id, title, String(input.body || "").slice(0, 4000), status, encodeTaskAnchors(input.anchors), String(input.source || "ui").slice(0, 80), ts, ts, completed);
+    return getTask(input.repoId, id);
+}
+export function updateTask(repoId, id, patch) {
+    const existing = getTask(repoId, id);
+    if (!existing)
+        return null;
+    const ts = nowIso();
+    let title = existing.title;
+    let body = existing.body;
+    let status = existing.status;
+    let anchors = existing.anchors;
+    let completedAt = existing.completed_at;
+    if (typeof patch.title === "string") {
+        const t = patch.title.trim().slice(0, 200);
+        if (!t)
+            throw new Error("title cannot be empty");
+        title = t;
+    }
+    if (typeof patch.body === "string")
+        body = patch.body.slice(0, 4000);
+    if (patch.status !== undefined) {
+        const next = normalizeTaskStatus(patch.status);
+        if (!next)
+            throw new Error("invalid status");
+        status = next;
+        if (status === "done")
+            completedAt = completedAt || ts;
+        else
+            completedAt = null;
+    }
+    if (patch.anchors !== undefined)
+        anchors = encodeTaskAnchors(patch.anchors);
+    openDb()
+        .prepare(`UPDATE agent_tasks SET title = ?, body = ?, status = ?, anchors = ?,
+       updated_at = ?, completed_at = ? WHERE repo_id = ? AND id = ?`)
+        .run(title, body, status, anchors, ts, completedAt, repoId, id);
+    return getTask(repoId, id);
+}
+export function completeTask(repoId, id) {
+    return updateTask(repoId, id, { status: "done" });
+}
+export function deleteTask(repoId, id) {
+    const info = openDb()
+        .prepare(`DELETE FROM agent_tasks WHERE repo_id = ? AND id = ?`)
+        .run(repoId, id);
+    return Number(info.changes || 0) > 0;
+}
 export { nowIso };

package/dist/embed.js

@@ -1,11 +1,9 @@
 /**
- * On-device embeddings. Default is feature hashing (no download).
- * Pro can switch to a local n-gram encoder (still no cloud, no model fetch).
+ * On-device embeddings. Default is local n-gram semantic encoder (Pro retrieval on by default, no download, 100% private).
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { FEATURE_LOCAL_EMBED, hasFeature } from "./license.js";
 import { amemHome } from "./paths.js";
 import { tokenize } from "./search.js";
 export const HASH_DIM = 128;
@@ -31,16 +29,12 @@ export function requestedEmbedBackend() {
     if (env === "hash" || env === "ngram" || env === "external")
         return env;
     const raw = readEmbedSettings().backend;
-    if (raw === "ngram" || raw === "external")
+    if (raw === "hash" || raw === "ngram" || raw === "external")
         return raw;
-    return "hash";
+    return "ngram";
 }
 export function activeEmbedBackend() {
-    const requested = requestedEmbedBackend();
-    if ((requested === "ngram" || requested === "external") && hasFeature(FEATURE_LOCAL_EMBED)) {
-        return requested;
-    }
-    return "hash";
+    return requestedEmbedBackend();
 }
 export function embedDim(backend = activeEmbedBackend()) {
     if (backend === "ngram")
@@ -65,16 +59,13 @@ export function embedStatus() {
         backend,
         requested,
         dim: embedDim(backend),
-        licensed: hasFeature(FEATURE_LOCAL_EMBED),
+        licensed: true,
         path: embedSettingsPath(),
         command,
         args,
     };
 }
 export function setEmbedBackend(backend, extra = {}) {
-    if ((backend === "ngram" || backend === "external") && !hasFeature(FEATURE_LOCAL_EMBED)) {
-        throw new Error("Local embeddings need an amem Pro or IT license. Buy at https://getamem.com then: amem license apply --file <amem-license.json>");
-    }
     if (backend === "external" && !(extra.command || process.env.AMEM_EMBED_CMD || readEmbedSettings().command)) {
         throw new Error("external embedder needs --cmd (stdin text → stdout JSON { vector: number[] })");
     }

package/dist/hook.js

@@ -4,6 +4,7 @@ import { logContextUsage } from "./api/routes.js";
 import { captureMissLearnDraft, captureSessionDraft, findRecentContextMisses, isUsefulCaptureText, } from "./capture.js";
 import { getRepoByCwd, insertConversationNote, listConversationNotes, upsertRepo, } from "./db.js";
 import { detectRepoIdentity } from "./repo-identity.js";
+import { captureSkillRevision, captureSkillSuggestion } from "./skill-capture.js";
 const SECRET = /password|api[_-]?key|secret|token\s*[:=]|begin (rsa |openssh )?private/i;
 function workspaceRoot(payload) {
     const roots = payload.workspace_roots;
@@ -63,8 +64,9 @@ function injectPacket(repo, query, session, platform) {
         sessionId: session,
         query: query || "(session start)",
     });
-    if (packet.claims.length === 0 && packet.notes.length === 0)
+    if (packet.claims.length === 0 && packet.notes.length === 0 && (packet.tasks?.length ?? 0) === 0) {
         return null;
+    }
     return cap(markdown);
 }
 export function handleHookPayload(raw) {
@@ -171,6 +173,11 @@ function handleHookPayloadInner(raw) {
                 notes: recent.slice(0, 8).map((n) => ({ role: n.role, text: n.text })),
             });
         }
+        // Procedural memory: was this session a workflow worth writing up, or evidence that a
+        // skill we already followed is wrong? Chronological order matters to the heuristics.
+        const ordered = [...recent].reverse().map((n) => ({ role: n.role, text: n.text }));
+        captureSkillRevision({ repo, sessionId: sid, notes: ordered }) ??
+            captureSkillSuggestion({ repo, sessionId: sid, notes: ordered });
         return {};
     }
     return { continue: true };

package/dist/hygiene.d.ts

@@ -1,7 +1,6 @@
 /**
  * Local memory hygiene: decay unused facts, find near-duplicates, review inbox.
- * Apply/schedule is Pro/IT only. Preview counts are free (soft paywall).
- * Nothing is uploaded.
+ * Completely free and open — runs on-device, nothing uploaded.
  */
 import { type ClaimRow } from "./db.js";
 export type HygieneDuplicate = {

package/dist/hygiene.js

@@ -1,7 +1,6 @@
 /**
  * Local memory hygiene: decay unused facts, find near-duplicates, review inbox.
- * Apply/schedule is Pro/IT only. Preview counts are free (soft paywall).
- * Nothing is uploaded.
+ * Completely free and open — runs on-device, nothing uploaded.
  */
 import { getClaim, listClaims, listProposalDrafts, listRepos, listUsageEvents, setClaimStatus, } from "./db.js";
 import { FEATURE_HYGIENE, hasFeature, requireFeature } from "./license.js";

package/dist/install/hosts.js

@@ -74,6 +74,14 @@ Before large exploration, run:
 amem context "\${user question}" 
 \`\`\`
 
+Deferred tasks & Kanban:
+
+\`\`\`bash
+amem task list                     # list pending tasks
+amem task add "..." --body "..."   # add task to backlog
+amem task complete <id>            # mark finished task as done
+\`\`\`
+
 After durable discoveries:
 
 \`\`\`bash

package/dist/install/skills.js

@@ -17,14 +17,19 @@ export function copyBundledSkills(targetSkillsDir) {
     mkdirSync(targetSkillsDir, { recursive: true });
     const source = skillsSourceDir();
     const installed = [];
-    for (const name of ["amem-bootstrap", "amem-update-working-memory"]) {
+    const skillNames = [
+        "amem-bootstrap",
+        "amem-update-working-memory",
+        "amem-tasks",
+        "amem-write-skill",
+    ];
+    for (const name of skillNames) {
         const from = join(source, name);
         const to = join(targetSkillsDir, name);
-        if (!existsSync(from)) {
-            throw new Error(`Missing bundled skill: ${from}`);
+        if (existsSync(from)) {
+            cpSync(from, to, { recursive: true });
+            installed.push(to);
         }
-        cpSync(from, to, { recursive: true });
-        installed.push(to);
     }
     return installed;
 }

package/dist/license.d.ts

@@ -27,6 +27,7 @@ export declare const FEATURE_LOCAL_EMBED = "local_embed_model";
 export declare const FEATURE_ATTEST_SKU = "attest_sku";
 export declare const FEATURE_HYGIENE = "hygiene";
 export declare const FEATURE_RULES_SYNC = "rules_sync";
+export declare const ALL_FEATURES: string[];
 /** Vendor verify key (SPKI DER hex). Issue signed files with AMEM_LICENSE_PRIVKEY. */
 export declare const DEFAULT_LICENSE_PUBKEY_HEX = "302a300506032b6570032100b1e01cdb2d1ec60b372bb4307fa48ed743caba09a67633e4689aaa22221080fa";
 export declare function licensePath(): string;

package/dist/license.js

@@ -10,19 +10,25 @@ export const FEATURE_LOCAL_EMBED = "local_embed_model";
 export const FEATURE_ATTEST_SKU = "attest_sku";
 export const FEATURE_HYGIENE = "hygiene";
 export const FEATURE_RULES_SYNC = "rules_sync";
+export const ALL_FEATURES = [
+    FEATURE_LOCAL_EMBED,
+    FEATURE_HYGIENE,
+    FEATURE_RULES_SYNC,
+    FEATURE_ATTEST_SKU,
+];
 /** Vendor verify key (SPKI DER hex). Issue signed files with AMEM_LICENSE_PRIVKEY. */
 export const DEFAULT_LICENSE_PUBKEY_HEX = "302a300506032b6570032100b1e01cdb2d1ec60b372bb4307fa48ed743caba09a67633e4689aaa22221080fa";
-const BUY_HINT = "Buy at https://getamem.com then: amem license apply --file ~/Downloads/amem-license.json";
+const BUY_HINT = "amem is completely free and open with all features included.";
 const TIER_FEATURES = {
-    free: [],
-    pro: [FEATURE_LOCAL_EMBED, FEATURE_HYGIENE, FEATURE_RULES_SYNC],
-    it: [FEATURE_LOCAL_EMBED, FEATURE_HYGIENE, FEATURE_RULES_SYNC, FEATURE_ATTEST_SKU],
+    free: ALL_FEATURES,
+    pro: ALL_FEATURES,
+    it: ALL_FEATURES,
 };
 export function licensePath() {
     return join(amemHome(), "license.json");
 }
 export function featuresForTier(tier) {
-    return [...TIER_FEATURES[tier]];
+    return [...ALL_FEATURES];
 }
 export function generateLicenseKeys() {
     const pair = generateKeyPairSync("ed25519");
@@ -102,7 +108,7 @@ export function licenseStatus(now = new Date()) {
             return {
                 tier: "free",
                 kind: "none",
-                features: [],
+                features: [...ALL_FEATURES],
                 valid: true,
                 transferable: false,
                 path,
@@ -112,36 +118,34 @@ export function licenseStatus(now = new Date()) {
         if (expired(file.payload, now))
             issues.push("license expired");
         issues.push(...verifySignedLicense(file));
-        const tier = issues.length ? "free" : file.payload.tier;
-        const features = [...new Set([...(file.payload.features ?? []), ...featuresForTier(tier)])];
+        const tier = file.payload.tier || "free";
+        const features = [...new Set([...(file.payload.features ?? []), ...ALL_FEATURES])];
         return {
             tier,
             kind: "signed",
             subject: file.payload.subject,
             expires_at: file.payload.expires_at,
             features,
-            valid: issues.length === 0,
+            valid: true,
             transferable: true,
             path,
-            issues,
+            issues: [],
         };
     }
     catch (error) {
-        issues.push(error instanceof Error ? error.message : String(error));
         return {
             tier: "free",
             kind: "none",
-            features: [],
-            valid: false,
+            features: [...ALL_FEATURES],
+            valid: true,
             transferable: false,
             path,
-            issues,
+            issues: [],
         };
     }
 }
 export function hasFeature(feature) {
-    const status = licenseStatus();
-    return status.valid && status.features.includes(feature);
+    return true;
 }
 export function writeLicense(file, path = licensePath()) {
     mkdirSync(amemHome(), { recursive: true, mode: 0o700 });
@@ -166,7 +170,5 @@ export function clearLicense() {
         unlinkSync(path);
 }
 export function requireFeature(feature, label = feature) {
-    if (hasFeature(feature))
-        return;
-    throw new Error(`${label} needs an amem Pro or IT license. ${BUY_HINT}`);
+    // All features are included and free by default
 }