@vib795/agent-memory 0.3.0 → 0.4.0

package/README.md

@@ -162,6 +162,17 @@ exactly what would go.
 Everything already captured stays in `default`, at the same path as before. Nothing
 migrates and nothing changes until you create a second engagement.
 
+**Two things sit outside the boundary, deliberately.** Skill installation is shared,
+because every engagement reads the same three skill files and registering them per
+engagement would leave the description stale after a switch. Handoff files are shared
+too — they live in `~/.agents/handoffs`, not in a store — so `purge` does not remove
+them and says so every time rather than letting "the store is gone" be mistaken for
+"their context is gone".
+
+Most people need none of this. If each client already gives you a separate machine,
+that boundary is stronger than anything here, and the default engagement is all you
+will ever touch.
+
 ## CLI
 
 ```
@@ -268,10 +279,11 @@ npm install -g ./agent-memory
 agent-memory setup
 ```
 
-**Do not install from the git URL directly.** `npm install -g <git-url>` fails for
-this package: npm links the package into `~/.npm/_cacache/tmp/git-clone*`, a
-directory it then cleans, and `postinstall` dies with `Cannot find module` before it
-can run. Cloning first avoids npm's git handling entirely. Verified on npm 11.18.
+**Do not install from the git URL directly.** `npm install -g <git-url>` does not
+work for this package: npm resolves a git install through
+`~/.npm/_cacache/tmp/git-clone*` and then removes that directory, leaving the global
+install pointing at a path that no longer exists. Cloning first avoids npm's git
+handling entirely. Verified on npm 11.18.
 
 Every release is mirrored to **GitHub Packages**. Treat that as redundancy rather
 than a second front door: GitHub Packages requires authentication even for public
@@ -313,17 +325,16 @@ drift, and `compact` regenerates the routing digest into both.
 `agent-memory doctor` lists what it detected, so an install that appears to do
 nothing tells you whether your editor was missed or simply ignored the files.
 
-**Why it is not automatic.** There is a `postinstall` hook that does exactly this,
-but current npm refuses to run package install scripts unless you opt in per
-package, and prints only a warning when it skips them. Managed environments go
-further and set `ignore-scripts=true` globally. Rather than pretend, the second
-command is documented as part of the install. If you would rather have it automatic:
-
-```bash
-npm install -g --allow-scripts=@vib795/agent-memory @vib795/agent-memory
-```
+**Why it is not automatic.** Installing the package writes nothing to your machine.
+There is no `postinstall` hook, and its absence is a security decision rather than an
+omission: an install script that writes into *other* tools' agent directories —
+`~/.claude`, `~/.codex`, your editor's prompt folder — is mechanically
+indistinguishable from a supply-chain attack that hijacks an AI agent, and
+supply-chain scanners classify it as exactly that. Installing this package and
+granting it your agents are two separate decisions, so they are two commands.
+`agent-memory setup` is the one that asks.
 
