threadnote 0.6.3 → 0.7.1

package/docs/agent-instructions.md

@@ -118,8 +118,9 @@ The MCP tool `share_publish` runs the same scrubber as the CLI and refuses to pu
 patterns (PEM private keys, `sk-...`, `gh[pousr]_...`, `Bearer ...`, `AKIA...`, `xox[abprs]-...`). It is a destructive
 operation: it removes the personal copy after the shared copy is committed.
 
-When a teammate's memory needs to come into your own working set, run `threadnote share sync` (no MCP equivalent yet) to
-pull and reindex.
+Incoming shared memories are normally fetched and synced automatically before MCP `recall_context` / `read_context` and
+CLI `threadnote recall` / `threadnote read` return. If automatic sync reports a dirty worktree, a conflict, or another
+git issue, run `threadnote share sync` after resolving the local state to pull, reindex, and push explicitly.
 
 ```
 # MCP call shape

package/docs/index.html

@@ -1346,17 +1346,19 @@ threadnote remember \
             </div>
 
             <div class="reveal">
-              <h3>Pull teammates' updates</h3>
+              <h3>Teammates' updates auto-sync</h3>
               <div class="terminal">
                 <div class="terminal-bar"><span></span><span></span><span></span></div>
-                <pre><span class="cmd">$ threadnote share sync</span>
-<span class="out">git pull --rebase</span>
-<span class="out">Reindexed 3 file change(s) into OpenViking.</span>
+                <pre><span class="cmd">$ recall_context({query: "shared feature memory"})</span>
+<span class="out">→ viking://user/you/memories/shared/default/durable/projects/&lt;p&gt;/&lt;t&gt;.md</span>
+<span class="out">Auto-synced shared memories: default</span>
 <span class="out-strong">Recall now finds new shared memories alongside personal.</span></pre>
               </div>
               <p class="muted" style="font-size: 0.9rem; margin-top: 0.6rem">
-                Recall sees the shared subtree by default. Both semantic search and exact-token grep cover
-                <code>viking://user/&lt;you&gt;/memories/shared/&lt;team&gt;/...</code> alongside your personal memories.
+                The MCP server periodically fetches share repos and syncs clean incoming updates before
+                <code>recall_context</code> or <code>read_context</code> returns. Manual
+                <code>threadnote share sync</code> is still there for dirty worktrees, conflicts, explicit pushes, or
+                immediate operator control.
               </p>
             </div>
 
@@ -1430,8 +1432,8 @@ threadnote remember \
               <pre class="v-response">Published → shared/&lt;team&gt;/durable/projects/&lt;repo&gt;/&lt;feature&gt;.md
 git push: ok</pre>
               <div class="v-answer">
-                The memory lands in the team git repo. A teammate's next <code>share sync</code> pulls it; their
-                recall surfaces it alongside their own memories — no DM forwarding, no PDF dumping.
+                The memory lands in the team git repo. Their agent's next recall/read auto-syncs clean incoming changes
+                and surfaces it alongside their own memories — no DM forwarding, no PDF dumping.
               </div>
             </div>
 

package/docs/share.md

@@ -71,7 +71,18 @@ 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.
 
-### Pull teammates' updates
+### Keep teammates' updates current
+
+Threadnote does a periodic background `git fetch` for configured share teams.
+When an agent calls MCP `recall_context` / `read_context`, or the CLI
+`threadnote recall` / `threadnote read`, Threadnote checks whether a shared
+repo is behind. If it is, Threadnote rebases the clean worktree, reindexes the
+pulled markdown files into OpenViking, and then returns the requested
+recall/read result. Sync errors degrade to warnings so memory access still
+works with the best local data available.
+
+Manual sync remains useful when you want to publish local edits, clear a dirty
+shared worktree, resolve git conflicts, or force a sync immediately:
 
 ```bash
 threadnote share sync                  # default team
@@ -82,7 +93,9 @@ threadnote share sync --no-push        # pull only
 `share sync` will auto-commit any uncommitted edits in the worktree, fetch and
 rebase from the remote, reindex pulled markdown files into OpenViking (so
 `recall` finds them immediately), and push. Pass `--no-auto-commit` to refuse
-syncing when the worktree is dirty.
+syncing when the worktree is dirty. Automatic recall/read sync never commits a
+dirty shared worktree; it warns and leaves that case for explicit
+`threadnote share sync`.
 
 ### Take a memory back
 

package/package.json

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