@iamem/amem 0.1.2 → 0.2.0

package/dist/estimate.js

@@ -3,11 +3,42 @@ export function estimateTokensFromText(text) {
     return Math.max(1, Math.ceil(text.length / 4));
 }
 /**
- * Proxy for exploration avoided:
+ * Assumed cost of one file the agent did not have to open. This is a MODELLED
+ * constant, not a measurement: it credits a saving whether or not the agent
+ * would actually have read that file. It dominates the headline number, so
+ * treat any total built from it as an upper bound until calibrated against
+ * real reported savings (`amem usage report --saved <n>`).
+ */
+export const ASSUMED_TOKENS_PER_FILE = 4000;
+export const ASSUMED_TOKENS_PER_CLAIM = 200;
+/**
+ * Proxy for exploration avoided, net of what the packet itself cost:
  * anchors_returned * 4000 + claims_returned * 200 - packet_tokens
+ *
+ * Deliberately NOT clamped at zero. A packet that returns little and still
+ * costs input tokens is a net loss, and the metric has to be able to say so —
+ * clamping made the dashboard structurally incapable of reporting that amem
+ * ever cost anything, which is not a property you want in your own numbers.
  */
 export function estimateTokensSaved(input) {
-    return Math.max(0, input.anchorsCount * 4000 + input.claimsCount * 200 - input.packetTokens);
+    return (input.anchorsCount * ASSUMED_TOKENS_PER_FILE +
+        input.claimsCount * ASSUMED_TOKENS_PER_CLAIM -
+        input.packetTokens);
+}
+/**
+ * How a savings figure should be presented. "measured" only once real reported
+ * savings exist; until then the number is a model and must be labelled as one.
+ */
+export function savingsBasis(reportedTokensSaved) {
+    const calibrated = Number(reportedTokensSaved) > 0;
+    return {
+        // Distinct from pricing.basis ("input"), which is about which side of the
+        // token bill is being priced, not about how trustworthy the figure is.
+        savingsBasis: calibrated ? "measured" : "modelled",
+        calibrated,
+        assumedTokensPerFile: ASSUMED_TOKENS_PER_FILE,
+        assumedTokensPerClaim: ASSUMED_TOKENS_PER_CLAIM,
+    };
 }
 /** Typical Cursor/Claude tool round-trip to read a file (~1.2s) plus a little per claim. */
 export const MS_PER_FILE_ROUNDTRIP = 1200;