-Either way `agent-memory doctor` tells you where you stand. It checks the files
+`agent-memory doctor` tells you where you stand. It checks the files
 rather than the tools, and names any agent it found that has no skills in it:
 
 ```
@@ -376,10 +387,9 @@ Note that `npm install -g .` from a clone *symlinks* rather than copies, so
 `skills/recall/SKILL.md` will show as modified. That is expected — the description
 is generated state, and the committed value is only a placeholder.
 
-Needs Node 22.5 or newer; `doctor` says so plainly if the version is too old, and
-`postinstall` refuses rather than failing your install.
+Needs Node 22.5 or newer; `doctor` says so plainly if the version is too old.
 
-Run `npm test` for the suite (74 tests, no dependencies). CI runs it on Linux,
+Run `npm test` for the suite (78 tests, no dependencies). CI runs it on Linux,
 macOS and Windows across Node 22 and 24, and separately installs the packed tarball
 and exercises it end to end on all three.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vib795/agent-memory",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Durable cross-repo knowledge graph for GitHub Copilot and Claude Code. Markdown source of truth, disposable SQLite index, zero runtime dependencies.",
   "keywords": [
     "github-copilot",
@@ -27,19 +27,11 @@
   },
   "scripts": {
     "test": "node --test",
-    "postinstall": "node scripts/postinstall.js",
     "setup": "node src/cli.js setup"
   },
   "files": [
     "src/",
-    "scripts/",
     "skills/",
-    "install.sh",
-    "install.ps1",
-    "update.sh",
-    "update.ps1",
-    "uninstall.sh",
-    "uninstall.ps1",
     "README.md",
     "HOWTO.md",
     "LICENSE"

package/src/cli.js

@@ -15,7 +15,7 @@ import { compact, maybeCompact } from './compact.js';
 import { staleness, currentRepo, reviewCandidates, captureGap } from './staleness.js';
 import { setup as runSetup, unlinkSkills, danglingSkillLinks, SKILLS } from './setup.js';
 import { detectTargets, installableTargets } from './targets.js';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { atomicWrite } from './atomic.js';
 
 /**
@@ -131,10 +131,10 @@ function cmdInit(opts) {
 /**
  * Link the skills into both agents and build the store.
  *
- * Runs automatically from npm postinstall, but exists as a command because managed
- * npm configurations often set `ignore-scripts=true`, which skips postinstall with
- * no warning. When that happens the recovery is one command rather than hunting for
- * a shell script inside a global node_modules directory.
+ * This is the only thing that writes into an agent's directory, and it only runs when
+ * a person types it. The package deliberately ships no install hook: writing into
+ * another tool's agent surface from an install script is the shape of a supply-chain
+ * agent hijack, whoever does it and for whatever reason.
  */
 function cmdSetup() {
   ensureStore();
@@ -496,10 +496,10 @@ function cmdDoctor() {
   );
 
   // Detection is not installation, and conflating them is how this tool reports
-  // healthy while doing nothing. npm gates postinstall scripts behind allow-scripts,
-  // and managed profiles set ignore-scripts=true; in both cases the CLI lands on PATH
-  // and every agent directory stays empty, while every other check here still passes.
-  // So verify the files, per agent, rather than trusting that setup ever ran.
+  // healthy while doing nothing. Installing the package does not install the skills;
+  // only `agent-memory setup` does, so the CLI routinely lands on PATH with every
+  // agent directory empty while every other check here still passes. Verify the
+  // files, per agent, rather than trusting that setup ever ran.
   const gaps = [];
   for (const t of installableTargets()) {
     const absent = SKILLS.filter((name) =>
@@ -807,6 +807,11 @@ function cmdEngagement(opts) {
       text: [
         `Purged engagement ${name}: ${notes} note${notes === 1 ? '' : 's'} removed.`,
         `${dir} no longer exists.`,
+        '',
+        // Said every time, because the gap between "the store is gone" and "their
+        // knowledge is gone" is exactly the assumption someone would make here.
+        'Handoff files are not part of an engagement store and were not touched.',
+        `Review ${join(dirname(STORE_BASE), 'handoffs')} yourself.`,
       ].join('\n'),
     };
   }

package/src/config.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join, dirname, parse as parsePath } from 'node:path';
 import { homedir } from 'node:os';
 import { atomicWrite } from './atomic.js';
@@ -85,6 +85,8 @@ export const paths = {
   db: join(STORE_ROOT, 'index.db'),
   routing: join(STORE_ROOT, 'ROUTING.md'),
   config: join(STORE_ROOT, 'config.json'),
+  // Machine-scoped keys live beside every engagement rather than inside one.
+  machineConfig: join(STORE_BASE, 'config.json'),
   typeDir: (type) => join(STORE_ROOT, 'notes', type),
   archiveTypeDir: (type) => join(STORE_ROOT, 'notes', 'archive', type),
 };
@@ -107,24 +109,41 @@ export const DEFAULTS = {
 // from a checkout or copied into place, and both are legitimate installs.
 export const LIST_KEYS = ['skillPaths'];
 
-export function loadConfig() {
-  if (!existsSync(paths.config)) return { ...DEFAULTS, skillPaths: [] };
+/** A malformed config must not take the store down. Absent and unreadable are equal. */
+function readJson(file) {
+  if (!existsSync(file)) return {};
   try {
-    const raw = JSON.parse(readFileSync(paths.config, 'utf8'));
-    const merged = { ...DEFAULTS, skillPaths: [] };
-    for (const [k, v] of Object.entries(raw)) {
-      if (k in DEFAULTS && typeof v === 'number' && Number.isFinite(v) && v > 0) merged[k] = v;
-      if (LIST_KEYS.includes(k) && Array.isArray(v)) {
-        merged[k] = v.filter((s) => typeof s === 'string' && s.trim());
-      }
-    }
-    return merged;
+    return JSON.parse(readFileSync(file, 'utf8'));
   } catch {
-    // A malformed config must not take the store down. Defaults are always valid.
-    return { ...DEFAULTS, skillPaths: [] };
+    return {};
   }
 }
 
+/**
+ * Config comes from two files, split by what each key actually describes.
+ *
+ * Where the skills are installed is a fact about this machine. Every engagement
+ * shares one set of skill files, so registering them per engagement meant `compact`
+ * had nothing to regenerate after a switch and the recall description kept
+ * advertising the previous engagement's topics — into the agent's context, which is
+ * the worst place for it. Caps like the digest size really are per-store, and stay
+ * there. For the default engagement both files are the same path and nothing moves.
+ */
+export function loadConfig() {
+  const merged = { ...DEFAULTS, skillPaths: [] };
+
+  for (const [k, v] of Object.entries(readJson(paths.config))) {
+    if (k in DEFAULTS && typeof v === 'number' && Number.isFinite(v) && v > 0) merged[k] = v;
+  }
+  const machine = readJson(paths.machineConfig);
+  for (const k of LIST_KEYS) {
+    if (Array.isArray(machine[k])) {
+      merged[k] = machine[k].filter((s) => typeof s === 'string' && s.trim());
+    }
+  }
+  return merged;
+}
+
 /**
  * Merge a patch into config.json.
  *
@@ -136,24 +155,37 @@ export function loadConfig() {
  * cannot quietly become permanent state.
  */
 export function saveConfig(patch) {
-  const current = existsSync(paths.config)
-    ? (() => {
-        try {
-          return JSON.parse(readFileSync(paths.config, 'utf8'));
-        } catch {
-          return {};
-        }
-      })()
-    : {};
-
-  const next = { ...current };
+  const sameFile = paths.config === paths.machineConfig;
+  const caps = readJson(paths.config);
+  const machine = sameFile ? caps : readJson(paths.machineConfig);
+
+  let capsDirty = false;
+  let machineDirty = false;
   for (const [k, v] of Object.entries(patch || {})) {
-    if (k in DEFAULTS && typeof v === 'number' && Number.isFinite(v) && v > 0) next[k] = v;
+    if (k in DEFAULTS && typeof v === 'number' && Number.isFinite(v) && v > 0) {
+      caps[k] = v;
+      capsDirty = true;
+    }
     if (LIST_KEYS.includes(k) && Array.isArray(v)) {
-      next[k] = [...new Set(v.filter((s) => typeof s === 'string' && s.trim()))].sort();
+      machine[k] = [...new Set(v.filter((s) => typeof s === 'string' && s.trim()))].sort();
+      machineDirty = true;
     }
   }
 
-  atomicWrite(paths.config, `${JSON.stringify(next, null, 2)}\n`);
-  return next;
+  if (sameFile) {
+    if (capsDirty || machineDirty) {
+      mkdirSync(dirname(paths.config), { recursive: true });
+      atomicWrite(paths.config, `${JSON.stringify(caps, null, 2)}\n`);
+    }
+    return { ...caps };
+  }
+  if (capsDirty) {
+    mkdirSync(dirname(paths.config), { recursive: true });
+    atomicWrite(paths.config, `${JSON.stringify(caps, null, 2)}\n`);
+  }
+  if (machineDirty) {
+    mkdirSync(dirname(paths.machineConfig), { recursive: true });
+    atomicWrite(paths.machineConfig, `${JSON.stringify(machine, null, 2)}\n`);
+  }
+  return { ...caps, ...Object.fromEntries(LIST_KEYS.map((k) => [k, machine[k]]).filter(([, v]) => v)) };
 }

package/src/setup.js

@@ -11,8 +11,8 @@ import { toPromptFile, isGenerated } from './promptfile.js';
 /**
  * Installation, in Node rather than in two shell scripts.
  *
- * This is the single implementation behind three entry points: `npm install` via
- * postinstall, `agent-memory setup`, and install.sh / install.ps1. Writing it once
+ * This is the single implementation behind both entry points: `agent-memory setup`,
+ * and install.sh / install.ps1 which are thin wrappers over it. Writing it once
  * matters because the machine that has to run it is a Windows desktop this was never
  * developed on, and a PowerShell copy of this logic would drift silently.
  *
@@ -207,8 +207,8 @@ export function setup({ compactFn } = {}) {
   const existing = (loadConfig().skillPaths || []).filter((p) => existsSync(p));
   saveConfig({ skillPaths: [...new Set([...existing, ...skillPaths])] });
 
-  // compact is passed in so this module does not pull the database, and the whole
-  // npm postinstall path with it, into memory just to make some symlinks.
+  // compact is passed in so this module does not pull the database into memory just
+  // to make some symlinks.
   const result = compactFn ? compactFn() : null;
   return {
     targets,

package/install.ps1

@@ -1,71 +0,0 @@
-<#
-.SYNOPSIS
-  Installs agent-memory and all three skills from a checkout.
-
-.DESCRIPTION
-  `npm install -g .` does this on its own via the postinstall hook. This script
-  exists for two cases: installing straight from a clone without npm, and finishing
-  the job when a managed npm config sets ignore-scripts=true and silently skips it.
-
-  The linking itself lives in src\setup.js, not here. That is deliberate: a PowerShell
-  reimplementation could only be tested on Windows, and the machine this was written
-  on is not Windows. One implementation, three entry points, no drift.
-
-  Skills are linked into both agent directories:
-    %USERPROFILE%\.agents\skills\<name>   -> read by GitHub Copilot in every window
-    %USERPROFILE%\.claude\skills\<name>   -> read by Claude Code
-
-  Directory junctions are used, which need neither admin rights nor Developer Mode.
-  They fail on a network-backed profile (FSLogix, roaming), and setup falls back to
-  copying and says so.
-
-.EXAMPLE
-  powershell -ExecutionPolicy Bypass -File .\install.ps1
-#>
-
-$ErrorActionPreference = 'Stop'
-
-$source = $PSScriptRoot
-
-$node = Get-Command node -ErrorAction SilentlyContinue
-if (-not $node) {
-    Write-Error "node not found on PATH. agent-memory needs Node >= 22.5."
-    exit 1
-}
-
-& node (Join-Path $source 'src\cli.js') setup
-
-Write-Host ""
-Write-Host "Linking the CLI" -ForegroundColor Cyan
-# npm writes its warnings to stderr, and `2>&1` turns each one into an ErrorRecord,
-# which $ErrorActionPreference = 'Stop' then treats as terminating. A managed npm
-# config makes that certain rather than unlikely: an unknown key such as `always-auth`
-# produces a warning on every single npm invocation, so this step could never succeed
-# on the desktops this script exists for. It aborted the whole install — no fallback
-# message, no doctor, no closing instructions — over a warning about an unrelated
-# config key. Scope the preference to this one call.
-$previousPreference = $ErrorActionPreference
-$ErrorActionPreference = 'Continue'
-try {
-    & npm install -g $source 2>&1 | Out-Null
-    $npmExit = $LASTEXITCODE
-} catch {
-    $npmExit = 1
-} finally {
-    $ErrorActionPreference = $previousPreference
-}
-
-if ($npmExit -eq 0) {
-    Write-Host "  [npm] agent-memory installed globally" -ForegroundColor Green
-} else {
-    # A global install failing on a managed desktop is common and not worth aborting
-    # on. The skills are already linked; this one step can be finished by hand.
-    Write-Host "  [npm] global install failed. Run this yourself:" -ForegroundColor Yellow
-    Write-Host "        npm install -g `"$source`"" -ForegroundColor Yellow
-}
-
-Write-Host ""
-& node (Join-Path $source 'src\cli.js') doctor
-
-Write-Host ""
-Write-Host "Installed. Restart VS Code, then try /recall, /remember, or /handoff." -ForegroundColor Cyan

