@plinth-music/cli 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 Notable changes to `@plinth-music/cli`. Grouped by what a user notices, not by PR.
 
+## 0.15.0 - 2026-08-31
+
+One code PR since `0.14.0` (`v0.14.0..f293dd0`, #153). A minor because sync gains a
+refusal: there is now a case where Plinth declines to upload a file.
+
+- ⚠️ **A memory file that looks like it carries a credential is held back instead of
+  synced.** The file is never modified and nothing is lost - it stays on your machine
+  until you decide. Plinth is not approved to store credentials, so it will not take one
+  without you saying so explicitly. Sharing one with your own team is not the problem and
+  the message does not treat it as one.
+- **You clear it in one of two ways:** take the line out, or mark it `plinth-allow-secret`
+  on the line itself. The marker sits in the file where your teammates can see it, so an
+  allow is a decision on the record rather than a setting nobody can find.
+- **`plinth status` names the file, the line and the remedy**, and the daemon logs it. The
+  finding is local only - it is never posted to your team, because "there is a key at line
+  42 of workspace-memory.md" is a pointer straight at the key.
+- **It matches vendor-prefixed shapes only** (AWS, GitHub, Slack, Stripe, Google,
+  OpenAI/Anthropic, private-key blocks, JWTs, signed URLs). Recall is deliberately low:
+  this stops a recognisable token going up by accident, and it is not a guarantee against
+  a determined leak. Measured against every real memory file on the first workspace
+  (81,897 bytes across 12 files): no false positives.
+- Covers `workspace-memory.md`, `user-memory.md` and `artists/<slug>/memory.md`.
+
+⚠️ **The check runs under the daemon only.** `plinth sync` is pull-only and never scans, so
+a workspace with no daemon running is not protected.
+
+The desktop app pins `0.14.0` exact and picks none of this up until its own release repins.
+
 ## 0.14.0 - 2026-08-31
 
 One code PR since `0.13.0` (`v0.13.0..50ab852`, #150; #149 was 0.13.0's own History row).

package/dist/build-stamp.json

@@ -1,5 +1,5 @@
 {
-  "sha": "4746a5177bbf94305bc067f283c50818cd24b045",
+  "sha": "71f22efc85823f5d401c67709224d315e7504974",
   "dirty": false,
-  "built_at": "2026-08-31T14:55:47.045Z"
+  "built_at": "2026-08-31T19:26:38.895Z"
 }

package/dist/cli.js

@@ -7584,7 +7584,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.14.0",
+  version: "0.15.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -30541,6 +30541,108 @@ function calendarNoticeLine(kind) {
   return `[${token} reason=${kind}]`;
 }
 
+// src/lib/context/secret-scan.ts
+var HOLD_ON_SECRET = true;
+var ALLOW_SECRET_MARKER = "plinth-allow-secret";
+var SECRET_HELD_REASON = "possible_secret";
+var SECRET_RULES = [
+  {
+    id: "aws-access-key-id",
+    label: "an AWS access key id",
+    pattern: /\b(?:AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{16}\b/
+  },
+  {
+    id: "github-token",
+    label: "a GitHub token",
+    pattern: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/
+  },
+  {
+    id: "slack-token",
+    label: "a Slack token",
+    pattern: /\bxox[baprse]-[0-9A-Za-z-]{10,}/
+  },
+  {
+    id: "google-api-key",
+    label: "a Google API key",
+    pattern: /\bAIza[0-9A-Za-z_-]{35}\b/
+  },
+  {
+    id: "anthropic-openai-key",
+    label: "an Anthropic or OpenAI API key",
+    pattern: /\bsk-(?:ant-|proj-)?(?=[A-Za-z0-9_-]*[A-Z])(?=[A-Za-z0-9_-]*[0-9])[A-Za-z0-9_-]{20,}/
+  },
+  {
+    id: "stripe-secret-key",
+    label: "a Stripe secret key",
+    pattern: /\b[sr]k_live_[0-9A-Za-z]{16,}\b/
+  },
+  {
+    id: "private-key-block",
+    label: "a private key block",
+    pattern: /-----BEGIN(?: [A-Z]+)* PRIVATE KEY-----/
+  },
+  {
+    id: "jwt",
+    label: "a JSON Web Token",
+    pattern: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/
+  },
+  {
+    id: "signed-url",
+    label: "a signed URL carrying its own credential",
+    pattern: /[?&](?:X-Amz-Signature|X-Goog-Signature|Signature|sig)=[A-Za-z0-9%._-]{16,}/i
+  }
+];
+function redactMatch(match) {
+  const prefix = match.length >= 12 ? match.slice(0, 4) : "";
+  return `${prefix}… ${match.length} characters`;
+}
+function lineIsAllowed(line) {
+  return line.toLowerCase().includes(ALLOW_SECRET_MARKER);
+}
+function scanForSecrets(raw) {
+  const findings = [];
+  const lines = raw.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (lineIsAllowed(line))
+      continue;
+    for (const rule of SECRET_RULES) {
+      const m = rule.pattern.exec(line);
+      if (!m)
+        continue;
+      findings.push({
+        line: i + 1,
+        ruleId: rule.id,
+        label: rule.label,
+        excerpt: redactMatch(m[0])
+      });
+      break;
+    }
+  }
+  return findings;
+}
+var MAX_NAMED_SECRET_FINDINGS = 3;
+function secretHoldReason(findings, hold = HOLD_ON_SECRET) {
+  const named = findings.slice(0, MAX_NAMED_SECRET_FINDINGS);
+  const rest = findings.length - named.length;
+  const detail = named.map((f) => `line ${f.line} looks like ${f.label} (${f.excerpt})`).join("; ");
+  const more = rest > 0 ? `, and ${rest} more` : "";
+  return `${detail.charAt(0).toUpperCase()}${detail.slice(1)}${more}. ` + `Plinth is not approved to store credentials yet, so ` + (hold ? `this file stays on this machine until you say otherwise. ` + `Remove the value, or add ${ALLOW_SECRET_MARKER} to that line to ` + `store it anyway. ` : `it has already reached Plinth on this sync. Rotate it if it is ` + `live, then remove the value — or add ${ALLOW_SECRET_MARKER} to that ` + `line to stop being told. `) + `Nothing is changed in your file either way.`;
+}
+function secretHoldSummary(findings) {
+  const n = findings.length;
+  return `${n} possible credential${n === 1 ? "" : "s"} found`;
+}
+function secretHoldMessage(filename, findings, hold = HOLD_ON_SECRET) {
+  const verb = hold ? "was not synced" : "was synced";
+  return `${filename} ${verb}. ${secretHoldReason(findings, hold)}`;
+}
+function secretHoldRecord(findings, hold = HOLD_ON_SECRET) {
+  const verdict = hold ? "so this file was not synced" : "and it synced anyway";
+  return `${secretHoldSummary(findings)}, ${verdict}. ${secretHoldReason(findings, hold)}`;
+}
+
 // src/lib/rejected.ts
 var PERMANENT_REJECT_REASONS = new Set(["bad_request", "invalid_frontmatter"]);
 function isPermanentReject(err) {
@@ -30690,6 +30792,45 @@ function clearReportedSafeFileRejected(state, relPath) {
     return state;
   return clearFileRejected(state, relPath);
 }
+function recordMemorySecretHeld(args) {
+  let path3;
+  try {
+    path3 = relative3(workspaceMirrorPath(args.workspaceSlug), args.absolutePath);
+  } catch {
+    path3 = args.absolutePath;
+  }
+  const withoutStale = removeUnsynced(args.state, "entity", path3).state;
+  return persist(withoutStale, upsertRejected(withoutStale, {
+    target: "entity",
+    op: "upsert",
+    path: path3,
+    reason: SECRET_HELD_REASON,
+    message: args.record,
+    rejected_at: args.now().toISOString()
+  }));
+}
+function secretHoldRecordFor(state, workspaceSlug, absolutePath) {
+  let path3;
+  try {
+    path3 = relative3(workspaceMirrorPath(workspaceSlug), absolutePath);
+  } catch {
+    path3 = absolutePath;
+  }
+  return (state.rejected ?? []).find((o) => o.target === "entity" && o.path === path3 && o.reason === SECRET_HELD_REASON);
+}
+function clearMemorySecretHeld(state, workspaceSlug, absolutePath) {
+  let path3;
+  try {
+    path3 = relative3(workspaceMirrorPath(workspaceSlug), absolutePath);
+  } catch {
+    path3 = absolutePath;
+  }
+  const list = state.rejected ?? [];
+  const next = list.filter((o) => !(o.target === "entity" && o.path === path3 && o.reason === SECRET_HELD_REASON));
+  if (next.length === list.length)
+    return state;
+  return commitState(state, { ...state, rejected: next });
+}
 
 // src/lib/context/workspace-claude-md.ts
 var EXTRACTED_TEXT_DIR = extractedTextRelPath("x").replace(/x\.md$/, "");
@@ -36186,6 +36327,41 @@ async function reconcileFilesSubtree(args) {
 
 // src/lib/artist-memory/sync.ts
 import { relative as relative9 } from "node:path";
+
+// src/lib/context/secret-gate.ts
+function applySecretGate(args) {
+  const hold = args.hold ?? HOLD_ON_SECRET;
+  const release = () => ({
+    state: clearMemorySecretHeld(args.state, args.workspaceSlug, args.absolutePath),
+    held: false,
+    findings: []
+  });
+  if (args.alreadyAcked)
+    return release();
+  const findings = scanForSecrets(args.body);
+  if (findings.length === 0)
+    return release();
+  const record2 = secretHoldRecord(findings, hold);
+  const standing = secretHoldRecordFor(args.state, args.workspaceSlug, args.absolutePath);
+  if (standing?.message === record2) {
+    return { state: args.state, held: hold, findings };
+  }
+  args.output?.warn(secretHoldMessage(args.filename, findings, hold));
+  args.output?.log(`[${args.logTag}_SECRET_HELD ws=${args.workspaceSlug} ` + `findings=${findings.length} held=${hold}]`);
+  return {
+    state: recordMemorySecretHeld({
+      state: args.state,
+      workspaceSlug: args.workspaceSlug,
+      absolutePath: args.absolutePath,
+      record: record2,
+      now: args.now
+    }),
+    held: hold,
+    findings
+  };
+}
+
+// src/lib/artist-memory/sync.ts
 var MAX_MEMORY_PUSH_ATTEMPTS = 3;
 var ENTITY_TYPE = "artists";
 function conflictSlug(slug) {
@@ -36293,11 +36469,26 @@ async function pushArtistMemory(args) {
   }
   const localHash = stableHash(local);
   const runPatch = async () => {
-    const base2 = args.mutex ? loadState(workspaceSlug) : state;
+    let base2 = args.mutex ? loadState(workspaceSlug) : state;
     const entry2 = getEntryBySlug(base2, ENTITY_TYPE, slug);
     if (!entry2)
       return { state: base2, outcome: { kind: "ignored", slug } };
-    if (entry2.memory_hash === localHash) {
+    const alreadyAcked = entry2.memory_hash === localHash;
+    const gate = applySecretGate({
+      state: base2,
+      workspaceSlug,
+      absolutePath: artistMemoryFilePath(workspaceSlug, slug),
+      filename: `artists/${slug}/${ARTIST_MEMORY_ANCHOR}`,
+      body: local,
+      alreadyAcked,
+      output,
+      logTag: "ARTIST_MEMORY",
+      now
+    });
+    base2 = gate.state;
+    if (gate.held)
+      return { state: base2, outcome: { kind: "secret_held", slug } };
+    if (alreadyAcked) {
       return { state: base2, outcome: { kind: "noop", slug } };
     }
     const acked = entry2.memory_hash;
@@ -38581,11 +38772,26 @@ async function pushWorkspaceMemory(args) {
   }
   const localHash = stableHash(local);
   const acked = getWorkspaceMemoryState(state);
-  if (acked && acked.body_hash === localHash) {
-    return { state, outcome: { kind: "noop" } };
+  const alreadyAcked = Boolean(acked && acked.body_hash === localHash);
+  const gate = applySecretGate({
+    state,
+    workspaceSlug,
+    absolutePath: contextFilePath(workspaceSlug, WORKSPACE_MEMORY_FILENAME),
+    filename: WORKSPACE_MEMORY_FILENAME,
+    body: local,
+    alreadyAcked,
+    output,
+    logTag: "WORKSPACE_MEMORY",
+    now
+  });
+  const gated = gate.state;
+  if (gate.held)
+    return { state: gated, outcome: { kind: "secret_held" } };
+  if (alreadyAcked) {
+    return { state: gated, outcome: { kind: "noop" } };
   }
   if (extractWorkspaceMemory(local) === null && (acked?.updated_at ?? null) === null) {
-    const next2 = persistMemory(state, { body_hash: localHash, updated_at: null });
+    const next2 = persistMemory(gated, { body_hash: localHash, updated_at: null });
     return { state: next2, outcome: { kind: "noop" } };
   }
   const res = await putWorkspaceMemory({
@@ -38596,7 +38802,7 @@ async function pushWorkspaceMemory(args) {
     fetchImpl
   });
   if (res.ok) {
-    const next2 = persistMemory(state, {
+    const next2 = persistMemory(gated, {
       body_hash: localHash,
       updated_at: res.row.updated_at
     });
@@ -38605,7 +38811,7 @@ async function pushWorkspaceMemory(args) {
   }
   if (res.code === 413) {
     output?.warn(`${WORKSPACE_MEMORY_FILENAME} is over the ${Math.round(MAX_WORKSPACE_MEMORY_BYTES / 1024)}KB cap — not synced.`);
-    return { state, outcome: { kind: "over_cap" } };
+    return { state: gated, outcome: { kind: "over_cap" } };
   }
   {
     const probe2 = await getWorkspaceMemory({ baseUrl, pat, fetchImpl });
@@ -38618,7 +38824,7 @@ async function pushWorkspaceMemory(args) {
         fetchImpl
       });
       if (retry.ok) {
-        const next2 = persistMemory(state, {
+        const next2 = persistMemory(gated, {
           body_hash: localHash,
           updated_at: retry.row.updated_at
         });
@@ -38627,7 +38833,7 @@ async function pushWorkspaceMemory(args) {
       }
       if (retry.code === 413) {
         output?.warn(`${WORKSPACE_MEMORY_FILENAME} is over the ${Math.round(MAX_WORKSPACE_MEMORY_BYTES / 1024)}KB cap — not synced.`);
-        return { state, outcome: { kind: "over_cap" } };
+        return { state: gated, outcome: { kind: "over_cap" } };
       }
     }
   }
@@ -38639,7 +38845,7 @@ async function pushWorkspaceMemory(args) {
     contents: local,
     side: "local"
   });
-  const next = await restoreFromCloud2(args);
+  const next = await restoreFromCloud2({ ...args, state: gated });
   output?.warn(`Conflict on ${WORKSPACE_MEMORY_FILENAME} -> stashed local edit to ${stashPath} (cloud-wins; cloud copy restored).`);
   return { state: next, outcome: { kind: "conflict", stashPath } };
 }
@@ -38851,11 +39057,29 @@ async function pushSingleton(descriptor, args) {
   }
   const localHash = stableHash(local);
   const acked = descriptor.getState(state);
-  if (acked && acked.body_hash === localHash) {
-    return { state, outcome: { kind: "noop" } };
+  const alreadyAcked = Boolean(acked && acked.body_hash === localHash);
+  let gated = state;
+  if (descriptor.secretScanned) {
+    const gate = applySecretGate({
+      state,
+      workspaceSlug,
+      absolutePath: filePath(descriptor, workspaceSlug),
+      filename: descriptor.filename,
+      body: local,
+      alreadyAcked,
+      output,
+      logTag: descriptor.logTag,
+      now
+    });
+    gated = gate.state;
+    if (gate.held)
+      return { state: gated, outcome: { kind: "secret_held" } };
+  }
+  if (alreadyAcked) {
+    return { state: gated, outcome: { kind: "noop" } };
   }
   if (descriptor.extractActive(local) === null && (acked?.updated_at ?? null) === null) {
-    const next2 = persist2(descriptor, state, { body_hash: localHash, updated_at: null });
+    const next2 = persist2(descriptor, gated, { body_hash: localHash, updated_at: null });
     return { state: next2, outcome: { kind: "noop" } };
   }
   const res = await descriptor.api.put({
@@ -38866,13 +39090,13 @@ async function pushSingleton(descriptor, args) {
     fetchImpl
   });
   if (res.ok) {
-    const next2 = persist2(descriptor, state, ackedFrom(res.row, localHash));
+    const next2 = persist2(descriptor, gated, ackedFrom(res.row, localHash));
     output?.log(`[${descriptor.logTag}_PUT ws=${workspaceSlug} is_empty=${res.row.is_empty}` + `${res.row.status ? ` status=${res.row.status}` : ""}]`);
     return { state: next2, outcome: { kind: "pushed" } };
   }
   if (res.code === 413) {
     output?.warn(`${descriptor.filename} is over the ${Math.round(descriptor.maxBytes / 1024)}KB cap — not synced.`);
-    return { state, outcome: { kind: "over_cap" } };
+    return { state: gated, outcome: { kind: "over_cap" } };
   }
   {
     const probe2 = await descriptor.api.get({ baseUrl, pat, fetchImpl });
@@ -38885,13 +39109,13 @@ async function pushSingleton(descriptor, args) {
         fetchImpl
       });
       if (retry.ok) {
-        const next2 = persist2(descriptor, state, ackedFrom(retry.row, localHash));
+        const next2 = persist2(descriptor, gated, ackedFrom(retry.row, localHash));
         output?.log(`[${descriptor.logTag}_PUT ws=${workspaceSlug} is_empty=${retry.row.is_empty}` + `${retry.row.status ? ` status=${retry.row.status}` : ""}]`);
         return { state: next2, outcome: { kind: "pushed" } };
       }
       if (retry.code === 413) {
         output?.warn(`${descriptor.filename} is over the ${Math.round(descriptor.maxBytes / 1024)}KB cap — not synced.`);
-        return { state, outcome: { kind: "over_cap" } };
+        return { state: gated, outcome: { kind: "over_cap" } };
       }
     }
   }
@@ -38903,7 +39127,7 @@ async function pushSingleton(descriptor, args) {
     contents: local,
     side: "local"
   });
-  const next = await restoreFromCloud3(descriptor, args);
+  const next = await restoreFromCloud3(descriptor, { ...args, state: gated });
   output?.warn(`Conflict on ${descriptor.filename} -> stashed local edit to ${stashPath} (cloud-wins; cloud copy restored).`);
   return { state: next, outcome: { kind: "conflict", stashPath } };
 }
@@ -38925,6 +39149,7 @@ var USER_MEMORY_DESCRIPTOR = {
   mutexKey: USER_MEMORY_MUTEX_KEY,
   logTag: "USER_MEMORY",
   maxBytes: MAX_USER_MEMORY_BYTES,
+  secretScanned: true,
   extractActive: extractUserMemory,
   getState: getUserMemoryState,
   setState: setUserMemoryState,
@@ -38957,6 +39182,7 @@ var VOICE_DESCRIPTOR = {
   mutexKey: VOICE_MUTEX_KEY,
   logTag: "VOICE",
   maxBytes: MAX_USER_VOICE_BYTES,
+  secretScanned: false,
   extractActive: extractVoiceProfile,
   getState: getUserVoiceState,
   setState: setUserVoiceState,
@@ -42127,6 +42353,7 @@ function reportWorkspaceMemoryOutcome(spinner, slug, state, outcome) {
       spinner.warn(`Conflict on ${WORKSPACE_MEMORY_FILENAME} → ${outcome.stashPath} (cloud-wins; local copy stashed)`);
       spinner.update(`Watching ${slug} · ${summary}`);
       return;
+    case "secret_held":
     case "over_cap":
     case "noop":
       return;
@@ -42143,6 +42370,7 @@ function reportUserMemoryOutcome(spinner, slug, state, outcome) {
       spinner.warn(`Conflict on ${USER_MEMORY_FILENAME} → ${outcome.stashPath} (cloud-wins; local copy stashed)`);
       spinner.update(`Watching ${slug} · ${summary}`);
       return;
+    case "secret_held":
     case "over_cap":
     case "noop":
       return;
@@ -42195,6 +42423,7 @@ function reportArtistMemoryOutcome(spinner, slug, state, outcome) {
       spinner.warn(`Conflict on artists/${outcome.slug}/memory.md → ${outcome.stashPath} (cloud-wins; local copy stashed)`);
       spinner.update(`Watching ${slug} · ${summary}`);
       return;
+    case "secret_held":
     case "not_found":
     case "noop":
     case "ignored":
@@ -42541,6 +42770,8 @@ function scanPendingWrites(args) {
       continue;
     if (Buffer.byteLength(local) > lane.maxBytes)
       continue;
+    if (reported.entities.has(lane.filename))
+      continue;
     const localHash = stableHash(local);
     if (lane.acked && lane.acked.body_hash === localHash)
       continue;
@@ -42566,6 +42797,8 @@ function scanPendingWrites(args) {
       continue;
     if (isPristineMemoryStub(local))
       continue;
+    if (reported.entities.has(`artists/${entry2.slug}/memory.md`))
+      continue;
     const localHash = stableHash(local);
     if (entry2.memory_hash === localHash)
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plinth-music/cli",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Plinth capstone sync daemon and CLI",
   "type": "module",
   "private": false,