threadnote 0.7.6 → 0.7.7

package/README.md

@@ -43,7 +43,8 @@ which memory to keep/update, which old handoffs to archive, and which exact dupl
 
 **Still working on the same issue?**
 Use `threadnote remember --replace <uri>` or `threadnote handoff --replace <uri>` to keep one current-state memory fresh
-instead of accumulating near-duplicate progress notes.
+instead of accumulating near-duplicate progress notes. Replacing a shared `durable/` URI updates that shared memory in
+place and pushes the shared repo, so you do not need a separate `share publish` step.
 
 ## Memory Lifecycle
 
@@ -347,8 +348,9 @@ This is it! Start working with your agents as usual. The agent will automaticall
   reusable workflow guidance. Use `seed-skills --native` only after configuring a working VLM provider.
 - `mcp-install codex|claude|cursor|copilot`: installs or prints OpenViking MCP configuration for Codex, Claude, Cursor,
   or GitHub Copilot in VS Code.
-- `remember`: stores a durable memory. Use `--replace <uri>` to store an updated memory and remove a superseded one
-  after the new memory succeeds. Use `--kind`, `--project`, and `--topic` to store lifecycle-aware current knowledge.
+- `remember`: stores a durable memory. Use `--replace <uri>` to store an updated memory and remove a superseded personal
+  memory after the new memory succeeds; if `<uri>` is shared, Threadnote updates that shared memory in place and pushes
+  the shared repo. Use `--kind`, `--project`, and `--topic` to store lifecycle-aware current knowledge.
 - `migrate-memories`: migrates legacy session-only `MEMORY` and `HANDOFF` records into durable memory files. Run
   `migrate-memories --dry-run` first; use `--all-accounts` when importing from older local OpenViking accounts.
 - `migrate-lifecycle`: moves clear legacy handoff memories from the old events path into archived lifecycle handoff

package/dist/mcp_server.cjs