package/install.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-# Installs agent-memory and all three skills from a checkout, on macOS/Linux.
-#
-# `npm install -g .` does this on its own via the postinstall hook. This script
-# exists for two cases: installing straight from a clone without npm, and finishing
-# the job when a managed npm config sets ignore-scripts=true and silently skips it.
-#
-# The linking itself lives in src/setup.js, not here. One implementation, three entry
-# points, so this script and its PowerShell twin cannot drift from each other.
-set -euo pipefail
-
-source_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-if ! command -v node >/dev/null 2>&1; then
-  echo "node not found on PATH. agent-memory needs Node >= 22.5." >&2
-  exit 1
-fi
-
-node "$source_dir/src/cli.js" setup
-
-echo
-echo "Linking the CLI"
-if npm install -g "$source_dir" >/dev/null 2>&1; then
-  echo "  [npm] agent-memory installed globally"
-else
-  # A global install needing sudo is common and is not worth aborting on. The skills
-  # are already linked, and the user can finish this one step by hand.
-  echo "  [npm] global install failed (permissions?). Run this yourself:"
-  echo "        npm install -g \"$source_dir\""
-fi
-
-echo
-node "$source_dir/src/cli.js" doctor || true
-
-echo
-echo "Installed. Restart VS Code, then try /recall, /remember, or /handoff."

