instar 1.3.152 → 1.3.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.152",
+  "version": "1.3.154",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/assemble-next-md.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * assemble-next-md — fold per-PR release-note FRAGMENTS into a single NEXT.md.
+ *
+ * ── Why this exists ───────────────────────────────────────────────────
+ * The release pipeline consumes a single shared `upgrades/NEXT.md` per merge.
+ * With many agents merging concurrently, EVERY PR rewrote that one file, so
+ * every PR collided on it within minutes — the release notes became an
+ * un-landable hot file. The fix is per-PR FRAGMENTS: each PR ships its note as
+ * `upgrades/next/<slug>.md`, touching a distinct file, so two PRs never
+ * collide. This script concatenates the fragments into `upgrades/NEXT.md`
+ * BEFORE the existing publish pipeline runs, leaving everything downstream
+ * unchanged.
+ *
+ * ── What it does ──────────────────────────────────────────────────────
+ *   1. Reads every `upgrades/next/*.md` fragment (deterministic filename sort).
+ *   2. Folds in a legacy `upgrades/NEXT.md` too, if one exists (backward compat).
+ *   3. Merges by section: the result has ONE "## What Changed", ONE
+ *      "## Summary of New Capabilities", ONE "## What to Tell Your User", ONE
+ *      "## Evidence" — each section is the concatenation of that section across
+ *      all inputs (in source order). Any non-canonical H2 section is preserved
+ *      and appended after the canonical ones (also concatenated by title).
+ *   4. The bump directive is the HIGHEST tier among the inputs
+ *      (major > minor > patch), emitted as `<!-- bump: X -->`. This is a
+ *      documentation hint only — the REAL release tier is
+ *      `.instar/release-tier.json`, which this script never touches.
+ *   5. Writes the merged result to `upgrades/NEXT.md`.
+ *
+ * ── No-op / failure semantics ─────────────────────────────────────────
+ *   - NO fragments AND NO legacy NEXT.md → does nothing, exits 0 quietly. The
+ *     existing publish "skip if no NEXT.md" logic then fires unchanged.
+ *   - A real malformation (a fragment with content but no parseable H2 section
+ *     at all) → exits non-zero with a clear message, so the workflow fails
+ *     loudly rather than shipping a broken guide.
+ *   - Idempotent: running twice produces the same NEXT.md. (When a generated
+ *     NEXT.md is the ONLY input — no fragments — it is re-emitted byte-stable.)
+ *
+ * The core `assembleNextMd()` function is pure (string in / string out) and is
+ * exported for unit testing. The CLI wrapper at the bottom handles I/O.
+ *
+ * Usage:
+ *   node scripts/assemble-next-md.mjs            # assemble + write upgrades/NEXT.md
+ *   node scripts/assemble-next-md.mjs --upgrades-dir <path>   # override (tests)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+// ── Canonical section order ───────────────────────────────────────────
+// These four are the sections check-upgrade-guide.js / upgrade-guide-validator
+// know about. We emit them in this order; any other H2 is appended after.
+export const CANONICAL_SECTIONS = [
+  'What Changed',
+  'What to Tell Your User',
+  'Summary of New Capabilities',
+  'Evidence',
+];
+
+const BUMP_RANK = { patch: 0, minor: 1, major: 2 };
+const RANK_BUMP = ['patch', 'minor', 'major'];
+
+const H1_HEADER = '# Upgrade Guide — vNEXT';
+
+// Stable marker stamped into every machine-assembled NEXT.md. It lets us
+// recognize (and skip re-folding) a NEXT.md that this script generated, which
+// is what keeps the on-disk assemble idempotent: a second run shouldn't fold
+// the previous run's output back in on top of the still-present fragments. A
+// hand-authored legacy NEXT.md (no marker) is still folded for backward compat.
+export const GENERATED_MARKER = '<!-- assembled-by: assemble-next-md -->';
+
+/** True when content was produced by this assembler (carries the marker). */
+export function isAssembledOutput(content) {
+  return String(content).includes(GENERATED_MARKER);
+}
+
+/**
+ * Parse the declared bump type from a fragment's `<!-- bump: TYPE -->` comment.
+ * Returns 'patch' | 'minor' | 'major' | null.
+ */
+export function parseBumpType(content) {
+  const match = /<!--\s*bump:\s*(patch|minor|major)\s*-->/i.exec(content);
+  return match ? match[1].toLowerCase() : null;
+}
+
+/**
+ * Split a fragment body into H2 sections: [{ title, body }] in source order.
+ * `body` excludes the heading line itself and is right-trimmed.
+ * Content before the first H2 (H1 header, bump comment, stray prose) is dropped
+ * from the section map — the assembler synthesizes a fresh H1 + bump comment.
+ */
+export function parseSections(content) {
+  const out = [];
+  const lines = String(content).replace(/\r\n/g, '\n').split('\n');
+  let current = null;
+  for (const line of lines) {
+    const m = /^##\s+(.+?)\s*$/.exec(line);
+    if (m) {
+      if (current) out.push(current);
+      current = { title: m[1].trim(), lines: [] };
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  if (current) out.push(current);
+  return out.map((s) => ({ title: s.title, body: s.lines.join('\n').replace(/\s+$/, '') }));
+}
+
+/**
+ * Is this fragment content "empty" for assembly purposes? True when stripping
+ * HTML comments and whitespace leaves nothing.
+ */
+function isEffectivelyEmpty(content) {
+  return String(content).replace(/<!--[\s\S]*?-->/g, '').trim().length === 0;
+}
+
+/**
+ * Core assembler. Pure: takes named fragment inputs, returns the merged NEXT.md
+ * string (or throws on a real malformation).
+ *
+ * @param {Array<{ name: string, content: string }>} fragments
+ *   Each input fragment, in the order they should be concatenated. `name` is
+ *   used only for error messages.
+ * @returns {string} the assembled NEXT.md content (with trailing newline).
+ * @throws {Error} when a fragment has content but no parseable H2 section.
+ */
+export function assembleNextMd(fragments) {
+  // Idempotency guard: a previously-assembled NEXT.md (carrying GENERATED_MARKER)
+  // is the FOLD of the current fragments — folding it again on top of the same
+  // fragments would duplicate every section. So when at least one non-generated
+  // input is present, drop the generated one(s). When a generated output is the
+  // SOLE input (no fragments), keep it: parse→emit is stable, so it re-emits
+  // identically.
+  const nonGenerated = fragments.filter((f) => !isAssembledOutput(f.content ?? ''));
+  const effective = nonGenerated.length > 0 ? nonGenerated : fragments;
+
+  // Map title -> array of section bodies (in source order).
+  const merged = new Map();
+  // Preserve first-seen order of non-canonical titles.
+  const extraOrder = [];
+  let maxBumpRank = 0;
+  let sawAnyBump = false;
+
+  for (const frag of effective) {
+    const content = frag.content ?? '';
+    const bump = parseBumpType(content);
+    if (bump) {
+      sawAnyBump = true;
+      maxBumpRank = Math.max(maxBumpRank, BUMP_RANK[bump]);
+    }
+
+    const sections = parseSections(content);
+    if (sections.length === 0) {
+      // No H2 sections. An effectively-empty fragment (only comments/whitespace)
+      // is malformed — a fragment file should always carry real notes.
+      // A fragment with real prose but no headings is also malformed: we can't
+      // place its content under a known section.
+      throw new Error(
+        `release-note fragment "${frag.name}" has no recognizable "## " section. ` +
+        `Every fragment must contain at least one section heading ` +
+        `(e.g. "## What Changed"). Fix or remove this fragment.`,
+      );
+    }
+
+    for (const sec of sections) {
+      const body = sec.body.trim();
+      // Skip a section whose body is only whitespace/comments — nothing to fold.
+      if (isEffectivelyEmpty(body)) continue;
+      if (!merged.has(sec.title)) {
+        merged.set(sec.title, []);
+        if (!CANONICAL_SECTIONS.includes(sec.title)) extraOrder.push(sec.title);
+      }
+      merged.get(sec.title).push(body);
+    }
+  }
+
+  // If after folding there is genuinely nothing to say, that's a malformation
+  // for a non-empty input set (every fragment was comments-only).
+  if (merged.size === 0) {
+    throw new Error(
+      'release-note fragments produced no content — every section was empty. ' +
+      'Fill in at least "## What Changed" in one fragment.',
+    );
+  }
+
+  // Emit canonical sections first (only when present), then extras in
+  // first-seen order.
+  const titleOrder = [
+    ...CANONICAL_SECTIONS.filter((t) => merged.has(t)),
+    ...extraOrder,
+  ];
+
+  const bump = sawAnyBump ? RANK_BUMP[maxBumpRank] : 'patch';
+
+  const parts = [];
+  parts.push(H1_HEADER);
+  parts.push('');
+  parts.push(GENERATED_MARKER);
+  parts.push(`<!-- bump: ${bump} -->`);
+  parts.push('');
+  for (const title of titleOrder) {
+    const bodies = merged.get(title);
+    parts.push(`## ${title}`);
+    parts.push('');
+    // Concatenate each fragment's body for this section, separated by a blank
+    // line. Bodies were already trimmed.
+    parts.push(bodies.join('\n\n'));
+    parts.push('');
+  }
+
+  // Single trailing newline, no duplicate blank lines at EOF.
+  return parts.join('\n').replace(/\n+$/, '\n');
+}
+
+// ── CLI entry point ────────────────────────────────────────────────────
+
+/**
+ * Gather fragment inputs from disk in deterministic order: legacy NEXT.md first
+ * (so its content leads), then `next/*.md` sorted by filename.
+ */
+export function gatherFragmentInputs(upgradesDir) {
+  const inputs = [];
+
+  const legacyPath = path.join(upgradesDir, 'NEXT.md');
+  const fragmentsDir = path.join(upgradesDir, 'next');
+
+  let legacyContent = null;
+  if (fs.existsSync(legacyPath)) {
+    legacyContent = fs.readFileSync(legacyPath, 'utf-8');
+  }
+
+  let fragmentFiles = [];
+  if (fs.existsSync(fragmentsDir)) {
+    fragmentFiles = fs
+      .readdirSync(fragmentsDir)
+      .filter((f) => f.endsWith('.md'))
+      .sort((a, b) => a.localeCompare(b, 'en'));
+  }
+
+  // Fold the legacy NEXT.md in first — only when it carries real content
+  // (skip a bare template/empty file so re-runs are idempotent and a fresh
+  // template doesn't masquerade as content).
+  if (legacyContent !== null && !isEffectivelyEmpty(legacyContent)) {
+    inputs.push({ name: 'NEXT.md', content: legacyContent });
+  }
+
+  for (const file of fragmentFiles) {
+    const content = fs.readFileSync(path.join(fragmentsDir, file), 'utf-8');
+    inputs.push({ name: `next/${file}`, content });
+  }
+
+  return { inputs, hadLegacy: legacyContent !== null, fragmentCount: fragmentFiles.length };
+}
+
+function main() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const ROOT = path.resolve(__dirname, '..');
+
+  // Allow tests / callers to point at an alternate upgrades dir.
+  const argIdx = process.argv.indexOf('--upgrades-dir');
+  const upgradesDir =
+    argIdx !== -1 && process.argv[argIdx + 1]
+      ? path.resolve(process.argv[argIdx + 1])
+      : path.join(ROOT, 'upgrades');
+
+  const { inputs, hadLegacy, fragmentCount } = gatherFragmentInputs(upgradesDir);
+
+  if (inputs.length === 0) {
+    // No fragments and no (content-bearing) legacy NEXT.md. Do nothing — the
+    // existing publish skip logic handles the "nothing to publish" case.
+    console.log(
+      `[assemble-next-md] no fragments in ${path.join(upgradesDir, 'next')} ` +
+      `and no content-bearing NEXT.md — nothing to assemble.`,
+    );
+    process.exit(0);
+  }
+
+  let assembled;
+  try {
+    assembled = assembleNextMd(inputs);
+  } catch (err) {
+    console.error(`[assemble-next-md] ERROR: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+
+  const nextPath = path.join(upgradesDir, 'NEXT.md');
+  fs.mkdirSync(upgradesDir, { recursive: true });
+  fs.writeFileSync(nextPath, assembled);
+
+  console.log(
+    `[assemble-next-md] assembled ${fragmentCount} fragment(s)` +
+    `${hadLegacy ? ' + legacy NEXT.md' : ''} → ${path.relative(ROOT, nextPath)}`,
+  );
+  process.exit(0);
+}
+
+// Only run main() when invoked directly (not when imported by tests).
+// Compare resolved file URLs rather than string-concatenating argv[1] — that
+// naive form breaks on relative paths and paths containing spaces.
+function invokedDirectly() {
+  if (!process.argv[1]) return false;
+  try {
+    return import.meta.url === pathToFileURL(fs.realpathSync(process.argv[1])).href;
+  } catch {
+    return import.meta.url === pathToFileURL(process.argv[1]).href;
+  }
+}
+
+if (invokedDirectly()) {
+  main();
+}

package/scripts/pre-push-gate.js

@@ -14,11 +14,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { validateGuideContent } from './upgrade-guide-validator.mjs';
+import { assembleNextMd, gatherFragmentInputs } from './assemble-next-md.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '..');
 const upgradesDir = path.join(ROOT, 'upgrades');
-const nextPath = path.join(ROOT, 'upgrades', 'NEXT.md');
 const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
 const version = pkg.version;
 
@@ -34,38 +34,66 @@ const REQUIRED_SECTIONS = [
 let errors = [];
 let warnings = [];
 
-// ── 1. NEXT.md validation ─────────────────────────────────────────────
+// ── 1. Release-note validation (fragment-aware) ───────────────────────
+//
+// Release notes are authored as per-PR FRAGMENTS in upgrades/next/<slug>.md
+// (so concurrent PRs never collide on a single shared NEXT.md). The pre-push
+// gate validates the ASSEMBLED result — fragments folded together with any
+// legacy upgrades/NEXT.md — so a PR that ships only a fragment passes the same
+// section/content checks the publish gate enforces. We assemble in-memory and
+// NEVER write NEXT.md to disk here: the PR keeps its fragment, not a generated
+// guide. publish.yml runs the real assemble step before publishing.
 
 const versionedGuidePath = path.join(upgradesDir, `${version}.md`);
 const versionedGuideExists = fs.existsSync(versionedGuidePath);
-const nextExists = fs.existsSync(nextPath);
-
-// Pick the active guide for this push. NEXT.md wins if present (in-flight
-// release notes); fall back to the versioned guide once NEXT.md has been
-// renamed during a publish.
-const activeGuidePath = nextExists
-  ? nextPath
-  : (versionedGuideExists ? versionedGuidePath : null);
-const activeGuideLabel = nextExists
-  ? 'NEXT.md'
-  : (versionedGuideExists ? `${version}.md` : null);
 
-if (activeGuidePath && activeGuideLabel) {
-  const content = fs.readFileSync(activeGuidePath, 'utf-8');
+// Assemble fragments + legacy NEXT.md in-memory.
+let assembledContent = null;
+let assembleError = null;
+{
+  const { inputs } = gatherFragmentInputs(upgradesDir);
+  if (inputs.length > 0) {
+    try {
+      assembledContent = assembleNextMd(inputs);
+    } catch (err) {
+      assembleError = err instanceof Error ? err.message : String(err);
+    }
+  }
+}
 
+// The active guide for validation: the assembled fragments/NEXT.md (in-flight
+// release notes) win when present; otherwise fall back to the versioned guide
+// (post-release-cut state, when NEXT.md has been renamed and no new fragment is
+// staged yet).
+const activeGuideLabel = assembledContent !== null
+  ? 'assembled release notes (upgrades/next/*.md + NEXT.md)'
+  : (versionedGuideExists ? `${version}.md` : null);
+
+if (assembleError) {
+  // A malformed fragment must fail the push loudly — the same loud failure the
+  // publish workflow would hit.
+  errors.push(`Release-note fragments are malformed: ${assembleError}`);
+} else if (assembledContent !== null) {
   // Run the shared validator (same checks as check-upgrade-guide.js at publish
   // time). This catches the publish-blocker bugs that previously slipped past
   // pre-push: inline code / fenced blocks / camelCase config keys in "What to
   // Tell Your User", and missing "## Evidence" when "What Changed" claims a fix.
   // Before this gate, those defects only surfaced as silently-dropped publish
   // runs on main — agents never received the merged code.
-  const validatorIssues = validateGuideContent(content);
+  const validatorIssues = validateGuideContent(assembledContent);
   for (const issue of validatorIssues) {
     errors.push(`${activeGuideLabel}: ${issue}`);
   }
+} else if (versionedGuideExists) {
+  const content = fs.readFileSync(versionedGuidePath, 'utf-8');
+  const validatorIssues = validateGuideContent(content);
+  for (const issue of validatorIssues) {
+    errors.push(`${version}.md: ${issue}`);
+  }
 } else {
   errors.push(
-    `No upgrade guide found. Create upgrades/NEXT.md with sections: ${REQUIRED_SECTIONS.join(', ')}`
+    `No upgrade guide found. Create a release-note fragment ` +
+    `upgrades/next/<slug>.md (or legacy upgrades/NEXT.md) with sections: ${REQUIRED_SECTIONS.join(', ')}`
   );
 }
 
@@ -221,14 +249,16 @@ if (!process.env.CI) {
     /\bnew\b/i,
   ];
 
-  // When NEXT.md exists, it represents the *next* shipment being prepared in
-  // this push — prefer it over the (frozen) versioned guide, which describes
-  // the already-released version and isn't what this PR is changing. This is
-  // the post-release-cut + new-PR state: both files coexist, but only NEXT.md
-  // is in flight. Falls back to the versioned guide when no NEXT.md is staged.
-  const guidePath = nextExists ? nextPath : (versionedGuideExists ? versionedGuidePath : null);
-  if (guidePath && fs.existsSync(guidePath)) {
-    const guideContent = fs.readFileSync(guidePath, 'utf-8');
+  // The in-flight release notes (assembled fragments + legacy NEXT.md) represent
+  // the *next* shipment being prepared in this push — prefer them over the
+  // (frozen) versioned guide, which describes the already-released version and
+  // isn't what this PR is changing. Falls back to the versioned guide when no
+  // fragment / NEXT.md is staged (post-release-cut state).
+  const inFlight = assembledContent !== null;
+  const guideContent = inFlight
+    ? assembledContent
+    : (versionedGuideExists ? fs.readFileSync(versionedGuidePath, 'utf-8') : null);
+  if (guideContent !== null) {
     // Extract "## What Changed" section
     const whatChangedMatch = guideContent.match(/## What Changed\s*([\s\S]*?)(?=\n##\s|$)/);
     const whatChanged = whatChangedMatch ? whatChangedMatch[1] : '';
@@ -237,10 +267,10 @@ if (!process.env.CI) {
 
     if (qualifies) {
       const sideEffectsDir = path.join(ROOT, 'upgrades', 'side-effects');
-      // If NEXT.md is the active guide, any fresh artifact (last 24h) counts —
-      // the versioned-filename requirement only applies when a versioned guide
-      // is being validated without an in-flight NEXT.md.
-      const artifactName = (!nextExists && versionedGuideExists) ? `${version}.md` : null;
+      // When in-flight notes (fragments/NEXT.md) drive the push, any fresh
+      // artifact (last 24h) counts — the versioned-filename requirement only
+      // applies when a versioned guide is being validated without in-flight notes.
+      const artifactName = (!inFlight && versionedGuideExists) ? `${version}.md` : null;
       let artifactFound = false;
 
       if (fs.existsSync(sideEffectsDir)) {
@@ -248,9 +278,9 @@ if (!process.env.CI) {
         if (artifactName) {
           artifactFound = files.includes(artifactName);
         } else {
-          // For NEXT.md, any fresh artifact from the last 24h counts.
-          // The expectation is that during release cut, NEXT.md -> <version>.md
-          // rename will pair with the artifact rename as well.
+          // For in-flight notes (fragments/NEXT.md), any fresh artifact from the
+          // last 24h counts. The expectation is that during release cut, the
+          // fragment/NEXT.md -> <version>.md rename pairs with an artifact rename.
           const recent = files.filter((f) => {
             const stat = fs.statSync(path.join(sideEffectsDir, f));
             return Date.now() - stat.mtimeMs < 24 * 60 * 60 * 1000;

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-05-31T09:03:11.651Z",
-  "instarVersion": "1.3.152",
+  "generatedAt": "2026-05-31T09:22:25.465Z",
+  "instarVersion": "1.3.154",
   "entryCount": 193,
   "entries": {
     "hook:session-start": {
@@ -11,7 +11,7 @@
       "domain": "identity",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/session-start.sh",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:dangerous-command-guard": {
@@ -20,7 +20,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/dangerous-command-guard.sh",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:grounding-before-messaging": {
@@ -29,7 +29,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/grounding-before-messaging.sh",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:compaction-recovery": {
@@ -38,7 +38,7 @@
       "domain": "identity",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/compaction-recovery.sh",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:external-operation-gate": {
@@ -47,7 +47,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/external-operation-gate.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:deferral-detector": {
@@ -56,7 +56,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/deferral-detector.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:post-action-reflection": {
@@ -65,7 +65,7 @@
       "domain": "evolution",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/post-action-reflection.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:external-communication-guard": {
@@ -74,7 +74,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/external-communication-guard.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:scope-coherence-collector": {
@@ -83,7 +83,7 @@
       "domain": "coherence",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/scope-coherence-collector.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:scope-coherence-checkpoint": {
@@ -92,7 +92,7 @@
       "domain": "coherence",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/scope-coherence-checkpoint.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:free-text-guard": {
@@ -101,7 +101,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/free-text-guard.sh",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:claim-intercept": {
@@ -110,7 +110,7 @@
       "domain": "coherence",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/claim-intercept.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:claim-intercept-response": {
@@ -119,7 +119,7 @@
       "domain": "coherence",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/claim-intercept-response.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:stop-gate-router": {
@@ -128,7 +128,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/stop-gate-router.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "hook:auto-approve-permissions": {
@@ -137,7 +137,7 @@
       "domain": "safety",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
       "installedPath": ".instar/hooks/instar/auto-approve-permissions.js",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "job:health-check": {
@@ -1489,7 +1489,7 @@
       "type": "subsystem",
       "domain": "updates",
       "sourcePath": "src/core/PostUpdateMigrator.ts",
-      "contentHash": "3418f7109a38172a28a3a202c8a878c1064f55911a82155c53a0b1ccde44e804",
+      "contentHash": "9eed6792d9f566c568f499824c267d35f1c98d484ef3f853919fa9d42ca5049c",
       "since": "2025-01-01"
     },
     "subsystem:scheduler": {