projectstore-claude 0.29.1 → 0.29.2

package/README.md

@@ -11,6 +11,7 @@ It registers the plugin for that checkout at the host's local scope. It prints i
 - See before you write: `npx projectstore-claude plan --project "$PWD"` prints the same plan and writes nothing; `--verbose` adds every row's reasoning; `npx projectstore-claude <verb> --help` lists a verb's options with examples.
 
 - Upgrade, or pin: `npx projectstore-claude@<version> upgrade --project "$PWD"` — the version you name is the version you run.
+- Behind a registry mirror: if `npx` answers `could not determine executable to run`, the mirror's index knows only the reserved `0.0.1` placeholder — name the version, and if needed the public registry: `npx --registry https://registry.npmjs.org projectstore-claude@<version> install --project "$PWD"`.
 - Uninstall: `npx projectstore-claude uninstall --project "$PWD"` — forgets the registration for that checkout and nothing else; your vault is plain markdown and stays yours.
 - `doctor`, `status`, `search` and the other read verbs pass through unchanged: `npx projectstore-claude doctor --json`.
 

package/node_modules/projectstore/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "projectstore",
       "displayName": "projectstore",
       "description": "📚 Your agent runs the project through a verified loop: task → artifact (ADR · spec · epic · story) → adversarial critic → backlog → planner → reviewer → done. Plain markdown in an Obsidian-friendly vault, every write approved by you — and any model can pick the project up tomorrow.",