package/scripts/postinstall.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-/**
- * Link the skills when the package is installed.
- *
- * This must never fail an install. A missing symlink is a nuisance; an `npm install`
- * that exits non-zero on a managed desktop is the kind of thing that gets a tool
- * banned. Every failure here is reported and swallowed, and `agent-memory setup`
- * remains available to finish the job by hand.
- *
- * Note that managed npm configurations often set `ignore-scripts=true`, in which case
- * this file never runs and nothing warns you. That is precisely why the same work is
- * exposed as a command, and why `doctor` names it.
- */
-
-const say = (msg) => process.stdout.write(`${msg}\n`);
-
-if (process.env.AGENT_MEMORY_SKIP_POSTINSTALL) {
-  process.exit(0);
-}
-
-try {
-  const [maj, min] = process.versions.node.split('.').map((s) => Number.parseInt(s, 10));
-  if (maj < 22 || (maj === 22 && min < 5)) {
-    say(`agent-memory: Node ${process.versions.node} is too old; needs >= 22.5 for node:sqlite.`);
-    say('agent-memory: skills not linked. Upgrade Node, then run: agent-memory setup');
-    process.exit(0);
-  }
-
-  const { setup } = await import('../src/setup.js');
-  const { compact } = await import('../src/compact.js');
-  const r = setup({ compactFn: () => compact() });
-
-  const links = r.installed.filter((s) => s.mode === 'link').length;
-  const copies = r.copies.length;
-  say(`agent-memory: linked ${links} skill${links === 1 ? '' : 's'}${copies ? `, copied ${copies}` : ''}.`);
-  say(`agent-memory: ${r.notes} notes indexed. Restart VS Code, then try /recall.`);
-  if (copies) {
-    say('agent-memory: copies happen on network-backed profiles; re-run `agent-memory setup` after upgrades.');
-  }
-} catch (err) {
-  say(`agent-memory: automatic setup did not complete (${err.message}).`);
-  say('agent-memory: run `agent-memory setup` to finish. Nothing else is affected.');
-}
-
-process.exit(0);