@@ -18,7 +49,9 @@ export function estimateMsSaved(input) {
 /** Mid-range frontier *input* $/1M tokens (Sonnet-class). Avoided exploration is input-side. Not a bill. */
 export const USD_PER_MILLION_INPUT_TOKENS = 3;
 export function estimateUsdSaved(tokens, usdPerMillion = USD_PER_MILLION_INPUT_TOKENS) {
-    return Math.max(0, (Number(tokens) / 1_000_000) * usdPerMillion);
+    // Unclamped for the same reason as estimateTokensSaved: a negative here is
+    // real information, not an error to be hidden.
+    return (Number(tokens) / 1_000_000) * usdPerMillion;
 }
 export function eventKind(claimsCount, notesCount = 0) {
     return claimsCount > 0 || notesCount > 0 ? "local_hit" : "server_trip";

package/dist/freshness.d.ts

@@ -5,6 +5,13 @@ export type ClaimFreshness = {
     staleAnchors: string[];
     missingAnchors: string[];
 };
+/**
+ * capture.ts falls back to this when it cannot extract a real file anchor.
+ * README churns constantly, so honouring it as a real anchor marks those claims
+ * stale forever and drowns the genuine staleness signal. Treat it as no anchor.
+ * (capture.ts already filters it out of "does this claim have real anchors".)
+ */
+export declare const PLACEHOLDER_ANCHOR = "README.md";
 export declare function parseAnchors(codeAnchorsJson: string): string[];
 /**
  * Compare claim.updated_at to filesystem mtimes of code_anchors.

package/dist/freshness.js

@@ -1,5 +1,12 @@
 import { existsSync, statSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
+/**
+ * capture.ts falls back to this when it cannot extract a real file anchor.
+ * README churns constantly, so honouring it as a real anchor marks those claims
+ * stale forever and drowns the genuine staleness signal. Treat it as no anchor.
+ * (capture.ts already filters it out of "does this claim have real anchors".)
+ */
+export const PLACEHOLDER_ANCHOR = "README.md";
 export function parseAnchors(codeAnchorsJson) {
     try {
         const parsed = JSON.parse(codeAnchorsJson);
@@ -21,7 +28,7 @@ function resolveAnchorPath(rootPath, anchor) {
  * Missing paths → missing_anchor; any newer file → stale.
  */
 export function assessClaimFreshness(rootPath, claim) {
-    const anchors = parseAnchors(claim.code_anchors);
+    const anchors = parseAnchors(claim.code_anchors).filter((a) => a !== PLACEHOLDER_ANCHOR);
     if (anchors.length === 0) {
         return { status: "unanchored", staleAnchors: [], missingAnchors: [] };
     }

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 = {
@@ -68,3 +67,28 @@ export declare function runScheduledHygiene(unusedDays?: number): {
         error?: string;
     }>;
 };
+export type NonFactClaim = {
+    repoId: string;
+    repoName: string;
+    id: string;
+    kind: string;
+    reason: string;
+    preview: string;
+};
+/** Stored claims that are clear junk. Pinned claims are never included. */
+export declare function findNonFactClaims(opts?: {
+    repoId?: string;
+}): NonFactClaim[];
+/**
+ * Delete clear-junk claims. Always run with dryRun first — deletion is not
+ * reversible from inside amem, only from a backup.
+ */
+export declare function purgeNonFactClaims(opts?: {
+    repoId?: string;
+    dryRun?: boolean;
+}): {
+    scanned: number;
+    matched: NonFactClaim[];
+    deleted: number;
+    dryRun: boolean;
+};

package/dist/hygiene.js

@@ -1,13 +1,13 @@
 /**
  * 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 { deleteClaim, getClaim, listClaims, listClaimsAll, listProposalDrafts, listRepos, listUsageEvents, setClaimStatus, } from "./db.js";
 import { FEATURE_HYGIENE, hasFeature, requireFeature } from "./license.js";
 import { applyProposal, applySupersedes } from "./proposal.js";
 import { tokenJaccard } from "./search.js";
 import { parseAnchors } from "./freshness.js";
+import { nonFactReason } from "./kinds.js";
 export const SOFT_PAYWALL_FACTS = 200;
 export const SOFT_PAYWALL_NOISE = 15;
 /** Soft-paywall when session chat takeaways dominate the graph. */
@@ -252,3 +252,42 @@ export function runScheduledHygiene(unusedDays = 90) {
     }
     return { repos };
 }
+/** Stored claims that are clear junk. Pinned claims are never included. */
+export function findNonFactClaims(opts = {}) {
+    const names = new Map(listRepos().map((r) => [r.id, r.repo_name]));
+    const claims = opts.repoId ? listClaims(opts.repoId) : listClaimsAll();
+    const out = [];
+    for (const claim of claims) {
+        if (claim.pinned)
+            continue;
+        const reason = nonFactReason(claim.text);
+        if (!reason)
+            continue;
+        out.push({
+            repoId: claim.repo_id,
+            repoName: names.get(claim.repo_id) ?? claim.repo_id,
+            id: claim.id,
+            kind: claim.kind,
+            reason,
+            preview: claim.text.replace(/\s+/g, " ").slice(0, 120),
+        });
+    }
+    return out;
+}
+/**
+ * Delete clear-junk claims. Always run with dryRun first — deletion is not
+ * reversible from inside amem, only from a backup.
+ */
+export function purgeNonFactClaims(opts = {}) {
+    const dryRun = opts.dryRun !== false;
+    const scanned = (opts.repoId ? listClaims(opts.repoId) : listClaimsAll()).length;
+    const matched = findNonFactClaims({ repoId: opts.repoId });
+    let deleted = 0;
+    if (!dryRun) {
+        for (const row of matched) {
+            if (deleteClaim(row.repoId, row.id))
+                deleted += 1;
+        }
+    }
+    return { scanned, matched, deleted, dryRun };
+}

package/dist/install/hosts.d.ts

@@ -11,6 +11,21 @@ export declare function installContinue(workspace?: string): HostInstallResult;
 export declare function installAider(repoRoot: string): HostInstallResult;
 /** Zed: settings.json context_servers / mcp style. */
 export declare function installZed(workspace?: string): HostInstallResult;
+/** Absolute path to the POSIX launcher shipped with the package. */
+export declare function mcpLauncherPath(): string;
+/** Claude Desktop stores MCP config here (also read by Cowork). */
+export declare function claudeDesktopConfigPath(): string;
+/**
+ * Claude Desktop / Cowork: stdio MCP entry in claude_desktop_config.json.
+ *
+ * GUI apps are not launched from a login shell, so they inherit a minimal PATH
+ * with no Homebrew and no nvm. A bare `amem` — or even `node` — registers as a
+ * connector but never completes tool discovery, and the host reports no reason.
+ * Point at the launcher, which re-resolves node at spawn time; fall back to an
+ * absolute node + cli.js pair where a shell script cannot run (Windows).
+ */
+export declare function installClaudeDesktop(workspace?: string): HostInstallResult;
+export declare function claudeDesktopInstallHealth(): string[];
 export declare function continueInstallHealth(): string[];
 export declare function zedInstallHealth(): string[];
 export declare function windsurfInstallHealth(): string[];

package/dist/install/hosts.js

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { mcpClientConfig } from "../mcp.js";
-import { resolveAmemBin, writeJson, readJsonObject } from "./skills.js";
+import { dirname, join } from "node:path";
+import { mcpClientConfig, stdioMcpLaunch } from "../mcp.js";
+import { getPackageRoot, resolveAmemBin, writeJson, readJsonObject } from "./skills.js";
 function ensureDir(path) {
     mkdirSync(path, { recursive: true });
 }
@@ -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
@@ -122,6 +130,72 @@ export function installZed(workspace = "personal") {
         ],
     };
 }
+/** Absolute path to the POSIX launcher shipped with the package. */
+export function mcpLauncherPath() {
+    return join(getPackageRoot(), "scripts", "mcp-launch.sh");
+}
+/** Claude Desktop stores MCP config here (also read by Cowork). */
+export function claudeDesktopConfigPath() {
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+/**
+ * Claude Desktop / Cowork: stdio MCP entry in claude_desktop_config.json.
+ *
+ * GUI apps are not launched from a login shell, so they inherit a minimal PATH
+ * with no Homebrew and no nvm. A bare `amem` — or even `node` — registers as a
+ * connector but never completes tool discovery, and the host reports no reason.
+ * Point at the launcher, which re-resolves node at spawn time; fall back to an
+ * absolute node + cli.js pair where a shell script cannot run (Windows).
+ */
+export function installClaudeDesktop(workspace = "personal") {
+    const path = claudeDesktopConfigPath();
+    ensureDir(dirname(path));
+    const existing = readJsonObject(path);
+    const servers = existing.mcpServers ?? {};
+    const launcher = mcpLauncherPath();
+    const usable = process.platform !== "win32" && existsSync(launcher);
+    if (usable) {
+        try {
+            chmodSync(launcher, 0o755);
+        }
+        catch {
+            // npm preserves the exec bit; a read-only install is not fatal here
+        }
+    }
+    const stdio = stdioMcpLaunch(workspace);
+    servers.amem = usable
+        ? { command: launcher, args: [], env: { AMEM_WORKSPACE: workspace } }
+        : {
+            command: stdio.command,
+            args: stdio.args,
+            env: { ...stdio.env, AMEM_WORKSPACE: workspace },
+        };
+    writeJson(path, { ...existing, mcpServers: servers });
+    const shown = usable ? launcher : `${stdio.command} ${stdio.args.join(" ")}`;
+    return {
+        host: "claude-desktop",
+        paths: [path],
+        notes: [
+            `Claude Desktop MCP amem \u2192 ${shown} (workspace ${workspace}).`,
+            "Quit Claude Desktop fully (Cmd+Q) and relaunch \u2014 config is read at startup, closing the window is not enough.",
+            "stdio needs no daemon: amem ui does not have to be running.",
+        ],
+    };
+}
+export function claudeDesktopInstallHealth() {
+    const path = claudeDesktopConfigPath();
+    if (!fileMentionsAmem(path)) {
+        return ["Claude Desktop has no amem MCP entry \u2014 run amem init --platform claude-desktop"];
+    }
+    return [];
+}
 function fileMentionsAmem(path) {
     if (!existsSync(path))
         return false;
@@ -159,6 +233,8 @@ export function windsurfInstallHealth() {
 }
 export function hostInstallHealth(host) {
     switch (host) {
+        case "claude-desktop":
+            return claudeDesktopInstallHealth();
         case "continue":
             return continueInstallHealth();
         case "zed":
@@ -172,6 +248,8 @@ export function hostInstallHealth(host) {
 export function installHost(host, opts = {}) {
     const ws = opts.workspace || "personal";
     switch (host) {
+        case "claude-desktop":
+            return installClaudeDesktop(ws);
         case "windsurf":
             return installWindsurf(ws);
         case "continue":

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/kinds.d.ts

@@ -15,4 +15,22 @@ export declare function compactFromNotes(notes: Array<{
     prompt: string;
     answer: string;
 } | null;
+/**
+ * Is this a durable statement about the code, or conversational residue?
+ *
+ * Auto-capture previously accepted any sentence >= 48 chars that mentioned a
+ * path, which stored the user's own questions as facts ("so use luna mcp to
+ * connect to amem and that will do the trick?"). A question is a request, not
+ * a fact, however many files it names.
+ */
+/**
+ * Why an ALREADY STORED claim is clear junk, or null to keep it.
+ *
+ * Deliberately narrower than isFactLike: that gate decides what to admit and
+ * can afford false negatives, this one decides what to DELETE and a false
+ * positive destroys memory. Short, lowercase or oddly-formatted claims are
+ * kept here even though capture would now reject them.
+ */
+export declare function nonFactReason(text: string): string | null;
+export declare function isFactLike(text: string): boolean;
 export declare function isDurableCapture(prompt: string, answer: string | undefined, anchorCount: number): boolean;

package/dist/kinds.js

@@ -47,8 +47,14 @@ export function compactClaimText(prompt, answer) {
         const head = sentences.slice(0, 2).join(" ").slice(0, 400);
         return head || takeaway.slice(0, 400);
     }
-    const q = prompt.replace(/\s+/g, " ").trim().slice(0, 280);
-    return takeaway ? `${q}\n\nPrior outcome: ${takeaway.slice(0, 200)}` : q.slice(0, 400);
+    // Short answer: the fact is still in the ANSWER, so lead with it and keep the
+    // prompt only as trailing context. Leading with the prompt is how questions
+    // ended up stored as durable claims; the trailing "?" is dropped so the
+    // result reads as a statement rather than tripping the question filter.
+    const q = prompt.replace(/\s+/g, " ").trim().replace(/\?+\s*$/, "").slice(0, 280);
+    if (!takeaway)
+        return q.slice(0, 400);
+    return `${takeaway.slice(0, 200)}${q ? ` (context: ${q})` : ""}`.slice(0, 400);
 }
 /** Multi-turn: fold several notes into one compact fact string. */
 export function compactFromNotes(notes) {
@@ -72,10 +78,81 @@ function isUsefulish(text) {
 function scrubCodeNoise(text) {
     return text
         .replace(/```[\s\S]*?```/g, " ")
-        .replace(/`[^`]+`/g, " ")
+        // Keep what is INSIDE an inline span. Deleting it removed the file paths
+        // and identifiers that make a claim worth storing ("lives in `src/x.ts`"
+        // became "lives in and"), and it ran before pickFactSentences, which
+        // scores sentences on exactly those paths.
+        .replace(/`([^`]+)`/g, "$1")
         .replace(/\s+/g, " ")
         .trim();
 }
+const QUESTION_LEAD = /^(can|could|would|should|is|are|was|were|do|does|did|how|what|why|when|where|who|which|will|shall|may|might|am|have|has|had)\b/i;
+const CHAT_LEAD = /^(so|ok|okay|and|but|also|im|i'm|let's|lets|please|thanks|thx|yeah|yep|nope|hmm|wait|actually|btw|oh|hey)\b/i;
+/** Residue of an earlier scrub: "lives in and is", "wired via and included". */
+const DANGLING = /\b(in|at|from|to|via|inside|under|with|into)\s+(and|is|was|the file|what)\b/i;
+/** Interrogative opener plus a subject — a question missing its "?". */
+const QUESTION_SHAPE = /^(can|could|should|would|do|does|did|is|are|will|shall|how|what|why|when|where|who|which)\s+(?:(?:do|does|did|can|could|should|would|is|are|will|shall)\s+)?(we|you|i|amem)\b/i;
+/** Preposition running into punctuation or end of string: the object was deleted. */
+const TRAILING_PREPOSITION = /\b(in|at|from|to|via|inside|under|with|into|through)\s*([.,;:]|$)/i;
+/** A leading token that looks like code (path, dotted or snake_case name). */
+const CODE_LEAD = /^[\w@./-]*[._/][\w@./-]*(\s|$)/;
+/**
+ * Is this a durable statement about the code, or conversational residue?
+ *
+ * Auto-capture previously accepted any sentence >= 48 chars that mentioned a
+ * path, which stored the user's own questions as facts ("so use luna mcp to
+ * connect to amem and that will do the trick?"). A question is a request, not
+ * a fact, however many files it names.
+ */
+/**
+ * Why an ALREADY STORED claim is clear junk, or null to keep it.
+ *
+ * Deliberately narrower than isFactLike: that gate decides what to admit and
+ * can afford false negatives, this one decides what to DELETE and a false
+ * positive destroys memory. Short, lowercase or oddly-formatted claims are
+ * kept here even though capture would now reject them.
+ */
+export function nonFactReason(text) {
+    const t = (text ?? "").replace(/\s+/g, " ").trim();
+    if (t.length === 0)
+        return "empty";
+    // A question is a request someone typed, not a fact about the code.
+    if (t.includes("?"))
+        return "question";
+    // ...and plenty were typed without the question mark ("can we expose amem
+    // data via mcp"). Require an interrogative opener FOLLOWED by a subject, so
+    // this cannot swallow a declarative sentence that merely starts with "Is".
+    if (QUESTION_SHAPE.test(t))
+        return "question";
+    // Left behind by the old scrub that deleted inline code spans.
+    if (DANGLING.test(t))
+        return "scrub-residue";
+    // Same damage, different shape: the span sat at the end of the clause, so a
+    // preposition now runs straight into punctuation ("memory lives under .").
+    if (TRAILING_PREPOSITION.test(t))
+        return "scrub-residue";
+    if (CHAT_LEAD.test(t))
+        return "chat-fragment";
+    return null;
+}
+export function isFactLike(text) {
+    const t = (text ?? "").replace(/\s+/g, " ").trim();
+    if (t.length < 40)
+        return false;
+    if (t.includes("?"))
+        return false;
+    if (QUESTION_LEAD.test(t))
+        return false;
+    if (CHAT_LEAD.test(t))
+        return false;
+    if (DANGLING.test(t))
+        return false;
+    // Mid-thought lowercase openings are transcript fragments — unless the
+    // sentence opens on an identifier, which is normal for a real fact.
+    if (/^[a-z]/.test(t) && !CODE_LEAD.test(t))
+        return false;
+    return true;
+}
 function pickFactSentences(text) {
     const sentences = text.split(/(?<=[.!?])\s+/).filter((s) => s.length > 25);
     const scored = sentences.map((s) => {

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
 }