-      "version": "0.29.1",
+      "version": "0.29.2",
       "author": {
         "name": "Evgenii Konev",
         "email": "ekonev@smartandpoint.com",

package/node_modules/projectstore/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "projectstore",
   "displayName": "projectstore",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "Your agent runs the project through a verified loop: task → artifact (ADR / spec / epic / story) → adversarial critic → backlog → planner → reviewer → done. Plain markdown in git — any model can pick the project up tomorrow.",
   "author": {
     "name": "Evgenii Konev @ SmartAndPoint",

package/node_modules/projectstore/README.md

@@ -101,12 +101,20 @@ The same tree is published to npm as [`projectstore`](https://www.npmjs.com/pack
 plugin manifest, namespaced workflow and role skills, lifecycle hooks, and
 the exact bundled core. It stages a stable marketplace under `CODEX_HOME`,
 drives `codex plugin marketplace add` and `codex plugin add`, then reads the
-installation back and verifies its version and payload digest. Restart Codex,
+installation back and verifies its version and payload digest. Before it
+changes anything it asks Codex for that read-back (`codex plugin list --json`),
+so a Codex too old to answer stops the registration before it changes anything
+and tells you to upgrade Codex. Restart Codex,
 approve the hooks, and run `$projectstore-bind <vault-path>`. For later
 releases, `npx projectstore-codex@<version> upgrade --project "$PWD"`. Because
 Codex's plugin registry is user-global, ordinary uninstall removes only the
 project's agents block; `uninstall --global` is the explicit machine-wide
-removal. Codex is **experimental** until a live session has exercised every
+removal. If `npx` answers `could not determine executable to run`, your
+registry (often a company mirror) serves a stale index that knows only the
+reserved `0.0.1` placeholder: name the version, and if that is not enough, the
+public registry: `npx --registry https://registry.npmjs.org
+projectstore-codex@<version> install --project "$PWD"` (the same holds for
+`projectstore-claude`). Codex is **experimental** until a live session has exercised every
 surface it installs; [`docs/harnesses.md`](./docs/harnesses.md) says what has
 been measured and what has not. From a checkout, the same npx path runs against
 a built tarball:

package/node_modules/projectstore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectstore",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "Your agent runs the project through a verified loop: task → artifact (ADR / spec / epic / story) → adversarial critic → backlog → planner → reviewer → done. Plain markdown in git — any model can pick the project up tomorrow.",
   "keywords": [
     "project-management",

package/node_modules/projectstore/scripts/cli.mjs

@@ -43,7 +43,7 @@ import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import * as term from "./term.mjs";
 import { projectRootDeclared, childEnv, harnessIds, harnessForOverlay, pinPluginRoot } from "./harness.mjs";
-import { readConfigAt, readOverlayAt, resolveAgentModel, writeOverlayAt, overlayId, layoutRoster, commandForm } from "./lib.mjs";
+import { readConfigAt, readOverlayAt, resolveAgentModel, writeOverlayAt, overlayId, layoutRoster, commandForm, projectDirRefusal } from "./lib.mjs";
 import { READ_OPERATIONS, LINEAGE_KINDS, LINEAGE_DEFAULT_DEPTH, SEARCH_DEFAULT_LIMIT, GRAPH_EDGE_CAP, DIRECTIONS } from "./query.mjs";
 // binding.mjs is a write module imported statically where the install family
 // is lazy: it is a dependency-free leaf with no side effects, so the MCP
@@ -554,7 +554,10 @@ async function runAgents(ctx) {
     if (inBinding) lines.push("  the binding still carries an agents block — a pre-0.28 leftover; run upgrade");
     return emit("agents show", true, { harness, path: before.path, present: before.present, unparseable: before.unparseable, agents: before.agents, resolved, roster, unknown, rejected: before.rejected, agents_in_binding: inBinding }, lines.join("\n") + "\n");
   }
-  // configure
+  // configure — in a project that exists (the install spec, contract 19;
+  // the layout spec, contract 4): refused before the preview and the gate.
+  const missingProject = projectDirRefusal(project);
+  if (missingProject) return emit("agents configure", false, { error: missingProject }, `${missingProject}\n`);
   if (!harness) return usage("no harness detected and none named: agents configure names --harness <id>");
   if (before.unparseable) return emit("agents configure", false, { error: `${before.path} is not valid JSON; fix or remove it first`, harness, path: before.path }, `${before.path} is not valid JSON; fix or remove it first\n`);
   if (!values.reset && values.default === undefined && !(values.agent || []).length) return usage("agents configure takes --default <model>, --agent <name>=<model> (repeatable) or --reset");

package/node_modules/projectstore/scripts/install-harness.mjs

@@ -69,7 +69,7 @@ import { loadHarness, loadHarnesses, harnessIds, sourceHarness, detectHarnesses,
 import { FOREIGN_TEXT, GRAMMAR_VERSION } from "./provenance.mjs";
 import { analyseBlock, analyseJsonEntry, analyseStampedFile, analyseRegistration, analysePortableRegistration, analyseLayout, isOurFile, readText } from "./surfaces.mjs";
 import { payloadFiles, renderPortableCatalog } from "./portable-registration.mjs";
-import { pluginRoot, writeFileAtomic, writeExclusiveMetadata, ensureStateDir, ensureRuntimeDir, removeAgentsBlock, replaceAgentsBlock, readConfigAt, isPluginCacheRoot, isEphemeralRoot, statusLineIsOurWiring, claudeHome, packageDigest, writeOwnTree, removeOwnTree, cmpPrecedence, importsLine, whichOnPath as whichOnPathFromLib, moveStateDir, mergeEntryLog, movePath, removeInside, statusLineScriptPath, layoutPaths, stagePortableMarketplace, finishPortableMarketplace, rollbackPortableMarketplace, removeTreeUnder } from "./lib.mjs";
+import { pluginRoot, writeFileAtomic, writeExclusiveMetadata, ensureStateDir, ensureRuntimeDir, removeAgentsBlock, replaceAgentsBlock, readConfigAt, isPluginCacheRoot, isEphemeralRoot, statusLineIsOurWiring, claudeHome, packageDigest, writeOwnTree, removeOwnTree, cmpPrecedence, importsLine, whichOnPath as whichOnPathFromLib, moveStateDir, mergeEntryLog, movePath, removeInside, statusLineScriptPath, layoutPaths, stagePortableMarketplace, finishPortableMarketplace, rollbackPortableMarketplace, removeTreeUnder, projectDirRefusal } from "./lib.mjs";
 
 import { GENERATOR } from "./surfaces.mjs";
 export { GENERATOR };
@@ -373,6 +373,15 @@ function planPortableRegistration(ctx, key, s) {
   if (!a.market) steps.push(hostStep(a, s, "marketplace_add", fill, "register the stable local marketplace source globally"));
   if (!a.installed || a.installedVersion !== a.desiredVersion || mustWrite) steps.push(hostStep(a, s, "install", fill, `materialise and enable ${a.id} from the staged source`));
   steps.push(hostStep(a, s, "list", fill, "read back host-reported installation and effective enablement"));
+  // Asked first, before anything changes: the command the registration's own
+  // verification needs. A host too old to answer it stops the run with nothing
+  // staged, journaled or registered (issue #28: a codex without `plugin list
+  // --json` failed only at verification, after it had added the marketplace
+  // and the plugin; the install spec's 2026-09-29 amendment, as amended
+  // 2026-10-05).
+  if (steps.some((x) => x.kind === "portable-write" || (x.kind === "host" && x.name !== "list"))) {
+    steps.unshift({ ...hostStep(a, s, "list", fill, "check that the host can report what it installs, before anything changes"), name: "preflight" });
+  }
   return [{ ...base, action: a.state === "absent" ? "create" : "update", steps, verify: { version: a.desiredVersion, digest }, reason: a.reason }];
 }
 
@@ -590,6 +599,16 @@ export function plan(projectDir, { harnesses = [], mode = "install", env = proce
     out.ok = false;
     return out;
   }
+  // A project that does not exist is refused before contract 8's detection
+  // could stand in for it ("no harness detected"), and before anything is
+  // written, staged, locked or spawned (contract 19).
+  const missing = projectDirRefusal(projectDir);
+  if (missing) {
+    out.harnesses = named;
+    out.refusals.push(missing);
+    out.ok = false;
+    return out;
+  }
   if (!ids.length) {
     out.refusals.push(harnessRefusal(projectDir));
     out.ok = false;
@@ -1118,7 +1137,7 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
     const r = spawn(bin || s.cli.bin, argv, { env: childEnv, cwd: p.projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
     const rows = !r.error && r.status === 0 ? portableListFacts(r.stdout) : null;
     out.steps.push({ kind: "portable-recovery-list", argv: [s.cli.bin, ...argv], status: r.status ?? null, ok: Boolean(rows) });
-    return { rows, stderr: String((r.stderr || "") + (r.error ? r.error.message : "")).trim() };
+    return { rows, stderr: r.error ? startFailure(r.error, { bin: s.cli.bin, resolved: bin, cwd: p.projectDir }) : String(r.stderr || "").trim() };
   };
   const observedPortable = (a) => ({
     dir_exists: existsSync(a.paths.dir),
@@ -1142,7 +1161,7 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
   };
   const verifyPrevious = (previous) => {
     const listed = readHostList();
-    if (!listed.rows) return { ok: false, why: listed.stderr || "Codex plugin list did not return JSON" };
+    if (!listed.rows) return { ok: false, unanswered: true, why: listed.stderr || "Codex plugin list did not return JSON" };
     const row = listed.rows.find((entry) => entry?.pluginId === i.entry) || null;
     if (!previous) {
       const a = analysePortableRegistration(p.projectDir, s, { root: p.root, home, harness, env: childEnv, ignoreJournal: true });
@@ -1171,10 +1190,21 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
     const ok = a.state === "current" && a.installedVersion === previous.version && a.enabled === previous.enabled && sourceOk && cacheOk && hostOk;
     return ok ? { ok: true } : { ok: false, why: `restored source/cache/enablement could not be proven (state=${a.state}, version=${a.installedVersion || "?"}, enabled=${String(a.enabled)})` };
   };
+  // A journal keeps its history (issue #28): the first failure's error and
+  // time stay as written; a later run that re-checks and still cannot prove
+  // the previous state adds its own reason and time beside them. The message
+  // says the error is a previous run's, where the journal is, and what lifts it.
   const requireRecovery = (journal, why) => {
-    writeFileAtomic(journalPath, JSON.stringify({ ...journal, phase: "recovery-required", error: why }, null, 2) + "\n", { sweep: false });
+    const now = new Date().toISOString();
+    const again = journal.phase === "recovery-required";
+    const record = again
+      ? { ...journal, rechecked_at: now, recheck_error: why }
+      : { ...journal, phase: "recovery-required", error: why, failed_at: now };
+    writeFileAtomic(journalPath, JSON.stringify(record, null, 2) + "\n", { sweep: false });
     releaseLock();
-    out.failed = { step: "recovery-required", status: null, stderr: `${why}; ${journalPath} was retained and blocks automatic mutation` };
+    out.failed = { step: "recovery-required", status: null, stderr: again
+      ? `a previous run (${journal.failed_at || "time not recorded"}) could not prove its restore: ${String(journal.error || "no error recorded").split("\n")[0]}. This run re-checked the previous state and could not prove it either: ${why}. ${journalPath} is kept: a later run lifts it once the previous state proves, or inspect the registration and remove the journal to start over`
+      : `${why}; ${journalPath} was retained and blocks automatic mutation until a later run proves the previous state` };
     return out;
   };
   if (portable) {
@@ -1219,22 +1249,43 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
         releaseLock(); out.failed = { step: "recovery", status: null, stderr: `${journalPath} does not describe this owned marketplace; inspect it before retrying` }; return out;
       }
       try {
-        if (journal.phase === "recovery-required") return requireRecovery(journal, journal.error || "a prior registration could not prove restoration");
-        if (journal.phase === "verified") finishPortableMarketplace(journal.target, journal.backup || null);
+        // A recovery the rollback could not prove is re-proved here, under the
+        // lock, with the rollback's own checks: it lifts when they hold, and is
+        // refused with its history kept when they do not (the install spec's
+        // 2026-09-29 amendment, as amended 2026-10-05).
+        let lifted = null;
+        if (journal.phase === "recovery-required") {
+          const proven = verifyPrevious(journal.previous || null);
+          // A host that cannot answer the proof's read-back is the case issue
+          // #28 met with a journal still in place: say what to do about it.
+          if (!proven.ok) return requireRecovery(journal, proven.unanswered
+            ? `${proven.why}\nThe re-check could not ask ${harness.display_name || s.cli.bin} (\`${[s.cli.bin, ...(s.cli.commands.list || [])].join(" ")}\`); if it is too old to answer, upgrade it, then run this again.`
+            : proven.why);
+          lifted = journal;
+        } else if (journal.phase === "verified") finishPortableMarketplace(journal.target, journal.backup || null);
         else if (journal.phase === "swapped" || (journal.phase === "prepare" && journal.backup && existsSync(journal.backup))) rollbackPortableMarketplace(journal.target, journal.backup || null);
         else if (journal.phase === "prepare" && !journal.previous && existsSync(journal.target)) {
           if (!ownedTargetMatches(journal.target, journal.next)) return requireRecovery(journal, `first-install recovery found an unrecognised target at ${journal.target}`);
           rollbackPortableMarketplace(journal.target, null);
         }
-        if (existsSync(journal.stage)) removeTreeUnder(journal.stage, i.home);
-        if (journal.phase !== "verified") {
+        if (existsSync(journal.stage) && resolve(journal.stage) !== resolve(i.path)) removeTreeUnder(journal.stage, i.home);
+        if (journal.phase !== "verified" && !lifted) {
           const restored = verifyPrevious(journal.previous || null);
           if (!restored.ok) return requireRecovery(journal, restored.why);
         }
         unlinkSync(journalPath);
-        out.steps.push({ kind: "portable-recover", phase: journal.phase || "unknown", ok: true });
+        out.steps.push({ kind: "portable-recover", phase: journal.phase || "unknown", ok: true, ...(lifted ? { lifted: lifted.error || null, failed_at: lifted.failed_at || null } : {}) });
+        // Only a lifted recovery prints a line of its own: the other phases'
+        // APPLY reads as it did. After the proof, whose host list has its line.
+        if (lifted && onStep) {
+          const st = { kind: "recover", path: journalPath, lifted: lifted.error || "" };
+          onStep(st, "start");
+          onStep(st, "end", { ok: true });
+        }
       } catch (e) {
-        releaseLock(); out.failed = { step: "recovery", status: null, stderr: e && e.message ? e.message : String(e) }; return out;
+        releaseLock();
+        out.failed = { step: "recovery", status: null, stderr: `${e && e.message ? e.message : String(e)}; ${journalPath} is kept: a later run retries it, or inspect the registration and remove the journal to start over` };
+        return out;
       }
     }
     const current = analysePortableRegistration(p.projectDir, s, { root: p.root, home, harness, env: childEnv, ignoreJournal: true });
@@ -1281,7 +1332,8 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
           const args = template.map((t) => t.replace(/\{(\w+)\}/g, (_, k) => fill[k] ?? `{${k}}`));
           const bin = whichOnPathFromLib(s.cli.bin, env);
           const r = spawn(bin || s.cli.bin, args, { env: childEnv, cwd: p.projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
-          out.steps.push({ kind: "portable-compensate", name, argv: [s.cli.bin, ...args], status: r.status ?? null, ok: !r.error && r.status === 0 });
+          const ok = !r.error && r.status === 0;
+          out.steps.push({ kind: "portable-compensate", name, argv: [s.cli.bin, ...args], status: r.status ?? null, ok, ...(ok ? {} : { stderr: r.error ? startFailure(r.error, { bin: s.cli.bin, resolved: bin, cwd: p.projectDir }) : String((r.stderr || "") + (r.stdout || "")).trim() }) });
         }
       }
       try {
@@ -1351,10 +1403,27 @@ function applyRegistration(p, i, { env, spawn, home, onStep = null }) {
     } else if (st.kind === "host") {
       const bin = whichOnPathFromLib(st.bin, env);
       const r = spawn(bin || st.bin, st.argv, { env: childEnv, cwd: p.projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
-      const ok = !r.error && r.status === 0;
-      const said = String((r.stderr || "") + (ok ? "" : r.stdout || "") + (r.error ? r.error.message : "")).trim();
-      out.steps.push({ kind: "host", argv: [st.bin, ...st.argv], status: r.status ?? null, ok, ...(ok ? {} : { stderr: said }) });
-      if (!ok) return fail(st.name, r.status ?? null, said, [st.bin, ...st.argv]);
+      const ran = !r.error && r.status === 0;
+      // A preflight that ran must also answer in the shape verification reads:
+      // a host that exits 0 with text would pass on its status alone.
+      const unreadable = ran && portable && st.name === "preflight" && portableListFacts(r.stdout) === null;
+      const ok = ran && !unreadable;
+      // A command that did not start says why (contract 19); one that ran and
+      // failed says what it said. A preflight the host ran and could not
+      // answer adds what that means; one that never started does not, since
+      // upgrading the host would not help.
+      const said = r.error
+        ? startFailure(r.error, { bin: st.bin, resolved: bin, cwd: p.projectDir })
+        : unreadable
+          ? `${[st.bin, ...st.argv].join(" ")} answered, but not with the JSON the registration reads`
+          : String((r.stderr || "") + (ok ? "" : r.stdout || "")).trim();
+      const told = !ok && st.name === "preflight" && !r.error
+        ? `${said}\nThe registration needs \`${[st.bin, ...st.argv].join(" ")}\` to verify what it installs, so it changed nothing. Upgrade ${harness.display_name || st.bin}, then run this again.`
+        : said;
+      out.steps.push({ kind: "host", argv: [st.bin, ...st.argv], status: r.status ?? null, ok, ...(ok ? {} : { stderr: told }) });
+      // An unreadable answer exited 0; STOPPED names it by what it said, as
+      // the final list's own failure does, not by an "exited 0".
+      if (!ok) return fail(st.name, unreadable ? null : r.status ?? null, told, [st.bin, ...st.argv]);
       if (portable && st.name === "list") {
         hostList = portableListFact(r.stdout, i.entry);
         if (!hostList) return fail("list", null, `${st.bin} ${st.argv.join(" ")} did not report ${i.entry} in JSON output`, [st.bin, ...st.argv]);
@@ -1403,6 +1472,19 @@ function homeEnvName(harnessId) {
   try { return loadHarness(harnessId).runtime.home_env; } catch { return sourceHarness().runtime.home_env; }
 }
 
+// What Node cannot say: spawnSync reports a working directory that does not
+// exist and a binary not on PATH with the same `spawnSync <bin> ENOENT`
+// (measured 2026-10-05). The filesystem tells them apart, in this order (the
+// install spec, contract 19); any other error passes through as Node wrote it.
+function startFailure(err, { bin, resolved, cwd }) {
+  let dir = false;
+  try { dir = statSync(cwd).isDirectory(); } catch {}
+  if (!dir) return `${bin} could not start: the working directory ${JSON.stringify(String(cwd))} is not an existing directory`;
+  if (!resolved) return `${bin} could not start: it was not found on PATH`;
+  if (["ENOENT", "EACCES", "ENOEXEC"].includes(err?.code)) return `${bin} could not start: ${resolved} exists but could not be run (${err.code})`;
+  return String(err?.message || err);
+}
+
 // rmdirSync refuses a non-empty directory — that refusal IS the guarantee
 // (contract 13): we prune only a directory we emptied. The runtime dir's own
 // .gitignore does not count as content.
@@ -1499,6 +1581,7 @@ function stepLabel(p, st) {
   const r = (x) => tilde(rel(p.projectDir, x));
   switch (st.kind) {
     case "portable-write": return `stage ${r(st.path)}`;
+    case "recover": return `lift ${r(st.path)} — the previous state proved${st.lifted ? `; it held: ${String(st.lifted).split("\n")[0]}` : ""}`;
     case "write": return `write ${r(st.path)}`;
     case "unregister": return `edit ${r(st.path)} [${st.pointer}.${st.name}]`;
     case "ensure": return `ensure ${r(st.path)}/`;

package/node_modules/projectstore/scripts/lib.mjs

@@ -689,6 +689,18 @@ export function installChannel(root, { home = homedir(), harness = sourceHarness
   return own && marketplace === own.marketplace_name ? "registration" : "marketplace";
 }
 
+// A write verb works in a project that exists (the install spec, contract 19):
+// install, upgrade, uninstall and plan, and agents configure, refuse a path
+// that is not an existing directory before anything is written, staged or
+// spawned. The path is quoted, so a trailing comma, space or newline shows: a
+// `--project "$PWD",` pasted from a chat once created `ProjectStore,/` and
+// wrote an AGENTS.md into it (2026-10-05). bind refuses the same way
+// (NO_PROJECT, binding.mjs).
+export function projectDirRefusal(dir) {
+  try { if (statSync(dir).isDirectory()) return null; } catch {}
+  return `no such project directory: ${JSON.stringify(String(dir))} — nothing is written`;
+}
+
 // ─── Status line wiring (SessionStart-managed) ─────────────────────────
 //
 // The Claude Code statusLine slot is single and NOT plugin-declarable, so

package/node_modules/projectstore/scripts/portable-registration.mjs

@@ -179,7 +179,12 @@ export function analysePortableRegistration(projectDir, s, { root, payloadRoot:
   try { desiredDigest = payloadDigest(payloadRoot); } catch (e) { return { ...out, state: "unavailable", reason: e.message }; }
   out.desiredDigest = desiredDigest;
   if (enabledOther) return { ...out, state: "conflict", refusal: `${enabledOther.id} is already enabled; two ProjectStore plugins would load the same skills and hooks. Disable or remove that registration explicitly, then retry` };
-  if (journal && !ignoreJournal) return { ...out, state: "stale", reason: "an interrupted registration has a recovery journal; the next confirmed run recovers it before applying this plan" };
+  // A journal the rollback could not prove names the run that left it, when,
+  // and its error, so the reader of the plan is not told recovery is assured
+  // (issue #28). Every other phase reads as before.
+  if (journal && !ignoreJournal) return { ...out, state: "stale", reason: journal.phase === "recovery-required"
+    ? `a previous run${journal.failed_at ? ` (${journal.failed_at})` : ""} could not prove its restore: ${String(journal.error || "no error recorded").split("\n")[0]}; this run re-proves the previous state before applying this plan, and refuses if it cannot (${paths.journal})`
+    : "an interrupted registration has a recovery journal; the next confirmed run recovers it before applying this plan" };
   if (existsSync(paths.dir) && !ownership) return { ...out, state: "foreign", refusal: `${paths.dir} exists without ${s.ownership_manifest}; a source this installer does not own holds the stable marketplace path` };
   if (market?.source && !samePath(market.source, paths.dir)) return { ...out, state: "foreign", refusal: `${paths.globalConfig} points marketplace ${s.marketplace_name} at ${market.source}, not ${paths.dir}` };
   if (nothing) return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectstore-claude",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "Installs projectstore for Claude Code from npm: the core pinned and bundled, the harness fixed — npx projectstore-claude install --project \"$PWD\".",
   "keywords": [
     "projectstore",
@@ -37,7 +37,7 @@
     "README.md"
   ],
   "dependencies": {
-    "projectstore": "=0.29.1"
+    "projectstore": "=0.29.2"
   },
   "bundleDependencies": [
     "projectstore"