@lh8ppl/claude-memory-kit 0.3.5 → 0.4.1

package/src/kiro-transcript.mjs

@@ -0,0 +1,366 @@
+// kiro-transcript.mjs — the Kiro session-transcript adapter (Task 50.H).
+//
+// Resolves the D-180 "highest unverified risk": Kiro stores transcripts
+// differently from Claude Code, and the kit's capture path hardcoded the
+// Claude-Code touchpoints (~/.claude/projects/<slug>/<session>.jsonl, JSONL).
+// Verified on a REAL Kiro install (D-180): Kiro is a VS Code fork; per-session
+// JSON lives at
+//   %APPDATA%/Kiro/User/globalStorage/kiro.kiroagent/workspace-sessions/
+//     <base64url(workspacePath)>/<sessionId>.json
+// with a `history[]` of { message: { role, content: [{type:'text', text}] } }
+// plus a sibling `sessions.json` index.
+//
+// This module is the per-agent transcript adapter the cross-agent seam needs:
+// it turns Kiro's session JSON into the {role, text} turns the kit's capture
+// path consumes, and resolves the workspace→dir key. Pure + defensive — a
+// malformed/partial session returns [] rather than throwing (a capture hook
+// must never crash the agent).
+//
+// Public surface:
+//   parseKiroSessionHistory(jsonText) → [{role, text}]   (ordered turns, IDE schema)
+//   parseKiroCliSession(jsonText) → {assistantText}       (kiro-cli schema, D-199)
+//   readKiroCliTurn({projectRoot, env}) → {userText, assistantText}  (~/.kiro/sessions/cli)
+//   workspaceKeyForPath(workspacePath) → string          (the base64url dir key)
+//   parseKiroIdeV1Messages(jsonlText) → {userText, assistantText}  (IDE 1.0 messages.jsonl)
+//   readKiroIdeV1Turn({projectRoot, env}) → {userText, assistantText}  (~/.kiro/sessions/<hash>/sess_*)
+//   readKiroTurn({projectRoot, env}) → {userText, assistantText}  (IDE-0.x → CLI → IDE-1.0)
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * Parse a Kiro session JSON into ordered {role, text} turns.
+ * @param {string} jsonText raw contents of a <sessionId>.json file
+ * @returns {{role:string, text:string}[]}
+ */
+export function parseKiroSessionHistory(jsonText) {
+  let session;
+  try {
+    session = JSON.parse(jsonText);
+  } catch {
+    return [];
+  }
+  if (!session || !Array.isArray(session.history)) return [];
+
+  const turns = [];
+  for (const item of session.history) {
+    const msg = item && item.message;
+    if (!msg || typeof msg.role !== 'string') continue;
+    const text = extractText(msg.content);
+    if (text !== '') turns.push({ role: msg.role, text });
+  }
+  return turns;
+}
+
+/**
+ * Parse a kiro-cli session JSON into the latest assistant turn text.
+ *
+ * The kiro-CLI session schema is DIFFERENT from the IDE's (D-199 gate finding —
+ * primary-source verified on a real `~/.kiro/sessions/cli/<uuid>.json`): there is
+ * NO `history[]`. Instead the per-turn assistant text lives at
+ *   session_state.conversation_metadata.user_turn_metadatas[].result.Ok.content[].data
+ * (each content part is `{ kind, data }`, `kind === 'text'`). The user's prompt
+ * text is NOT stored verbatim (only `user_prompt_length`), so the CLI path yields
+ * the ASSISTANT text only — which is all captureTurn's extractTurnText needs.
+ *
+ * @param {string} jsonText raw contents of a kiro-cli <uuid>.json file
+ * @returns {{assistantText:string}}
+ */
+export function parseKiroCliSession(jsonText) {
+  let session;
+  try {
+    session = JSON.parse(jsonText);
+  } catch {
+    return { assistantText: '' };
+  }
+  const turns = session?.session_state?.conversation_metadata?.user_turn_metadatas;
+  if (!Array.isArray(turns) || turns.length === 0) return { assistantText: '' };
+
+  // the LAST turn is the most recent; read its assistant text from result.Ok.content[].
+  const last = turns[turns.length - 1];
+  const content = last?.result?.Ok?.content;
+  if (!Array.isArray(content)) return { assistantText: '' };
+  const assistantText = content
+    .filter((part) => part && part.kind === 'text' && typeof part.data === 'string')
+    .map((part) => part.data)
+    .join('\n');
+  return { assistantText };
+}
+
+/**
+ * Read the latest assistant turn from a kiro-CLI session for a project. The CLI
+ * stores sessions at ~/.kiro/sessions/cli/<uuid>.json, each carrying its own
+ * `cwd` + `updated_at`; we pick the most-recent file whose `cwd` matches the
+ * project root. Pure + defensive (a capture hook must never crash the session).
+ * @param {{projectRoot:string, env?:object}} args
+ * @returns {{userText:string, assistantText:string}}
+ */
+export function readKiroCliTurn({ projectRoot, env = process.env } = {}) {
+  const empty = { userText: '', assistantText: '' };
+  try {
+    if (!projectRoot) return empty;
+    const home = env.USERPROFILE || env.HOME || homedir();
+    const cliDir = join(home, '.kiro', 'sessions', 'cli');
+    if (!existsSync(cliDir)) return empty;
+
+    // Compare cwd by NORMALIZED separators + case, NOT path.resolve(): both
+    // projectRoot and json.cwd are already absolute, same-machine, same-form
+    // paths (the hook's cwd and the session's recorded cwd). resolve() would
+    // re-root a value against the current cwd if it ever looked relative — a real
+    // hazard. ASSUMPTION: both sides are absolute drive-letter or matching-form
+    // paths; an extended-length (\\?\) or `~` form on one side only won't match
+    // (a missed match → empty capture, never a crash). Full-string equality, not
+    // a prefix test — so `C:\Temp\proj` and `C:\Temp\proj-2` correctly differ.
+    const norm = (p) => p.replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+    const want = norm(projectRoot);
+    const files = readdirSync(cliDir).filter((f) => f.endsWith('.json'));
+    let best = null;
+    let bestStamp = null; // [epochMs, filename] for a deterministic tie-break
+    for (const f of files) {
+      let json;
+      try {
+        json = JSON.parse(readFileSync(join(cliDir, f), 'utf8'));
+      } catch {
+        continue;
+      }
+      if (!json?.cwd || norm(json.cwd) !== want) continue;
+      // Parse updated_at to epoch ms for a numeric compare — robust to ISO
+      // precision/offset drift (a future kiro-cli format change won't silently
+      // mis-order). Unparseable → 0, so the filename tie-break still orders it.
+      const epoch = Date.parse(json.updated_at) || 0;
+      const stamp = [epoch, f];
+      if (bestStamp === null || stamp[0] > bestStamp[0] || (stamp[0] === bestStamp[0] && stamp[1] > bestStamp[1])) {
+        bestStamp = stamp;
+        best = json;
+      }
+    }
+    if (!best) return empty;
+    const { assistantText } = parseKiroCliSession(JSON.stringify(best));
+    return { userText: '', assistantText };
+  } catch {
+    return empty;
+  }
+}
+
+/**
+ * Parse a Kiro IDE 1.0 messages.jsonl (D-203g) into the latest user + assistant
+ * text. IDE 1.0 moved session storage to ~/.kiro/sessions/<hash>/sess_<uuid>/ —
+ * a JSON-Lines `messages.jsonl`: one `{id, timestamp, payload:{type, content}}` per
+ * line; `payload.type ∈ {user, assistant, tool_call, tool_result, turn_start/end,
+ * ContextualHookInvoked, …}`; `payload.content` is the message text (string) for
+ * user/assistant. We take the LAST user + LAST assistant content. Primary-source
+ * verified on a real IDE-1.0 session.
+ * @param {string} jsonlText raw contents of a messages.jsonl
+ * @returns {{userText:string, assistantText:string}}
+ */
+export function parseKiroIdeV1Messages(jsonlText) {
+  const empty = { userText: '', assistantText: '' };
+  if (typeof jsonlText !== 'string') return empty;
+  let userText = '';
+  let assistantText = '';
+  for (const line of jsonlText.split('\n')) {
+    if (line.trim() === '') continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue; // a malformed line never crashes the whole read
+    }
+    const type = msg?.payload?.type;
+    if (type !== 'user' && type !== 'assistant') continue;
+    const text = ideV1ContentText(msg?.payload?.content);
+    if (text === '') continue;
+    if (type === 'user') userText = text; // keep the LAST one
+    else assistantText = text;
+  }
+  return { userText, assistantText };
+}
+
+// IDE 1.0 payload.content is a STRING for plain messages (verified on a real
+// session), but a multi-part message (with images/documents) MAY serialize it as
+// an array of typed parts like IDE-0.x — so handle BOTH (review I1): a string is
+// returned as-is; an array joins the `text`-typed parts (the `{type:'text', text}`
+// shape, like extractText). Anything else → '' (drop, never crash). Defensive so a
+// multi-part assistant reply isn't silently dropped → capture-nothing recurrence.
+function ideV1ContentText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((part) => part && part.type === 'text' && typeof part.text === 'string')
+      .map((part) => part.text)
+      .join('\n');
+  }
+  return '';
+}
+
+/**
+ * Read the latest turn from a Kiro IDE 1.0 session (D-203g). Scans
+ * ~/.kiro/sessions/<workspace-hash>/sess_<uuid>/, matching session.json's
+ * `workspacePaths` to projectRoot (no hash-reversing), picking the most-recently-
+ * modified messages.jsonl. Pure + defensive (a capture hook must never crash).
+ * @param {{projectRoot:string, env?:object}} args
+ * @returns {{userText:string, assistantText:string}}
+ */
+export function readKiroIdeV1Turn({ projectRoot, env = process.env } = {}) {
+  const empty = { userText: '', assistantText: '' };
+  try {
+    if (!projectRoot) return empty;
+    const home = env.USERPROFILE || env.HOME || homedir();
+    const sessionsRoot = join(home, '.kiro', 'sessions');
+    if (!existsSync(sessionsRoot)) return empty;
+
+    const norm = (p) => p.replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+    const want = norm(projectRoot);
+
+    // walk <hash>/sess_*/ dirs; match by session.json.workspacePaths; pick latest
+    // messages.jsonl by mtime, tie-broken by path (review M1 — mirror the CLI/0.x
+    // readers' deterministic [stamp, path] tie-break so an equal mtime isn't
+    // decided by readdir order).
+    let best = null; // [mtimeMs, messagesPath]
+    for (const hash of readdirSync(sessionsRoot)) {
+      const hashDir = join(sessionsRoot, hash);
+      let sessDirs;
+      try {
+        sessDirs = readdirSync(hashDir).filter((d) => d.startsWith('sess_'));
+      } catch {
+        // a non-directory entry at sessions/ root → readdirSync throws ENOTDIR;
+        // skip it. (The `cli/` sibling IS a dir but has no sess_* children, so it
+        // falls out of the filter below — both cases are handled, never crash.)
+        continue;
+      }
+      for (const sd of sessDirs) {
+        const dir = join(hashDir, sd);
+        const metaPath = join(dir, 'session.json');
+        const msgPath = join(dir, 'messages.jsonl');
+        if (!existsSync(metaPath) || !existsSync(msgPath)) continue;
+        let meta;
+        try {
+          meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+        } catch {
+          continue;
+        }
+        const paths = Array.isArray(meta?.workspacePaths) ? meta.workspacePaths : [];
+        if (!paths.some((p) => typeof p === 'string' && norm(p) === want)) continue;
+        let mtimeMs = 0;
+        try {
+          mtimeMs = statSync(msgPath).mtimeMs;
+        } catch {
+          /* keep 0 */
+        }
+        if (
+          best === null ||
+          mtimeMs > best[0] ||
+          (mtimeMs === best[0] && msgPath > best[1]) // deterministic tie-break (M1)
+        ) {
+          best = [mtimeMs, msgPath];
+        }
+      }
+    }
+    if (!best) return empty;
+    return parseKiroIdeV1Messages(readFileSync(best[1], 'utf8'));
+  } catch {
+    return empty;
+  }
+}
+
+// Join the text of all text-type content parts; ignore tool/other blocks.
+// Kiro's content is always an array of typed parts (verified on a real install);
+// a non-array is treated as "no text" rather than guessed at.
+function extractText(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((part) => part && part.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n');
+}
+
+/**
+ * Encode a workspace path to Kiro's workspace-sessions directory key.
+ * EXACT scheme verified on a real install: standard base64, then +→-, /→_, and
+ * the `=` padding → `_` (NOT stripped — Kiro keeps the padding as underscores).
+ * @param {string} workspacePath e.g. 'c:\\Projects\\demo'
+ * @returns {string}
+ */
+export function workspaceKeyForPath(workspacePath) {
+  return Buffer.from(workspacePath, 'utf8')
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '_');
+}
+
+/**
+ * Read the latest user+assistant turn from Kiro's transcript for a project.
+ *
+ * Composes the verified pieces (probe P-CJYGTQYR + D-180):
+ *   - the globalStorage dir is given to the hook via env CONTINUE_GLOBAL_DIR
+ *     (= …/Kiro/User/globalStorage/kiro.kiroagent), so we don't guess the path;
+ *   - the per-project dir is workspace-sessions/<base64url(projectRoot)>;
+ *   - the most-recent <sessionId>.json (by dateCreated, else mtime) is the live
+ *     session; its history[] is parsed to the latest user + assistant text.
+ *
+ * Pure + defensive: any missing dir / absent env / parse error returns empty
+ * strings, never throws (a capture hook must never crash the Kiro session).
+ *
+ * @param {{projectRoot:string, env?:object}} args
+ * @returns {{userText:string, assistantText:string}}
+ */
+// The non-(IDE-0.x) fallback chain: kiro-CLI (~/.kiro/sessions/cli, D-199) → IDE
+// 1.0 (~/.kiro/sessions/<hash>/sess_*/messages.jsonl, D-203g). Tried when the
+// legacy IDE-0.x globalStorage path yields nothing. Returns the first non-empty.
+function readKiroFallbackTurn({ projectRoot, env }) {
+  const cli = readKiroCliTurn({ projectRoot, env });
+  if (cli.assistantText || cli.userText) return cli;
+  return readKiroIdeV1Turn({ projectRoot, env });
+}
+
+export function readKiroTurn({ projectRoot, env = process.env } = {}) {
+  const empty = { userText: '', assistantText: '' };
+  try {
+    const globalDir = env.CONTINUE_GLOBAL_DIR;
+    // No IDE-0.x globalStorage (the CLI/IDE-1.0 don't set CONTINUE_GLOBAL_DIR) →
+    // the fallback chain (kiro-CLI then IDE-1.0). The legacy IDE-0.x path stays
+    // PRIMARY when its env+dir are present, so an 0.x user is unaffected.
+    if (!globalDir || !projectRoot) return readKiroFallbackTurn({ projectRoot, env });
+    const wsDir = join(globalDir, 'workspace-sessions', workspaceKeyForPath(projectRoot));
+    if (!existsSync(wsDir)) return readKiroFallbackTurn({ projectRoot, env });
+
+    // pick the most-recent session file (by dateCreated in the JSON, else mtime).
+    const files = readdirSync(wsDir).filter((f) => f.endsWith('.json') && f !== 'sessions.json');
+    if (files.length === 0) return readKiroFallbackTurn({ projectRoot, env });
+
+    // Sort files for a DETERMINISTIC pick (review M2): primary by dateCreated
+    // (desc), secondary by filename (desc) so an equal-stamp tie isn't decided by
+    // readdir order. The first after sort is the most-recent session.
+    let best = null;
+    let bestKey = null; // [stamp, filename]
+    for (const f of files) {
+      let json;
+      try {
+        json = JSON.parse(readFileSync(join(wsDir, f), 'utf8'));
+      } catch {
+        continue;
+      }
+      const key = [Number(json.dateCreated) || 0, f];
+      if (bestKey === null || key[0] > bestKey[0] || (key[0] === bestKey[0] && key[1] > bestKey[1])) {
+        bestKey = key;
+        best = json;
+      }
+    }
+    if (!best || !Array.isArray(best.history)) return readKiroFallbackTurn({ projectRoot, env });
+
+    const turns = parseKiroSessionHistory(JSON.stringify(best));
+    const lastUser = [...turns].reverse().find((t) => t.role === 'user');
+    const lastAssistant = [...turns].reverse().find((t) => t.role === 'assistant');
+    // IDE-0.x session present but no text → fall through (a mixed install where the
+    // same project was used from another surface).
+    if (!lastAssistant?.text && !lastUser?.text) return readKiroFallbackTurn({ projectRoot, env });
+    return {
+      userText: lastUser?.text || '',
+      assistantText: lastAssistant?.text || '',
+    };
+  } catch {
+    return empty;
+  }
+}