@@ -34726,7 +34726,35 @@ function workfileToVikingUri(config2, team, filePath) {
   return `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config2, uri) {
-  return uri.startsWith(`viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`);
+  return sharedTeamNameForUri(config2, uri) !== void 0;
+}
+function sharedTeamNameForUri(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team] = uri.slice(prefix.length).split("/");
+  return team || void 0;
+}
+function sharedMemoryUriParts(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team, kind, scope, project, ...topicParts] = uri.slice(prefix.length).split("/");
+  if (!team) {
+    return void 0;
+  }
+  if (kind !== "durable" || scope !== "projects" || !project || topicParts.length === 0) {
+    return { team };
+  }
+  const topicPath = topicParts.join("/");
+  return {
+    kind,
+    project,
+    team,
+    topic: topicPath.endsWith(".md") ? topicPath.slice(0, -".md".length) : topicPath
+  };
 }
 function sharedUriFor(config2, personalUri, team) {
   const prefix = `viking://user/${uriSegment(config2.user)}/memories/`;
@@ -35547,7 +35575,9 @@ function registerStoreTool(server, config2, name, description) {
       inputSchema: {
         kind: external_exports.enum(["durable", "handoff", "incident", "preference", "smoke"]).optional().describe("Memory lifecycle kind; durable facts and handoffs are most common"),
         project: external_exports.string().optional().describe("Project/repo namespace, for example threadnote or mobile-native"),
-        replaceUri: external_exports.string().optional().describe("Optional viking:// memory URI to forget after the new memory is safely stored"),
+        replaceUri: external_exports.string().optional().describe(
+          "Optional viking:// memory URI to replace. Shared URIs are updated in place and pushed; personal URIs are forgotten after the replacement is safely stored."
+        ),
         text: external_exports.string().optional().describe("Required memory text to store"),
         sourceAgentClient: external_exports.string().optional().describe("Originating client, for example cursor, copilot, codex, or claude"),
         status: external_exports.enum(["active", "archived", "superseded"]).optional().describe("Memory lifecycle status"),
@@ -35866,6 +35896,9 @@ async function readTextIfExists(path) {
 async function writeDurableMemory(config2, params) {
   try {
     const ov = await requiredOpenVikingCli2();
+    if (params.replaceUri && isInSharedNamespace(config2, params.replaceUri)) {
+      return await writeSharedMemoryReplacement(config2, ov, params, params.replaceUri);
+    }
     const directoryUri = memoryDirectoryUri(config2, params.metadata);
     await ensureMemoryDirectory(ov, config2, directoryUri);
     const candidateMetadata = { ...params.metadata, supersedes: params.replaceUri };
@@ -35906,6 +35939,40 @@ async function writeDurableMemory(config2, params) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
+  if (params.metadata.kind !== "durable") {
+    return argumentError("Shared memory replacement only supports durable memories.");
+  }
+  const teamName = sharedTeamNameForUri(config2, targetUri);
+  if (!teamName) {
+    return argumentError(`Memory ${targetUri} is not in the shared namespace.`);
+  }
+  const resolved = await resolveTeam(config2, teamName);
+  const inferred = sharedMemoryUriParts(config2, targetUri);
+  const metadata = {
+    ...params.metadata,
+    project: params.metadata.project ?? inferred?.project,
+    topic: params.metadata.topic ?? inferred?.topic
+  };
+  const rawMemory = formatMemoryDocument2("MEMORY", metadata, params.bodyText);
+  const scrub = applyScrubber(stripPersonalProvenance(rawMemory), { redact: false });
+  if (scrub.blocker) {
+    return argumentError(
+      `Refusing to update shared memory ${targetUri}: possible ${scrub.blocker}. Strip the sensitive value first.`
+    );
+  }
+  await ensureSharedDirectoryChain(config2, ov, targetUri, false, { quiet: true });
+  await writeMemoryFile(config2, ov, targetUri, scrub.cleaned, "replace", false, { quiet: true });
+  const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
+  const messages = [`Updated shared memory: ${targetUri}`];
+  for (const redaction of scrub.redactions) {
+    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
+  }
+  messages.push(
+    ...await gitPublishWorkflow(resolved.config.worktree, relativePath, `share: update ${relativePath}`, true)
+  );
+  return { content: [{ type: "text", text: messages.join("\n") }] };
+}
 async function runOpenVikingWriteWithRetry(ov, config2, memoryUri, args) {
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });

package/dist/threadnote.cjs

@@ -8510,7 +8510,35 @@ function workfileToVikingUri(config, team, filePath) {
   return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config, uri) {
-  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`);
+  return sharedTeamNameForUri(config, uri) !== void 0;
+}
+function sharedTeamNameForUri(config, uri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team] = uri.slice(prefix.length).split("/");
+  return team || void 0;
+}
+function sharedMemoryUriParts(config, uri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team, kind, scope, project, ...topicParts] = uri.slice(prefix.length).split("/");
+  if (!team) {
+    return void 0;
+  }
+  if (kind !== "durable" || scope !== "projects" || !project || topicParts.length === 0) {
+    return { team };
+  }
+  const topicPath = topicParts.join("/");
+  return {
+    kind,
+    project,
+    team,
+    topic: topicPath.endsWith(".md") ? topicPath.slice(0, -".md".length) : topicPath
+  };
 }
 function isInTeamNamespace(config, uri, team) {
   return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`);
@@ -9434,6 +9462,10 @@ async function storeMemory(config, options) {
     assertVikingUri(options.replaceUri);
   }
   const ov = await openVikingCliForMode(options.dryRun);
+  if (options.replaceUri && isInSharedNamespace(config, options.replaceUri)) {
+    await storeSharedMemoryReplacement(config, ov, options, options.replaceUri);
+    return;
+  }
   const memoryPath = (0, import_node_path6.join)(config.agentContextHome, "last-memory.txt");
   const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
   const candidateMemory = formatMemoryDocument2(options.title, candidateMetadata, options.bodyText);
@@ -9484,6 +9516,49 @@ async function storeMemory(config, options) {
     console.log(`Updated existing memory in place: ${memoryUri}`);
   }
 }
+async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
+  if (options.metadata.kind !== "durable") {
+    throw new Error("Shared memory replacement only supports durable memories.");
+  }
+  const teamName = sharedTeamNameForUri(config, targetUri);
+  if (!teamName) {
+    throw new Error(`Memory ${targetUri} is not in the shared namespace.`);
+  }
+  const team = await resolveTeam(config, teamName);
+  const inferred = sharedMemoryUriParts(config, targetUri);
+  const metadata = {
+    ...options.metadata,
+    project: options.metadata.project ?? inferred?.project,
+    topic: options.metadata.topic ?? inferred?.topic
+  };
+  const rawMemory = formatMemoryDocument2(options.title, metadata, options.bodyText);
+  const scrub = applyScrubber(stripPersonalProvenance(rawMemory), { redact: false });
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to update shared memory ${targetUri}: possible ${scrub.blocker}. Strip the sensitive value first.`
+    );
+  }
+  const memory = scrub.cleaned;
+  const relativePath = vikingUriToWorktreeRelative(config, targetUri, team.name);
+  if (options.dryRun) {
+    console.log(memory);
+    console.log("\nWould run:");
+  }
+  await ensureSharedDirectoryChain(config, ov, targetUri, options.dryRun);
+  await writeMemoryFile(config, ov, targetUri, memory, "replace", options.dryRun);
+  const git = await requiredExecutable("git");
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "add", "--", relativePath]);
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "commit", "-m", `share: update ${relativePath}`], {
+    allowFailure: true
+  });
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "push", DEFAULT_GIT_REMOTE_NAME], {
+    allowFailure: true
+  });
+  for (const redaction of scrub.redactions) {
+    console.log(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
+  }
+  console.log(`Updated shared memory: ${targetUri}`);
+}
 async function writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode) {
   const args = withIdentity(config, [
     "write",

package/docs/agent-instructions.md

@@ -73,14 +73,17 @@ For branch feature work, prefer two stable memories with the same project and to
 - `kind: handoff` for current status, files touched, tests, blockers, and next step.
 
 If a durable feature memory already exists, update it in place with the same project/topic or with `--replace <uri>` /
-`replaceUri`. Avoid creating a new timestamped durable memory for every small progress note.
+`replaceUri`. When `replaceUri` points at a shared `durable/` URI, Threadnote updates that shared memory in place and
+pushes the shared repo; do not create a personal replacement and then run `share_publish` again. Avoid creating a new
+timestamped durable memory for every small progress note.
 
 ## Memory Compaction
 
 When working on the same active issue, prefer keeping one current-state memory updated instead of creating many small
 progress memories. If an existing memory is clearly the current state for the issue, store the updated version with
 `remember_context({"text":"...","replaceUri":"<uri>"})`, `threadnote remember --replace <uri>`, or
-`threadnote handoff --replace <uri>` so the old memory is removed only after the replacement is stored.
+`threadnote handoff --replace <uri>` so the old personal memory is removed only after the replacement is stored. Shared
+`durable/` replacements are updated in place and pushed instead.
 
 When the issue has a stable name, prefer project/topic storage over timestamped memories:
 

package/docs/index.html

@@ -1341,7 +1341,7 @@ threadnote remember \
               <p class="muted" style="font-size: 0.9rem; margin-top: 0.6rem">
                 Refuses to publish if the memory matches secret patterns (PEM, <code>sk-</code>, <code>gh*_</code>,
                 <code>github_pat_</code>, <code>glpat-</code>, JWTs, AWS keys, Slack tokens). Refuses to silently
-                overwrite an existing shared URI.
+                overwrite an existing shared URI; update shared memories with <code>remember --replace</code>.
               </p>
             </div>
 

package/docs/share.md

@@ -71,6 +71,21 @@ lines from the memory's header block. Those pointers only resolve on the
 publisher's machine — teammates pull via git and cannot dereference them — so
 keeping them would just leak local-only provenance into team git history.
 
+To update an existing shared durable memory, replace the shared URI directly:
+
+```bash
+threadnote remember \
+  --replace viking://user/you/memories/shared/default/durable/projects/foo/bar.md \
+  --project foo \
+  --topic bar \
+  --text "Updated shared knowledge."
+```
+
+For MCP, pass the same shared URI as `replaceUri` to `remember_context`.
+Threadnote rewrites the shared memory in place, strips local-only provenance
+headers, commits, and pushes the shared repo. You do not need to store a
+personal replacement and run `share publish` again.
+
 ### Keep teammates' updates current
 
 Threadnote does a periodic background `git fetch` for configured share teams.
@@ -155,7 +170,9 @@ otherwise unpublished work is lost.
   keep both, copy the memory to a new URI first (`ov read` then
   `threadnote remember`).
 - `share publish` refuses to overwrite an existing shared memory at the same
-  URI; forget the existing shared copy first or pick a different topic name.
+  URI; use `threadnote remember --replace <shared-uri>` or
+  `remember_context({replaceUri:"<shared-uri>"})` for updates, or pick a
+  different topic name.
 
 ## Conflict resolution
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",