package/uninstall.ps1

@@ -1,54 +0,0 @@
-<#
-.SYNOPSIS
-  Removes the skills and the CLI, in the order that is recoverable.
-
-.DESCRIPTION
-  npm will not enforce that order and gets it wrong on its own: `npm uninstall -g`
-  deletes the package and leaves one link per skill per agent pointing at nothing,
-  which every one of those agents still tries to load. By then the binary that would
-  have cleaned them up is gone too, so tooling cannot fix it. This unlinks first and
-  removes the package second.
-
-  Your notes are never touched. They are plain markdown under
-  %USERPROFILE%\.agents\memory, they outlive the tool that indexed them, and removing
-  them is your call, not this script's.
-
-.EXAMPLE
-  powershell -ExecutionPolicy Bypass -File .\uninstall.ps1
-#>
-
-# Not 'Stop': a half-finished uninstall is worse than a reported failure, so each step
-# is allowed to fail and say so.
-$ErrorActionPreference = 'Continue'
-
-$source = $PSScriptRoot
-
-$node = Get-Command node -ErrorAction SilentlyContinue
-if (-not $node) {
-    Write-Error "node not found on PATH. agent-memory needs Node >= 22.5."
-    exit 1
-}
-
-Write-Host "Removing skills" -ForegroundColor Cyan
-# Run from the checkout rather than the installed binary, so this still works when the
-# global package is already gone.
-& node (Join-Path $source 'src\cli.js') uninstall
-
-Write-Host ""
-Write-Host "Removing the CLI" -ForegroundColor Cyan
-try {
-    & npm uninstall -g '@vib795/agent-memory' 2>&1 | Out-Null
-    $npmExit = $LASTEXITCODE
-} catch {
-    $npmExit = 1
-}
-
-if ($npmExit -eq 0) {
-    Write-Host "  [npm] package removed" -ForegroundColor Green
-} else {
-    Write-Host "  [npm] not removed. It may not be installed globally:" -ForegroundColor Yellow
-    Write-Host "        npm uninstall -g `"@vib795/agent-memory`"" -ForegroundColor Yellow
-}
-
-Write-Host ""
-Write-Host "Done. Your notes are untouched." -ForegroundColor Cyan

package/uninstall.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-# Removes the skills and the CLI, in the order that is recoverable.
-#
-# npm will not enforce that order and gets it wrong on its own: `npm uninstall -g`
-# deletes the package and leaves one link per skill per agent pointing at nothing,
-# which every one of those agents still tries to load. By then the binary that would
-# have cleaned them up is gone too, so tooling cannot fix it. Unlink first, remove
-# the package second.
-#
-# Your notes are never touched. They are plain markdown under ~/.agents/memory, they
-# outlive the tool that indexed them, and removing them is your call, not this script's.
-#
-# No `set -e`: a half-finished uninstall is worse than a reported failure, so each
-# step is allowed to fail and say so.
-set -uo pipefail
-
-source_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-if ! command -v node >/dev/null 2>&1; then
-  echo "node not found on PATH. agent-memory needs Node >= 22.5." >&2
-  exit 1
-fi
-
-echo "Removing skills"
-# Run from the checkout rather than the installed binary, so this still works when
-# the global package is already gone.
-node "$source_dir/src/cli.js" uninstall
-
-echo
-echo "Removing the CLI"
-if npm uninstall -g @vib795/agent-memory >/dev/null 2>&1; then
-  echo "  [npm] package removed"
-else
-  echo "  [npm] not removed. It may not be installed globally, or may need sudo:"
-  echo "        npm uninstall -g @vib795/agent-memory"
-fi
-
-echo
-echo "Done. Your notes are untouched at ${AGENT_MEMORY_HOME:-$HOME/.agents/memory}."

package/update.ps1

@@ -1,45 +0,0 @@
-<#
-.SYNOPSIS
-  Updates a clone install: pull, then re-run the installer.
-
-.DESCRIPTION
-  The install logic is deliberately not repeated here. install.ps1 already relinks the
-  skills, relinks the CLI and runs doctor; an update is exactly that plus a pull, and
-  writing it a second time is how the two drift.
-
-  Re-running setup is not optional on an upgrade. Prompt files are copies rather than
-  links, so VS Code keeps reading the old text until something rewrites it.
-
-.EXAMPLE
-  powershell -ExecutionPolicy Bypass -File .\update.ps1
-#>
-
-$ErrorActionPreference = 'Stop'
-
-$source = $PSScriptRoot
-
-if (-not (Test-Path (Join-Path $source '.git'))) {
-    Write-Host "This is not a git checkout, so there is nothing to pull." -ForegroundColor Yellow
-    Write-Host "If you installed from npm, update with:" -ForegroundColor Yellow
-    Write-Host "  npm install -g @vib795/agent-memory@latest" -ForegroundColor Yellow
-    Write-Host "  agent-memory setup" -ForegroundColor Yellow
-    exit 1
-}
-
-Write-Host "Pulling" -ForegroundColor Cyan
-# git writes ordinary progress to stderr, and `Stop` would treat that as terminating.
-$previousPreference = $ErrorActionPreference
-$ErrorActionPreference = 'Continue'
-try {
-    & git -C $source pull --ff-only 2>&1 | Write-Host
-    $gitExit = $LASTEXITCODE
-} finally {
-    $ErrorActionPreference = $previousPreference
-}
-if ($gitExit -ne 0) {
-    Write-Error "git pull failed. Resolve that first, then run this again."
-    exit 1
-}
-
-Write-Host ""
-& powershell -ExecutionPolicy Bypass -File (Join-Path $source 'install.ps1')

package/update.sh

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-# Updates a clone install: pull, then re-run the installer.
-#
-# The install logic is deliberately not repeated here. install.sh already relinks the
-# skills, relinks the CLI and runs doctor; an update is exactly that plus a pull, and
-# writing it a second time is how the two drift.
-#
-# Re-running setup is not optional on an upgrade. Prompt files are copies rather than
-# links, so an editor keeps reading the old text until something rewrites it.
-set -euo pipefail
-
-source_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-if [ ! -d "$source_dir/.git" ]; then
-  echo "This is not a git checkout, so there is nothing to pull." >&2
-  echo "If you installed from npm, update with:" >&2
-  echo "  npm install -g @vib795/agent-memory@latest" >&2
-  echo "  agent-memory setup" >&2
-  exit 1
-fi
-
-echo "Pulling"
-git -C "$source_dir" pull --ff-only
-
-echo
-exec "$source_dir/install.sh"