package/src/kiro-trusted-commands.mjs

@@ -0,0 +1,130 @@
+// kiro-trusted-commands.mjs — pre-trust the kit's Kiro hook commands (D-194).
+//
+// THE PROBLEM (found live in the v0.4.0 cut-gate-kiro, 50.M): Kiro gates a hook's
+// shell command behind a "Run / Reject" approval prompt unless it's pre-trusted
+// (kiro.dev/docs/cli/chat/permissions). So the kit's inject/capture/guard hooks —
+// `cmd.exe /c cmk hook promptSubmit`, etc. — prompt the user EVERY turn, and
+// "automatic memory" isn't automatic. On Claude Code a registered hook just fires;
+// on Kiro it must be trusted (the 6th cross-agent "Claude-Code-shaped assumption"
+// cut-blocker — D-185/186/187/188/190).
+//
+// THE FIX: write the kit's OWN hook-command prefixes into the WORKSPACE
+// `.vscode/settings.json` under `kiroAgent.trustedCommands` — Kiro's IDE
+// command-trust list (an array of wildcard-PREFIX patterns; `npm *` trusts any
+// command starting `npm `). Workspace scope (not the user-global
+// `…/Kiro/User/settings.json`) so the trust travels with the repo and never
+// touches the user's machine-wide trust.
+//
+// We trust ONLY the kit's own commands by SPECIFIC prefix — never the
+// over-permissive `cmd.exe /c *` or `*` (the docs warn wildcards over-trust, and
+// trust matches only the command PREFIX, so a broad prefix would also trust any
+// chained command after it).
+//
+// Disciplines (same as mutateAgentConfig): array-UNION (a user's existing trusted
+// commands are preserved + deduped, never clobbered), refuse-to-clobber on a
+// corrupt file, BOM-tolerant read (D-187), idempotent, atomic write. Uninstall
+// removes ONLY our patterns and prunes an emptied key (no orphan empty array) —
+// the over-mutation guard.
+//
+// Public surface:
+//   installKiroTrustedCommands({ projectRoot }) → { action, changed, path }
+//   uninstallKiroTrustedCommands({ projectRoot }) → { action, changed, path }
+//   kitTrustedCommandPatterns() → string[]  (the patterns we own — also the
+//                                            uninstall key + the doctor/gate check)
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseJsonFile } from './read-json.mjs';
+import { atomicWrite } from './mutate-agent-config.mjs';
+import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
+
+const SETTINGS_PATH = ['.vscode', 'settings.json'];
+const TRUSTED_KEY = 'kiroAgent.trustedCommands';
+
+const IS_WINDOWS = process.platform === 'win32';
+
+// The kit's hook commands, as TRUST PREFIXES. These must prefix-match the actual
+// commands kiro-hook-command.mjs emits:
+//   IDE/CLI hooks → `[cmd.exe /c ]cmk hook <event>`   → `…cmk hook *`
+//   delete-guard  → `[cmd.exe /c ]cmk-guard-memory`   → `…cmk-guard-memory*`
+// Windows wraps in `cmd.exe /c ` (the WSL-no-node finding, P-PM2CD6CB); POSIX runs
+// the bare command. We keep these in lockstep with kiro-hook-command.mjs by
+// mirroring its exact platform prefix — a SPECIFIC prefix, not a blanket wildcard.
+const WIN_PREFIX = 'cmd.exe /c ';
+export function kitTrustedCommandPatterns() {
+  const base = ['cmk hook *', 'cmk-guard-memory*'];
+  return IS_WINDOWS ? base.map((b) => WIN_PREFIX + b) : base;
+}
+
+// Read settings.json, distinguishing missing (→ {}) from corrupt (→ throw-marker).
+// BOM-tolerant: a Windows-editor BOM must not read as corrupt (D-187). Returns
+// { root } on success or { error } on a genuine parse failure (refuse-to-clobber).
+function readSettings(path) {
+  if (!existsSync(path)) return { root: {} };
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (err) {
+    return { error: `could not read ${path}: ${err.message}` };
+  }
+  if (raw.trim() === '') return { root: {} };
+  // parseJsonFile strips the BOM and returns the sentinel on bad JSON.
+  const CORRUPT = Symbol('corrupt');
+  const parsed = parseJsonFile(path, { fallback: CORRUPT });
+  if (parsed === CORRUPT) return { error: `${path} is not valid JSON — refusing to overwrite` };
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return { error: `${path} is valid JSON but not an object — refusing to overwrite` };
+  }
+  return { root: parsed };
+}
+
+export function installKiroTrustedCommands({ projectRoot } = {}) {
+  if (!projectRoot) throw new Error('installKiroTrustedCommands: projectRoot is required');
+  const path = join(projectRoot, ...SETTINGS_PATH);
+  const fileExists = existsSync(path);
+
+  const { root, error } = readSettings(path);
+  if (error) return errorResult({ category: ERROR_CATEGORIES.CONFIG_PARSE, errors: [error], changed: false, path });
+
+  const existing = Array.isArray(root[TRUSTED_KEY]) ? root[TRUSTED_KEY] : [];
+  const want = kitTrustedCommandPatterns();
+
+  // array-UNION: keep the user's entries (and order), append only the kit
+  // patterns not already present. Idempotent: if all ours are present, no write.
+  const missing = want.filter((p) => !existing.includes(p));
+  if (missing.length === 0) return { action: 'skipped', changed: false, path };
+
+  const next = { ...root, [TRUSTED_KEY]: [...existing, ...missing] };
+  atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
+  return { action: 'installed', changed: true, path, created: !fileExists };
+}
+
+export function uninstallKiroTrustedCommands({ projectRoot } = {}) {
+  if (!projectRoot) throw new Error('uninstallKiroTrustedCommands: projectRoot is required');
+  const path = join(projectRoot, ...SETTINGS_PATH);
+  if (!existsSync(path)) return { action: 'noop', changed: false, path };
+
+  const { root, error } = readSettings(path);
+  // A corrupt file on uninstall: leave it alone (don't error-out the whole
+  // uninstall; just report no change for this leg).
+  if (error || !Array.isArray(root[TRUSTED_KEY])) return { action: 'noop', changed: false, path };
+
+  // Ownership is by exact-string membership (skill-review M1): if a user had
+  // MANUALLY added a pattern byte-identical to one of ours, uninstall removes it
+  // too — we can't distinguish who added an identical string without a separate
+  // ownership-marker array, which would be over-engineering for this surface.
+  // Collision is near-zero (our patterns are kit-specific: `cmd.exe /c cmk hook *`).
+  const ours = new Set(kitTrustedCommandPatterns());
+  const kept = root[TRUSTED_KEY].filter((c) => !ours.has(c));
+  if (kept.length === root[TRUSTED_KEY].length) return { action: 'noop', changed: false, path };
+
+  const next = { ...root };
+  if (kept.length === 0) {
+    // prune an emptied key — no orphan empty array left behind.
+    delete next[TRUSTED_KEY];
+  } else {
+    next[TRUSTED_KEY] = kept;
+  }
+  atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
+  return { action: 'uninstalled', changed: true, path };
+}