@iamem/amem 0.1.2 → 0.2.0

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";
@@ -11,7 +11,7 @@ import { installHost } from "./install/hosts.js";
 import { amemHome, dbPath, tryEnsureDir } from "./paths.js";
 import { assertExportAllowed, assertPlatformAllowed, assertRemoteAllowed, assertUiAllowed, loadPolicy, } from "./policy.js";
 import { applyProposal, diffProposal, exportRepoMemory, formatProposalDiff, loadProposalFile, validateProposal, } from "./proposal.js";
-import { detectRepoIdentity, parseWorkspaceSlug, workspaceIdentity } from "./repo-identity.js";
+import { detectRepoIdentity, parseWorkspaceSlug, unbindableRootReason, workspaceIdentity, } from "./repo-identity.js";
 import { runDesktopApp } from "./app-shell.js";
 import { startUiServer, buildUiLandingUrl, openUiInBrowser, isAddrInUse, probeUiHealth, } from "./ui/server.js";
 import { installLoginService, isServiceInstalled, isServiceSupported, uninstallLoginService } from "./service.js";
@@ -25,16 +25,18 @@ import { rememberContract } from "./remember-contract.js";
 import { vaultStatus } from "./vault.js";
 import { applyLicenseFile, clearLicense, generateLicenseKeys, licenseStatus, signLicense, } from "./license.js";
 import { embedIndexIssues, embedStatus, reindexAllEmbeds, setEmbedBackend, } from "./embed.js";
-import { acceptSafeCleanups, decayStaleClaims, hygieneReport, mergeDuplicate, runScheduledHygiene } from "./hygiene.js";
+import { acceptSafeCleanups, decayStaleClaims, hygieneReport, mergeDuplicate, purgeNonFactClaims, 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
 
 Usage:
   amem setup [--personal] [--platform <host>]
-  amem init --platform cursor|claude|windsurf|continue|aider|zed
+  amem init --platform cursor|claude|claude-desktop|windsurf|continue|aider|zed
   amem init --workspace <name> [--path <dir>] [--platform …]
   amem init --personal
   amem rename "<display name>" --workspace <slug>
@@ -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>
@@ -56,10 +63,13 @@ Usage:
   amem backup unschedule
   amem restore --file <backup.db|backup.db.enc> [--passphrase <secret>]
   amem hygiene [--days 90] [--decay] [--accept-safe] [--merge <keepId> <dropId>]
+  amem hygiene --purge-nonfacts [--all] [--apply]   # default is a dry run
   amem hygiene --scheduled
   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>]
@@ -221,11 +231,29 @@ async function main() {
                 }
                 const platform = flagString(flags, "platform");
                 if (!platform) {
-                    throw new Error("amem init requires --platform cursor|claude|windsurf|continue|aider|zed, --workspace <name>, or --personal");
+                    throw new Error("amem init requires --platform cursor|claude|claude-desktop|windsurf|continue|aider|zed, --workspace <name>, or --personal");
                 }
                 const policy = loadPolicy().policy;
                 assertPlatformAllowed(platform, policy);
+                // Claude Desktop, Windsurf, Continue and Zed read a single machine-wide
+                // MCP config. There is nothing repo-specific to bind, and binding the
+                // cwd here is exactly how running this from a home directory
+                // registered the whole home as a repo.
+                if (HOST_INSTALL_IDS.has(platform) && platform !== "aider") {
+                    const hostInfo = installHost(platform, { workspace: PERSONAL_SLUG });
+                    console.log(`Configured ${hostInfo.host} (machine-wide, no repo binding)`);
+                    for (const cfgPath of hostInfo.paths)
+                        console.log(`Config: ${cfgPath}`);
+                    for (const note of hostInfo.notes)
+                        console.log(`Note: ${note}`);
+                    break;
+                }
                 const identity = detectRepoIdentity();
+                const unbindable = unbindableRootReason(identity.rootPath);
+                if (unbindable) {
+                    throw new Error(`Refusing to bind ${unbindable} (${identity.rootPath}) as a repo. ` +
+                        "cd into a project first, or use: amem init --workspace <name>");
+                }
                 assertRemoteAllowed(identity.remoteUrl, policy);
                 const repo = upsertRepo(identity, platform);
                 let installInfo = { skills: [] };
@@ -646,6 +674,33 @@ async function main() {
                     }
                     break;
                 }
+                if (flags.get("purge-nonfacts")) {
+                    const all = Boolean(flags.get("all"));
+                    const scope = all ? {} : { repoId: resolveBinding(flags).id };
+                    // Dry run unless --apply is passed: deletion is not reversible.
+                    const preview = purgeNonFactClaims({ ...scope, dryRun: true });
+                    const byReason = new Map();
+                    for (const row of preview.matched) {
+                        byReason.set(row.reason, (byReason.get(row.reason) ?? 0) + 1);
+                    }
+                    console.log(`Scanned ${preview.scanned} claim(s)${all ? " across every repo" : ""}; ${preview.matched.length} look like clear junk.`);
+                    for (const [reason, n] of [...byReason].sort((a, b) => b[1] - a[1])) {
+                        console.log(`  ${reason}: ${n}`);
+                    }
+                    for (const row of preview.matched.slice(0, 8)) {
+                        console.log(`  - [${row.repoName}] ${row.reason}: ${row.preview}`);
+                    }
+                    if (preview.matched.length > 8) {
+                        console.log(`  … and ${preview.matched.length - 8} more`);
+                    }
+                    if (!flags.get("apply")) {
+                        console.log("Dry run. Re-run with --apply to delete. Back up first: amem backup");
+                        break;
+                    }
+                    const result = purgeNonFactClaims({ ...scope, dryRun: false });
+                    console.log(`Deleted ${result.deleted} claim(s).`);
+                    break;
+                }
                 const repo = resolveBinding(flags);
                 const days = Number(flagString(flags, "days") ?? "90");
                 const keep = flagString(flags, "merge");
@@ -691,6 +746,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 +1203,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._`, "");