From 5770d72b65d304710340ded8acb839bf248daf62 Mon Sep 17 00:00:00 2001 From: Kielov Date: Sat, 27 Jun 2026 12:45:43 -0400 Subject: [PATCH] feat(memory): portability procedure + wick-migrate skill (v1.2.0) The migration that gets an existing agent to single-writer + portable, plus the executable skill to run it. Companion to v1.1.0's MEMORY-PROTOCOL.md. Added: - PORTABILITY.md 14-step procedure: freeze + fresh-session-verify host auto-memory, inventory both layers, sort Keep/Merge/Discard/Conflict (never auto-resolve a conflict), archive-don't-delete, relativize to the launch directory, sweep tooling, verify behavior not form. - .claude/skills/wick-migrate/SKILL.md executable, gated form (skills 10 -> 11). Changed: CHANGELOG / wick-meta (1.1.0 -> 1.2.0) / README counts / WICK-INTEGRATION 12. All four scanners green. No workflow changes (no scope issue this time). Co-Authored-By: Claude Opus 4.8 --- .claude/skills/wick-migrate/SKILL.md | 68 +++++++ CHANGELOG.md | 11 ++ PORTABILITY.md | 256 +++++++++++++++++++++++++++ README.md | 5 +- WICK-INTEGRATION.md | 2 + wick-meta.json | 5 +- 6 files changed, 343 insertions(+), 4 deletions(-) create mode 100644 .claude/skills/wick-migrate/SKILL.md create mode 100644 PORTABILITY.md diff --git a/.claude/skills/wick-migrate/SKILL.md b/.claude/skills/wick-migrate/SKILL.md new file mode 100644 index 0000000..efcc32e --- /dev/null +++ b/.claude/skills/wick-migrate/SKILL.md @@ -0,0 +1,68 @@ +--- +name: wick-migrate +description: Make a Wick agent fully portable between machines β€” consolidate a host's auto-memory into the Wick memory/ layer, disable the shadow portably, and relativize all paths and tooling. Guided, gated, archive-don't-delete. Use when moving an agent to a new machine, or to converge a single-machine agent onto one governed memory layer. Full reference in PORTABILITY.md. +license: MIT +--- + +# Wick β€” Migrate (portability) + +Consolidate everything into one portable, git-mergeable memory layer and disable the +machine-keyed shadow. This skill is the executable form of `PORTABILITY.md` β€” read that for +the full rationale and the failure modes; this is the operating checklist with the gates. + +## When to invoke + +- Moving a Wick agent to a second machine (the `memory/` folder must travel whole) +- A host keeps its own auto-memory (Claude Code, Cursor) and you want one governed layer +- Convergence: corrections or facts live only in the host layer and you want them in `memory/` + +## The load-bearing facts + +- **Freeze before you migrate.** Auto-memory is live. Disable it (Step 1) and **verify in a + fresh session** before consolidating β€” else the source mutates under you and the layers + diverge invisibly. This makes it a **two-session** job, not one. +- **Verify behavior, not form.** "The setting says false" and "the path is relative" are the + two ways this silently fails. Confirm by a fresh session and by resolving paths from the + launch CWD. +- **Archive, don't delete.** Discards and prunes go to `memory/_archived-auto-memory/` (the + reversibility net), never to nothing. + +## Procedure (gates marked 🚦 β€” get explicit sign-off) + +1. 🚦 **Freeze.** Find `~/.claude/projects//memory/`. If present, write + `{ "autoMemoryEnabled": false }` to the project's in-folder `.claude/settings.json` + (verify the key against current docs; check `settings.local.json` doesn't re-enable). + **Then start a fresh session and confirm no auto-memory loaded.** Do the rest there. +2. **Inventory** both layers (Wick `memory/` + frozen auto-memory). Note duplicates, + convention-bleed (`feedback_X.md`), and what's already in `CLAUDE.md`. Present it. +3. 🚦 **Sort** auto-memory: Keep / Merge / Discard / **Conflict**. Never auto-resolve a + conflict β€” surface both versions, recommend, let the user decide. Present the sort. +4. 🚦 **Audit** Wick memory: redundancy, overlap, bloat. **Never flag by mtime** β€” judge by + whether content is still true. Present findings. +5. **Consolidate feedback** into `memory/feedback/*.md` topic files β€” *only if* it isn't + already in `CLAUDE.md`. Strip YAML frontmatter; keep tables/values; <200 lines each. +6. **Write** kept/merged content (read target first; append, dated). Project detail β†’ + `projects//` with a status line + pointer. +7. **Archive** the raw auto-memory `memory/` subfolder β†’ `memory/_archived-auto-memory/` with + an INERT README. Not the `*.jsonl` transcripts. +8. 🚦 **Prune** now-redundant Wick files (approval required). Immutable logs stay as written. +9. **Fix dangling references** in `memory/`, `CLAUDE.md`, and tooling. +10. **Rewrite `memory/index.md`** β€” relative paths, <100 lines, no "as of " blocks, + archives excluded. +11. **Update `CLAUDE.md`** memory protocol β€” deterministic session-start loading, feedback + capture, write discipline, portability note (`memory/` is the single source of truth). +12. **Relativize to the launch directory** β€” pin the frame in `CLAUDE.md`; run + `node tools/wick-path-audit.mjs`. Watch the two "relative-but-resolves-wrong" traps + (own-folder-name doubling; missing `memory/` prefix). +13. **Tooling sweep** β€” scripts self-locate; `.mcp.json` uses `${CLAUDE_PROJECT_DIR}`; no + plaintext secrets (`node tools/wick-scrub.mjs`); hooks use relative cwd. +14. **Verify behavior** β€” fresh session loads nothing; sample paths resolve from launch CWD; + all four scanners green; nothing lost; no conflict silently resolved. Report. + +## What this skill will never do + +- Pass a 🚦 gate without explicit user sign-off. +- Delete the only copy of anything (archive first). +- Auto-resolve a conflict between the host layer and `CLAUDE.md`. +- Claim "disabled" or "portable" from text inspection β€” only from a fresh session and real + path resolution. diff --git a/CHANGELOG.md b/CHANGELOG.md index eedac4e..807e55b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,16 @@ # Wick Changelog +## v1.2.0 (2026-06-27) β€” Portability procedure + `wick-migrate` + +`MEMORY-PROTOCOL.md` (v1.1.0) gave the single-writer *rule*. This gives the *migration* to get an existing agent there β€” and the executable skill to run it. + +### Added +- **`PORTABILITY.md`** β€” the canonical 14-step procedure to make a Wick agent fully portable by folder copy: freeze + verify the host auto-memory first, inventory both layers, sort Keep/Merge/Discard/Conflict (never auto-resolve a conflict), archive-don't-delete, relativize to the *launch directory* (with the two "relative-but-resolves-wrong" traps named), sweep tooling, and verify *behavior not form*. Validated against real multi-agent migrations. +- **`wick-migrate` skill** β€” the executable, gated form of the procedure (gates at disable / sort / audit / deletions). Skills: 10 β†’ 11. + +### Why it's a two-session job +The load-bearing insight: auto-memory is *live*. You must disable it and confirm in a **fresh session** before consolidating, or the source mutates under you and the layers diverge invisibly. "The setting says false" is not verification; "a fresh session loaded nothing" is. Portability can't be a one-shot. + ## v1.1.0 (2026-06-27) β€” Single-writer memory + host-layer reconciliation The gap a user issue surfaced: when Wick runs inside a host that keeps its *own* memory (Claude Code's auto-memory), two memory systems run at once and neither knows about the other β€” corrections captured by the host never reach `memory/`, the host store is machine-keyed and doesn't travel, and absolute paths silently break portability. This release governs that interaction instead of pretending it away. diff --git a/PORTABILITY.md b/PORTABILITY.md new file mode 100644 index 0000000..9454898 --- /dev/null +++ b/PORTABILITY.md @@ -0,0 +1,256 @@ +# Wick Portability Procedure + +Make a Wick-based agent fully portable between machines by folder copy. This is the +operational companion to `MEMORY-PROTOCOL.md`: the protocol states the single-writer +*rule*; this states the *migration* that gets an existing agent there. Hand this document +to the agent (or invoke the `wick-migrate` skill) and let it execute, gate by gate. + +**Prerequisites** +- **Back up the entire project folder before starting.** +- This spans **at least two sessions.** Step 1 disables auto-memory; verifying it took + effect requires a *fresh* session β€” you cannot confirm auto-memory is off from inside a + session that already loaded it. Do the consolidation (Steps 2+) in that confirmed-off + session, so the source layer is frozen before you migrate from it. +- The agent runs from the project directory it's consolidating. +- **Approval gates** at Steps 1 (disable), 3 (sort), 4 (audit), 8 (deletions). Don't pass a + gate without explicit user sign-off. + +## What you're doing and why + +Consolidating memory into a single, portable layer. Two systems usually coexist: + +1. **The Wick `memory/` folder** β€” structured, indexed, governed by `CLAUDE.md`. Loaded on + demand per the memory protocol. +2. **Host auto-memory** (e.g. Claude Code's, at `~/.claude/projects//memory/`). + Its `MEMORY.md` index is auto-loaded at session start; often the *only* memory loaded + automatically. + +Host auto-memory is not portable (the folder name encodes the absolute path), is not +governed by your memory discipline, and may hold corrections the Wick layer lacks β€” or that +*contradict* it. This procedure merges everything into the Wick layer, disables the shadow +portably, and relativizes all paths including tooling. + +**The key risk:** auto-memory is *live* β€” read and written every session. If you migrate +from it while it's active, or only *believe* you disabled it without confirming, the layers +diverge again, this time invisibly, because you'll treat the consolidated layer as +authoritative. (On a real run, auto-memory wrote a new file *after* the initial inventory β€” +caught only because the archive was taken from the live folder, not the stale inventory.) +So freeze and verify the source first. + +## Step 1 β€” Freeze the source: disable auto-memory and verify + +Check for `~/.claude/projects//memory/` (replace path separators with +dashes: `C:/Users/you/myproject` β†’ `C--Users-you-myproject`; the path derives from the git +root if the project is a git repo, else the project root). No `memory/` subfolder β†’ nothing +to consolidate; skip to **Step 4**. + +If it exists, disable it via the project's own `.claude/settings.json` (project-tier, +portable β€” travels with the folder): + +```json +{ "autoMemoryEnabled": false } +``` + +- `autoMemoryEnabled` defaults to `true`; `false` stops reads/writes (it does not delete the + folder β€” inventory still works). Also togglable via `/memory` or + `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1`. **Verify the key name against current docs first** β€” + config keys drift between versions. +- A project may also have `.claude/settings.local.json`, which overrides shared + `settings.json`. Check it doesn't re-enable auto-memory. +- On a new machine the setting applies only **after the workspace-trust dialog is accepted** + (already-trusted folders get no new prompt β€” expected, not a failure). + +**Then verify empirically β€” the load-bearing check.** Writing the key β‰  the feature being +off. Start a **fresh session** and confirm no auto-memory `MEMORY.md` loaded. Do the rest in +that confirmed-off session. "The file says false" is not verification; "a fresh session +loaded nothing" is. + +## Step 2 β€” Inventory both layers + +Read every file in `memory/` and in the frozen auto-memory folder (start with its +`MEMORY.md`). For each: filename, type, one-line summary, current vs superseded, and whether +it duplicates the other layer. + +- Watch for **convention bleed**: auto-memory-style per-event files (`feedback_X.md`, + `project_Y.md`) already written into the Wick folder. Prime consolidation targets. +- **Check what's already in `CLAUDE.md`.** On some agents most "feedback" has already been + promoted into `CLAUDE.md`; on others not. This determines whether feedback files are Keep + or Discard β€” don't assume; check. + +Present the inventory before proceeding. + +## Step 3 β€” Sort auto-memory files: Keep / Merge / Discard / Conflict + +- **Keep** β€” durable, actionable, not already in `CLAUDE.md` or Wick memory β†’ write into `memory/`. +- **Merge** β€” overlaps an existing file but has unique details β†’ fold in only the new parts. +- **Discard** β€” ephemeral (session recaps, stale snapshots), belongs in project docs, or + already present. Discarded content is preserved in the Step-7 archive, so discarding is + "don't promote to active memory," not deletion. +- **Conflict** β€” contradicts `CLAUDE.md` or another file (e.g. a feedback entry that loosens + a rule the docs enforce). **Do not auto-resolve.** Surface each with both versions and a + recommendation; let the user decide. The consolidating agent is also the entity whose past + writes created the conflicts β€” it is not a neutral arbiter. Conflicts are the highest-value + thing this pass finds. + +Present the sort (including conflicts) for approval before writing. + +## Step 4 β€” Audit the Wick memory + +Flag: empty scaffolding (keep as stubs), redundant files, overlap clusters, and bloat (one +topic scattered across many files, or files that outgrew their topic). + +**Do not flag by modification date.** A knowledge base is not code: a foundational file +untouched for months is stable, not stale. Judge staleness by whether the *content* is still +true (a shipped "in progress" project, a superseded parameter table) β€” never by mtime, which +would flag the most valuable durable content. Present findings. + +## Step 5 β€” Consolidate feedback into topic files + +If there are >5–6 feedback files **that aren't already in `CLAUDE.md`**, group them into a +few topic files under `memory/feedback/` (e.g. `method.md`, `code.md`, `workflow.md`): rule +in bold, then why, then how to apply; strip auto-memory YAML frontmatter; preserve +tables/schemas/exact values; under 200 lines each. **Skip entirely if the feedback already +lives in `CLAUDE.md`** β€” a `feedback/` folder that duplicates `CLAUDE.md` is worse than none. + +## Step 6 β€” Write kept and merged content + +Kept β†’ `memory/` (or a subfolder). Merged β†’ read the target first, add only what's new. +Relocate project-specific detail to `projects//` and keep a status line + pointer in +memory. Date entries; append, don't overwrite. + +## Step 7 β€” Archive raw auto-memory into the project + +The source is frozen (Step 1), so this snapshot is stable. Copy the auto-memory `memory/` +subfolder into the project as `memory/_archived-auto-memory/` β€” **only the `memory/` +subfolder, not the `*.jsonl` session transcripts beside it.** This is the reversibility net +and the sole record of "Discard" items. Add a `README.md` marking the folder **INERT β€” do +not load**, dated, naming what was archived and where each file went. Ensure `CLAUDE.md` +(Step 11) excludes `_archived-auto-memory/` from session-start loading β€” the `_` prefix +helps, but an explicit exclusion is more reliable. + +## Step 8 β€” Prune redundancies in Wick memory + +Re-evaluate now that Steps 5–6 added content. Propose deletions for approval, then delete: +fully redundant files, one-time stale snapshots, category subsets a master file now covers. +Do not delete without explicit approval; the user should have the Prerequisites backup. + +**Append-only logs are immutable.** Never rewrite history in a session log β€” not even to +relativize a path. Leave past entries as written; fix the discipline going forward. + +## Step 9 β€” Fix dangling references + +Search `memory/`, `CLAUDE.md`, and the wider project (tooling) for references to files that +were deleted, moved, or consolidated: load instructions, cross-references, scripts that load +memory by name. Update or remove every one (a warning on a missing file is tolerable; a crash +is not). + +## Step 10 β€” Rewrite the index + +Update `memory/index.md` to match disk: organized by section, **relative paths only**, +one-line descriptions, under 100 lines. **Strip "current state / counts as of " +blocks** β€” they go stale immediately; point to the live files for status. Confirm no orphans +and nothing listed-but-missing; exclude archive folders. + +## Step 11 β€” Update the CLAUDE.md memory protocol + +Add a Memory Protocol section: +- **Session-start loading** β€” which files load always vs on demand, by mode/lane if + applicable. Deterministic, not "hope auto-recall surfaces it." Since `CLAUDE.md` is always + loaded, an explicit "read `index.md` first" is *more* reliable than auto-recall β€” which is + what makes disabling safe. +- **Feedback capture** β€” where a new correction goes; update existing entries, don't spawn files. +- **Write discipline** β€” read before writing; one file per topic not per event; add an index + row on new files; prune superseded entries; project detail β†’ `projects//`; specs and + session recaps are not memory; relative paths only. +- **Portability note** β€” auto-memory disabled via in-folder `.claude/settings.json`; name + `memory/` the single source of truth; how to re-disable if it ever turns back on. + +## Step 12 β€” Make all paths relative β€” to the *launch directory*, and pin the frame + +First, **pin the frame**: identify the exact directory the agent launches from (where its +`CLAUDE.md` lives and where you start the tool), and relativize to *that*. "The project root" +is ambiguous for a nested agent. **State the launch directory explicitly in `CLAUDE.md`** +("You run from `…/agent/`; all paths here are relative to it") so the frame is declared, not +inferred. + +Then sweep every live `memory/` file and `CLAUDE.md` for absolute paths (`C:/Users/...`, +`/home/...`, `/Users/...`) and rewrite them relative to the launch directory. Two failure +modes β€” both *"relative βœ“ but resolves βœ—"*, so a check that only asks "is it relative?" +misses them: +- **Nested agent β†’ path doubling.** An agent launching from `…/agent/` with a reference + `agent/file.md` resolves to `…/agent/agent/file.md`. The agent's own folder name must not + appear as a prefix; sibling references go up (`../sibling/…`). +- **Standalone agent β†’ missing prefix.** An agent launching from the project root with a + cross-reference `decisions.md` looks for `./decisions.md`, but the file is at + `memory/decisions.md`. Loader/index references must be launch-CWD-relative + (`memory/decisions.md`). + +Self-check: **if the first segment of a relative path repeats your current directory's name β€” +or omits the subfolder (`memory/`) the target lives in β€” it won't resolve.** Don't prepend +your own folder name; don't drop the folder you're not in. + +**Don't launch one agent from two different directories.** That ambiguity *is* the bug. + +Exceptions (leave as-is): immutable log history (Step 8); intentional anti-pattern examples +inside a "never write `C:/...`" rule; directory-tree diagrams; security-boundary phrasing +(prefer "within its own root directory" over a hard-coded absolute). `tools/wick-path-audit.mjs` +automates the sweep and is CI-gated. + +## Step 13 β€” Tooling and code portability + +Memory portability doesn't make *tooling* portable. Sweep scripts and config: +- **Scripts:** replace hard-coded paths with self-location (`Path(__file__).resolve().parent` + / `.parents[N]`) and/or an env-var override (`os.environ.get("X") or `). +- **`.mcp.json`:** Claude Code expands `${VAR}` / `${VAR:-default}` and sets + `${CLAUDE_PROJECT_DIR}`. Use `["${CLAUDE_PROJECT_DIR:-.}/scripts/server.py"]` for args. The + interpreter (`command`) is machine-specific β€” keep the working absolute as an overridable + default: `"${PYTHON:-}"`. Bare `python` on PATH isn't reliable. +- **Credentials:** secrets in plaintext config travel with every copy. Move to env vars or an + untracked secrets file; document per-machine setup. (`tools/wick-scrub.mjs` catches these.) +- **Hooks** (`settings.json`): run with cwd at the project root β€” use `find .` not + `find /abs/path`. Editing `settings.local.json` may require explicit user authorization. +- **Multi-agent dependency:** if one agent's tooling imports a sibling's, the portability + unit is the *set of siblings together*. State this in the agent's notes. + +## Step 14 β€” Verify behavior, not form + +Every step that changed a setting or a reference is checked from the real runtime context, +not by inspecting text. "It's relative" and "the setting says false" are not verifications β€” +they're the two ways this procedure silently fails. + +- [ ] **A fresh session loads no auto-memory** (re-confirm the Step-1 check now settings are final) +- [ ] **References resolve from the launch CWD** β€” actually open/test-resolve a sample of + load-bearing paths (every `index.md` entry, every path in `CLAUDE.md`'s load protocol, + memory-to-memory cross-references) *from the directory the agent launches in* +- [ ] Every live `memory/` file uses relative paths (immutable log history excepted) +- [ ] `CLAUDE.md` uses relative paths (intentional examples excepted) +- [ ] `memory/index.md` matches files on disk; archive folders excluded +- [ ] `CLAUDE.md` specifies deterministic session-start loading and excludes `_archived-auto-memory/` +- [ ] Auto-memory disabled in the **in-folder** project settings (and per sub-agent) +- [ ] No content lost β€” kept/merged present; discarded/pruned items in the in-folder archive +- [ ] No dangling references; tooling self-locates; no plaintext secrets +- [ ] No conflicts silently resolved (all surfaced to the user) + +## After completion + +Portability unit = the folder (or the sibling set, if agents share tooling). To transfer: +1. Copy the folder(s), preserving sibling layout if tooling crosses between them. +2. Open in the tool; **accept the workspace-trust dialog** β€” project-tier settings apply only + after trust. The one manual step for memory. +3. Set any per-machine env vars the tooling needs (interpreter path, secrets). +4. Confirm the first session loads no auto-memory. The agent then has full memory from session 1. + +## Multi-agent projects + +- **Auto-memory is keyed by project root, and project-tier `settings.json` only applies at a + project root.** A `.claude/settings.json` in a mere *subfolder* is **not** independently + read. So: if the agent's folder is opened as its own root, a `settings.json` there works; + if it's only ever a subfolder, disable via the user tier (`~/.claude/settings.json`, not + portable) or `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1`, documented as per-machine setup. Either + way, **verify per agent with a fresh session.** +- **Each agent consolidates independently.** Run this once per agent; don't mix one agent's + auto-memory into another's. +- **Cross-agent references** use `../sibling/` form; survives a move only if sibling layout is + preserved β€” document the assumption. +- **Shared memory** lives in one canonical location, referenced via relative path; don't + duplicate into both agents. diff --git a/README.md b/README.md index 82fd95c..ed57538 100644 --- a/README.md +++ b/README.md @@ -191,7 +191,8 @@ Session 1 is dramatically better than vanilla Claude. Session 30 is dramatically | `GROWING-WICK.md` | Week-by-week guide for users β€” "zero to indispensable in 30 days" | | `WICK-INTEGRATION.md` | Dev-facing integration guide β€” install modes, memory lifecycle, extensions, cross-runtime, debugging, privacy & security | | `MEMORY-PROTOCOL.md` | Single-writer memory rule β€” how Wick's `memory/` coexists with a host's auto-memory (Claude Code, Cursor); ownership table, bufferβ†’drain, relative-path rule | -| `.claude/skills/` | On-demand skills β€” consolidate-memory, code-review, security-review, simplify, tldr, red-team, base-rate, research, catalog, changelog-summary (10 skills, spec-compliant per agentskills.io) | +| `PORTABILITY.md` | Migration procedure β€” make an agent fully portable by folder copy: freeze + verify host auto-memory, consolidate into `memory/`, relativize to the launch dir, verify behavior not form | +| `.claude/skills/` | On-demand skills β€” consolidate-memory, code-review, security-review, simplify, tldr, red-team, base-rate, research, catalog, changelog-summary, migrate (11 skills, spec-compliant per agentskills.io) | | `benchmark/` | Seed tasks + external-benchmark docs β€” targets GAIA2, Inspect AI (UK AISI), galileo-ai/agent-leaderboard | | `tools/wick-scrub.mjs` | Pre-commit secret scanner for `memory/` β€” catches API keys, tokens, credentials before you push | | `tools/wick-path-audit.mjs` | Pre-commit absolute-path scanner β€” flags non-portable paths in `memory/` + config before the folder moves | @@ -272,7 +273,7 @@ Sixteen slash commands. They ship as `.claude/commands/*.md` files (Claude Code | `/checkup` | Diagnose memory wiring β€” detect a host auto-memory shadow layer, flag fact-class overlap, scan for absolute paths; report a posture (reports only, never edits) | | `/sync [source]` | Drain a host/buffer memory layer into your canonical `memory/*.md`, with consent β€” classify by ownership, validate as data, fold with provenance | -### On-Demand Skills (10) +### On-Demand Skills (11) Skills live in `.claude/skills/` and load only when invoked β€” they add capability without bloating the main prompt. See `.claude/skills/README.md` for the full index. diff --git a/WICK-INTEGRATION.md b/WICK-INTEGRATION.md index db4ffc8..44a46f7 100644 --- a/WICK-INTEGRATION.md +++ b/WICK-INTEGRATION.md @@ -386,6 +386,8 @@ Two commands operate it: `tools/wick-path-audit.mjs` (CI-gated) enforces the relative-path half of the rule. The short version: **if the host wrote it and `memory/` should own it, drain it; if it's a runtime fact, leave it; and never let a correction live only in a layer that won't travel.** +To actually *move* an agent to a new machine β€” consolidate a host's auto-memory into `memory/`, disable the shadow portably, and relativize everything including tooling β€” follow **`PORTABILITY.md`** (or invoke the **`wick-migrate`** skill). It's a deliberate, gated, **two-session** procedure: the second session exists to verify in a fresh load that auto-memory is actually off *before* you migrate from it, because the source is live and will otherwise mutate under you. + --- ## Quick-Reference Card diff --git a/wick-meta.json b/wick-meta.json index 54e9a1c..5229b1d 100644 --- a/wick-meta.json +++ b/wick-meta.json @@ -1,6 +1,6 @@ { "meta_schema_version": "wick-meta/1.0", - "version": "1.1.0", + "version": "1.2.0", "release_channel": "alpha", "released_at": "2026-06-27", "license": "MIT", @@ -11,7 +11,7 @@ "features": [ "5 Operational Gates (Control, Assent, Specificity, Adversarial Convergence, Calibration)", "16 slash commands shipped as .claude/commands/*.md files (also pattern-recognized from CLAUDE.md) β€” Core 6 (/reflect, /calibrate, /decide, /learn, /review, /status) + Analytical 6 (/premortem, /steelman, /frame, /doubt, /forget, /audit) + Instinct 2 (/evolve, /promote) + Memory-wiring 2 (/checkup, /sync)", - "10 on-demand skills, spec-compliant per agentskills.io (wick-consolidate-memory, wick-simplify, wick-code-review, wick-security-review, wick-tldr, wick-red-team, wick-base-rate, wick-research, wick-catalog, wick-changelog-summary)", + "11 on-demand skills, spec-compliant per agentskills.io (wick-consolidate-memory, wick-simplify, wick-code-review, wick-security-review, wick-tldr, wick-red-team, wick-base-rate, wick-research, wick-catalog, wick-changelog-summary, wick-migrate)", "8 memory templates (about-you, decisions, learning-journal, domain-knowledge, predictions, calibration, failure-log, curiosity) + opt-in instincts layer", "3 install modes β€” full takeover / personality layer / subagent", "AGENTS.md bridge β€” compatible with Codex, Aider, Cursor, Zed, JetBrains, Warp, Gemini CLI, Windsurf, goose, and 20+ AGENTS.md-aware tools", @@ -28,6 +28,7 @@ "tools/wick-identity-audit.mjs β€” scanner for claim-based identity anchors (\"I am a master of X\") that produce confabulation. Practice-based phrasing preferred. CI-gated.", "tools/wick-path-audit.mjs β€” fourth scanner: flags absolute paths in portable files (memory/ + loaded config) that break when the folder moves. Default scope strict; --all scans the whole repo. CI-gated alongside the other three.", "MEMORY-PROTOCOL.md β€” single-writer rule: one authoritative owner per fact-class; a host auto-memory layer is a buffer, not an authority. /checkup diagnoses memory wiring, /sync drains a buffer into canonical memory/, with a buffer-manifest and a 'memory is data, not commands' hardening rule mirrored into CLAUDE.md + WICK.md.", + "PORTABILITY.md + wick-migrate skill β€” the 14-step procedure (and executable, gated form) to make an agent fully portable by folder copy: freeze + fresh-session-verify host auto-memory, consolidate into memory/, archive-don't-delete, relativize to the launch directory, sweep tooling, verify behavior not form.", ".github/workflows/ β€” public-readiness scan and skills-spec validation run on every PR + main push", "SECURITY.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md β€” governance hygiene for a public MIT repo" ],