@git-stunts/git-warp 10.8.0 → 11.3.3

package/src/infrastructure/adapters/CasSeekCacheAdapter.js

@@ -16,6 +16,11 @@
  * @module infrastructure/adapters/CasSeekCacheAdapter
  */
 
+/**
+ * Minimal interface for the ContentAddressableStore from @git-stunts/git-cas.
+ * @typedef {{ readManifest: Function, restore: Function, store: Function, createTree: Function }} CasStore
+ */
+
 import SeekCachePort from '../../ports/SeekCachePort.js';
 import { buildSeekCacheRef } from '../../domain/utils/RefLayout.js';
 import { Readable } from 'node:stream';
@@ -59,7 +64,7 @@ export default class CasSeekCacheAdapter extends SeekCachePort {
   /**
    * Lazily initializes the ContentAddressableStore.
    * @private
-   * @returns {Promise<*>}
+   * @returns {Promise<CasStore>}
    */
   async _getCas() {
     if (!this._casPromise) {
@@ -73,7 +78,7 @@ export default class CasSeekCacheAdapter extends SeekCachePort {
 
   /**
    * @private
-   * @returns {Promise<*>}
+   * @returns {Promise<CasStore>}
    */
   async _initCas() {
     const { default: ContentAddressableStore } = await import(
@@ -132,7 +137,7 @@ export default class CasSeekCacheAdapter extends SeekCachePort {
    * @returns {Promise<CacheIndex>} The mutated index
    */
   async _mutateIndex(mutate) {
-    /** @type {*} */ // TODO(ts-cleanup): type CAS retry error
+    /** @type {unknown} */
     let lastErr;
     for (let attempt = 0; attempt < MAX_CAS_RETRIES; attempt++) {
       const index = await this._readIndex();
@@ -144,7 +149,7 @@ export default class CasSeekCacheAdapter extends SeekCachePort {
         lastErr = err;
         // Transient write failure — retry with fresh read
         if (attempt === MAX_CAS_RETRIES - 1) {
-          throw new Error(`CasSeekCacheAdapter: index update failed after retries: ${lastErr.message}`);
+          throw new Error(`CasSeekCacheAdapter: index update failed after retries: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
         }
       }
     }

package/src/infrastructure/adapters/DenoHttpAdapter.js

@@ -100,8 +100,8 @@ function createHandler(requestHandler, logger) {
       const plain = await toPlainRequest(request);
       const response = await requestHandler(plain);
       return toDenoResponse(response);
-    } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-      if (err.status === 413) {
+    } catch (err) {
+      if (typeof err === 'object' && err !== null && /** @type {{status?: number}} */ (err).status === 413) {
         const msg = new TextEncoder().encode('Payload Too Large');
         return new Response(msg, {
           status: 413,
@@ -140,7 +140,7 @@ function closeImpl(state, callback) {
         callback();
       }
     },
-    /** @param {*} err */ (err) => {
+    /** @param {unknown} err */ (err) => {
       state.server = null;
       if (callback) {
         callback(err);
@@ -210,7 +210,7 @@ export default class DenoHttpAdapter extends HttpServerPort {
         const hostname = typeof host === 'string' ? host : undefined;
 
         try {
-          /** @type {*} */ // TODO(ts-cleanup): type Deno.serve options
+          /** @type {DenoServeOptions} */
           const serveOptions = {
             port,
             onListen() {
@@ -223,9 +223,8 @@ export default class DenoHttpAdapter extends HttpServerPort {
             serveOptions.hostname = hostname;
           }
 
-          // @ts-expect-error — Deno global is only available in Deno runtime
           state.server = globalThis.Deno.serve(serveOptions, handler);
-        } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
+        } catch (err) {
           if (cb) {
             cb(err);
           } else {

package/src/infrastructure/adapters/GitGraphAdapter.js

@@ -114,6 +114,26 @@ function getExitCode(err) {
   return err?.details?.code ?? err?.exitCode ?? err?.code;
 }
 
+/**
+ * Checks if a Git error indicates a dangling or missing object.
+ * Exit code 128 with specific stderr patterns means the ref exists but
+ * points to a missing object. Other exit-128 failures (bad repo, corrupt
+ * index, permission errors) are NOT considered dangling and will re-throw.
+ * @param {GitError} err
+ * @returns {boolean}
+ */
+function isDanglingObjectError(err) {
+  if (getExitCode(err) !== 128) {
+    return false;
+  }
+  const stderr = (err.details?.stderr || '').toLowerCase();
+  return (
+    stderr.includes('bad object') ||
+    stderr.includes('not a valid object name') ||
+    stderr.includes('does not point to a valid object')
+  );
+}
+
 /**
  * Checks whether a Git ref exists without resolving it.
  * @param {function(Object): Promise<string>} execute - The git command executor function
@@ -125,8 +145,12 @@ async function refExists(execute, ref) {
   try {
     await execute({ args: ['show-ref', '--verify', '--quiet', ref] });
     return true;
-  } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-    if (getExitCode(err) === 1) {
+  } catch (err) {
+    const gitErr = /** @type {GitError} */ (err);
+    if (getExitCode(gitErr) === 1) {
+      return false;
+    }
+    if (isDanglingObjectError(gitErr)) {
       return false;
     }
     throw err;
@@ -325,6 +349,20 @@ export default class GitGraphAdapter extends GraphPersistencePort {
     };
   }
 
+  /**
+   * Retrieves the tree OID for a given commit SHA.
+   * @param {string} sha - The commit SHA to query
+   * @returns {Promise<string>} The tree OID pointed to by the commit
+   * @throws {Error} If the SHA is invalid
+   */
+  async getCommitTree(sha) {
+    this._validateOid(sha);
+    const output = await this._executeWithRetry({
+      args: ['rev-parse', `${sha}^{tree}`]
+    });
+    return output.trim();
+  }
+
   /**
    * Returns raw git log output for a ref.
    * @param {Object} options
@@ -493,7 +531,7 @@ export default class GitGraphAdapter extends GraphPersistencePort {
   /**
    * Reads the OID a ref points to.
    * @param {string} ref - The ref name
-   * @returns {Promise<string|null>} The OID, or null if the ref does not exist
+   * @returns {Promise<string|null>} The OID, or null if the ref does not exist or points to a dangling/missing object
    * @throws {Error} If the ref format is invalid
    */
   async readRef(ref) {
@@ -507,14 +545,44 @@ export default class GitGraphAdapter extends GraphPersistencePort {
         args: ['rev-parse', ref]
       });
       return oid.trim();
-    } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-      if (getExitCode(err) === 1) {
+    } catch (err) {
+      const gitErr = /** @type {GitError} */ (err);
+      if (getExitCode(gitErr) === 1) {
+        return null;
+      }
+      if (isDanglingObjectError(gitErr)) {
         return null;
       }
       throw err;
     }
   }
 
+  /**
+   * Atomically updates a ref using compare-and-swap semantics.
+   *
+   * Uses `git update-ref ref newOid expectedOid` which is atomic CAS.
+   * Fails if the ref does not currently point to expectedOid.
+   *
+   * @param {string} ref - The ref name
+   * @param {string} newOid - The new OID to set
+   * @param {string|null} expectedOid - The expected current OID, or null if the ref must not exist
+   * @returns {Promise<void>}
+   * @throws {Error} If the ref does not match the expected value (CAS mismatch)
+   */
+  async compareAndSwapRef(ref, newOid, expectedOid) {
+    this._validateRef(ref);
+    this._validateOid(newOid);
+    // null means "ref must not exist" → use zero OID
+    const oldArg = expectedOid || '0'.repeat(newOid.length);
+    if (expectedOid) {
+      this._validateOid(expectedOid);
+    }
+    // Direct call — CAS failures are semantically expected and must NOT be retried.
+    await this.plumbing.execute({
+      args: ['update-ref', ref, newOid, oldArg],
+    });
+  }
+
   /**
    * Deletes a ref.
    * @param {string} ref - The ref name to delete
@@ -562,8 +630,8 @@ export default class GitGraphAdapter extends GraphPersistencePort {
     try {
       await this._executeWithRetry({ args: ['cat-file', '-e', sha] });
       return true;
-    } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-      if (getExitCode(err) === 1) {
+    } catch (err) {
+      if (getExitCode(/** @type {GitError} */ (err)) === 1) {
         return false;
       }
       throw err;
@@ -638,8 +706,8 @@ export default class GitGraphAdapter extends GraphPersistencePort {
         args: ['merge-base', '--is-ancestor', potentialAncestor, descendant]
       });
       return true;  // Exit code 0 means it IS an ancestor
-    } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-      if (this._getExitCode(err) === 1) {
+    } catch (err) {
+      if (this._getExitCode(/** @type {GitError} */ (err)) === 1) {
         return false; // Exit code 1 means it is NOT an ancestor
       }
       throw err; // Re-throw unexpected errors
@@ -660,8 +728,8 @@ export default class GitGraphAdapter extends GraphPersistencePort {
       });
       // Preserve empty-string values; only drop trailing newline
       return value.replace(/\n$/, '');
-    } catch (/** @type {*} */ err) { // TODO(ts-cleanup): type error
-      if (this._isConfigKeyNotFound(err)) {
+    } catch (err) {
+      if (this._isConfigKeyNotFound(/** @type {GitError} */ (err))) {
         return null;
       }
       throw err;

package/src/infrastructure/adapters/InMemoryGraphAdapter.js

@@ -253,6 +253,19 @@ export default class InMemoryGraphAdapter extends GraphPersistencePort {
     };
   }
 
+  /**
+   * @param {string} sha
+   * @returns {Promise<string>}
+   */
+  async getCommitTree(sha) {
+    validateOid(sha);
+    const commit = this._commits.get(sha);
+    if (!commit) {
+      throw new Error(`Commit not found: ${sha}`);
+    }
+    return commit.treeOid;
+  }
+
   /**
    * @param {string} sha
    * @returns {Promise<boolean>}
@@ -356,6 +369,29 @@ export default class InMemoryGraphAdapter extends GraphPersistencePort {
     this._refs.delete(ref);
   }
 
+  /**
+   * Atomically updates a ref using compare-and-swap semantics.
+   * @param {string} ref - The ref name
+   * @param {string} newOid - The new OID to set
+   * @param {string|null} expectedOid - Expected current OID, or null if ref must not exist
+   * @returns {Promise<void>}
+   * @throws {Error} If the ref does not match the expected value (CAS mismatch)
+   */
+  async compareAndSwapRef(ref, newOid, expectedOid) {
+    validateRef(ref);
+    validateOid(newOid);
+    if (expectedOid) {
+      validateOid(expectedOid);
+    }
+    const current = this._refs.get(ref) || null;
+    if (current !== expectedOid) {
+      throw new Error(
+        `CAS mismatch on ${ref}: expected ${expectedOid || '(none)'}, got ${current || '(none)'}`,
+      );
+    }
+    this._refs.set(ref, newOid);
+  }
+
   /**
    * @param {string} prefix
    * @returns {Promise<string[]>}

package/src/infrastructure/adapters/NodeHttpAdapter.js

@@ -71,7 +71,7 @@ export default class NodeHttpAdapter extends HttpServerPort {
     const logger = this._logger;
     const server = createServer((req, res) => {
       dispatch(req, res, { handler: requestHandler, logger }).catch(
-        /** @param {*} err */ (err) => {
+        /** @param {unknown} err */ (err) => {
           logger.error('[NodeHttpAdapter] unhandled dispatch error:', err);
         });
     });
@@ -85,7 +85,7 @@ export default class NodeHttpAdapter extends HttpServerPort {
       listen(port, host, callback) {
         const cb = typeof host === 'function' ? host : callback;
         const bindHost = typeof host === 'string' ? host : undefined;
-        /** @param {*} err */
+        /** @param {unknown} err */
         const onError = (err) => {
           if (cb) {
             cb(err);

package/src/infrastructure/adapters/WebCryptoAdapter.js

@@ -38,8 +38,8 @@ function toWebCryptoAlgo(algorithm) {
 function toUint8Array(data) {
   if (data instanceof Uint8Array) { return data; }
   if (typeof data === 'string') { return new TextEncoder().encode(data); }
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(/** @type {*} */ (data))) { // TODO(ts-cleanup): narrow port type
-    const buf = /** @type {Buffer} */ (/** @type {*} */ (data)); // TODO(ts-cleanup): narrow port type
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
+    const buf = /** @type {Buffer} */ (data);
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
   throw new Error('WebCryptoAdapter: data must be string, Buffer, or Uint8Array');

package/src/ports/CommitPort.js

@@ -90,6 +90,16 @@ export default class CommitPort {
     throw new Error('CommitPort.nodeExists() not implemented');
   }
 
+  /**
+   * Retrieves the tree OID for a given commit SHA.
+   * @param {string} _sha - The commit SHA to query
+   * @returns {Promise<string>} The tree OID pointed to by the commit
+   * @throws {Error} If not implemented by a concrete adapter
+   */
+  async getCommitTree(_sha) {
+    throw new Error('CommitPort.getCommitTree() not implemented');
+  }
+
   /**
    * Pings the repository to verify accessibility.
    * @returns {Promise<{ok: boolean, latencyMs: number}>} Health check result with latency

package/src/ports/RefPort.js

@@ -48,4 +48,21 @@ export default class RefPort {
   async listRefs(_prefix) {
     throw new Error('RefPort.listRefs() not implemented');
   }
+
+  /**
+   * Atomically updates a ref using compare-and-swap semantics.
+   *
+   * The ref is updated to `_newOid` only if it currently points to `_expectedOid`.
+   * If `_expectedOid` is `null`, the ref must not exist (genesis CAS).
+   *
+   * @param {string} _ref - The ref name
+   * @param {string} _newOid - The new OID to set
+   * @param {string|null} _expectedOid - The expected current OID, or null if the ref must not exist
+   * @returns {Promise<void>}
+   * @throws {Error} If the ref does not match the expected value (CAS mismatch)
+   * @throws {Error} If not implemented by a concrete adapter
+   */
+  async compareAndSwapRef(_ref, _newOid, _expectedOid) {
+    throw new Error('RefPort.compareAndSwapRef() not implemented');
+  }
 }

package/src/visualization/layouts/converters.js

@@ -7,7 +7,7 @@
  */
 
 /**
- * @typedef {{ id: string, label: string, props?: Record<string, any> }} GraphDataNode
+ * @typedef {{ id: string, label: string, props?: Record<string, unknown> }} GraphDataNode
  * @typedef {{ from: string, to: string, label?: string }} GraphDataEdge
  * @typedef {{ nodes: GraphDataNode[], edges: GraphDataEdge[] }} GraphData
  */
@@ -16,7 +16,7 @@
  * Converts a query result payload + edge array into graph data.
  * Edges are filtered to only those connecting matched nodes.
  *
- * @param {{ nodes?: Array<{ id: string, props?: Record<string, any> }> } | null} payload - Query result
+ * @param {{ nodes?: Array<{ id: string, props?: Record<string, unknown> }> } | null} payload - Query result
  * @param {Array<{ from: string, to: string, label?: string }>}  edges   - Edge array from graph.getEdges()
  * @returns {GraphData}
  */

package/src/visualization/layouts/elkAdapter.js

@@ -3,7 +3,7 @@
  */
 
 /**
- * @typedef {{ id: string, label: string, props?: Record<string, any> }} GraphDataNode
+ * @typedef {{ id: string, label: string, props?: Record<string, unknown> }} GraphDataNode
  * @typedef {{ from: string, to: string, label?: string }} GraphDataEdge
  * @typedef {{ nodes: GraphDataNode[], edges: GraphDataEdge[] }} GraphData
  * @typedef {{ text: string }} ElkLabel

package/src/visualization/layouts/elkLayout.js

@@ -7,20 +7,23 @@
 
 /**
  * @typedef {{ id: string, x?: number, y?: number, width?: number, height?: number, labels?: Array<{ text: string }> }} ElkResultChild
- * @typedef {{ id: string, sources?: string[], targets?: string[], labels?: Array<{ text: string }>, sections?: any[] }} ElkResultEdge
+ * @typedef {{ id: string, sources?: string[], targets?: string[], labels?: Array<{ text: string }>, sections?: unknown[] }} ElkResultEdge
  * @typedef {{ children?: ElkResultChild[], edges?: ElkResultEdge[], width?: number, height?: number }} ElkResult
- * @typedef {{ id: string, x: number, y: number, width: number, height: number, label: string }} PosNode
- * @typedef {{ id: string, source: string, target: string, label?: string, sections: any[] }} PosEdge
+ * @typedef {{ id: string, x: number, y: number, width: number, height: number, label?: string }} PosNode
+ * @typedef {{ x: number, y: number }} LayoutPoint
+ * @typedef {{ startPoint?: LayoutPoint, endPoint?: LayoutPoint, bendPoints?: LayoutPoint[] }} LayoutSection
+ * @typedef {{ id: string, source: string, target: string, label?: string, sections?: LayoutSection[] }} PosEdge
  * @typedef {{ nodes: PosNode[], edges: PosEdge[], width: number, height: number }} PositionedGraph
  * @typedef {{ id: string, children?: Array<{ id: string, width?: number, height?: number, labels?: Array<{ text: string }> }>, edges?: Array<{ id: string, sources?: string[], targets?: string[], labels?: Array<{ text: string }> }>, layoutOptions?: Record<string, string> }} ElkGraphInput
+ * @typedef {{ layout: (graph: ElkGraphInput) => Promise<ElkResult> }} ElkEngine
  */
 
-/** @type {Promise<any> | null} */
+/** @type {Promise<unknown> | null} */
 let elkPromise = null;
 
 /**
  * Returns (or creates) a singleton ELK instance.
- * @returns {Promise<any>} ELK instance
+ * @returns {Promise<unknown>} ELK instance
  */
 function getElk() {
   if (!elkPromise) {
@@ -39,7 +42,7 @@ export async function runLayout(elkGraph) {
   /** @type {ElkResult | undefined} */
   let result;
   try {
-    const elk = await getElk();
+    const elk = /** @type {ElkEngine} */ (await getElk());
     result = await elk.layout(elkGraph);
   } catch {
     return fallbackLayout(elkGraph);
@@ -67,7 +70,7 @@ function toPositionedGraph(result) {
     source: e.sources?.[0] ?? '',
     target: e.targets?.[0] ?? '',
     label: e.labels?.[0]?.text,
-    sections: e.sections ?? [],
+    sections: /** @type {LayoutSection[]} */ (e.sections ?? []),
   }));
 
   return {

package/src/visualization/layouts/index.js

@@ -21,7 +21,7 @@ import { runLayout } from './elkLayout.js';
  *
  * @param {{ nodes: Array<{ id: string, label: string }>, edges: Array<{ from: string, to: string, label?: string }> }} graphData - Normalised graph data
  * @param {{ type?: 'query'|'path'|'slice', layoutOptions?: Record<string, string> }} [options]
- * @returns {Promise<{ nodes: any[], edges: any[], width: number, height: number }>} PositionedGraph
+ * @returns {Promise<import('./elkLayout.js').PositionedGraph>} PositionedGraph
  */
 export async function layoutGraph(graphData, options = {}) {
   const elkGraph = toElkGraph(graphData, options);

package/src/visualization/renderers/ascii/seek.js

@@ -30,7 +30,7 @@ import { formatOpSummary } from './opSummary.js';
  * @property {number} patchCount
  * @property {Map<string, WriterInfo> | Record<string, WriterInfo>} perWriter
  * @property {{ nodes?: number, edges?: number }} [diff]
- * @property {Record<string, any>} [tickReceipt]
+ * @property {Record<string, unknown>} [tickReceipt]
  * @property {import('../../../domain/services/StateDiff.js').StateDiffResult | null} [structuralDiff]
  * @property {string} [diffBaseline]
  * @property {number | null} [baselineTick]
@@ -73,7 +73,7 @@ function pluralize(n, singular, plural) {
   return n === 1 ? singular : plural;
 }
 
-/** @param {Record<string, any> | undefined} tickReceipt @returns {string[]} */
+/** @param {Record<string, unknown> | undefined} tickReceipt @returns {string[]} */
 function buildReceiptLines(tickReceipt) {
   if (!tickReceipt || typeof tickReceipt !== 'object') {
     return [];
@@ -85,8 +85,12 @@ function buildReceiptLines(tickReceipt) {
 
   const lines = [];
   for (const [writerId, entry] of entries) {
-    const sha = typeof entry.sha === 'string' ? entry.sha : null;
-    const opSummary = entry.opSummary && typeof entry.opSummary === 'object' ? entry.opSummary : entry;
+    /** @type {Record<string, unknown>} */
+    const rec = /** @type {Record<string, unknown>} */ (entry);
+    const sha = typeof rec.sha === 'string' ? rec.sha : null;
+    const opSummary = rec.opSummary && typeof rec.opSummary === 'object'
+      ? /** @type {Record<string, number>} */ (rec.opSummary)
+      : /** @type {Record<string, number>} */ (rec);
     const name = padRight(formatWriterName(writerId, NAME_W), NAME_W);
     const shaStr = sha ? `  ${formatSha(sha)}` : '';
     lines.push(`    ${name}${shaStr}  ${formatOpSummary(opSummary, 40)}`);
@@ -443,14 +447,20 @@ function collectDiffEntries(diff) {
 
 /**
  * Formats a property value for display (truncated if too long).
- * @param {*} value
+ * @param {unknown} value
  * @returns {string}
  */
 function formatPropValue(value) {
   if (value === undefined) {
     return 'undefined';
   }
-  const s = typeof value === 'string' ? `"${value}"` : String(value);
+  if (typeof value === 'string') {
+    const s = `"${value}"`;
+    return s.length > 40 ? `${s.slice(0, 37)}...` : s;
+  }
+  const s = typeof value === 'number' || typeof value === 'boolean'
+    ? String(value)
+    : JSON.stringify(value) ?? '';
   return s.length > 40 ? `${s.slice(0, 37)}...` : s;
 }
 

package/src/visualization/renderers/svg/index.js

@@ -119,7 +119,7 @@ function renderEdge(edge) {
 /**
  * Renders a PositionedGraph as an SVG string.
  *
- * @param {{ nodes?: Array<{ id: string, x: number, y: number, width: number, height: number, label?: string }>, edges?: Array<{ sections?: Array<any>, label?: string }>, width?: number, height?: number }} positionedGraph - PositionedGraph from runLayout()
+ * @param {{ nodes?: Array<{ id: string, x: number, y: number, width: number, height: number, label?: string }>, edges?: Array<{ sections?: Array<{ startPoint?: { x: number, y: number }, endPoint?: { x: number, y: number }, bendPoints?: Array<{ x: number, y: number }> }>, label?: string }>, width?: number, height?: number }} positionedGraph - PositionedGraph from runLayout()
  * @param {{ title?: string }} [options]
  * @returns {string} Complete SVG markup
  */

package/src/hooks/post-merge.sh

@@ -1,60 +0,0 @@
-#!/bin/sh
-# --- @git-stunts/git-warp post-merge hook __WARP_HOOK_VERSION__ ---
-# warp-hook-version: __WARP_HOOK_VERSION__
-#
-# Post-merge hook: notify (or auto-materialize) when warp refs changed.
-#
-# Compares refs/warp/ before and after merge by maintaining
-# a snapshot file at .git/warp-ref-snapshot. If any warp writer refs
-# changed and warp.autoMaterialize is true, runs `git warp materialize`.
-# Otherwise prints an informational message advising re-materialization.
-# Always exits 0 — never blocks a merge.
-
-GIT_DIR=$(git rev-parse --git-dir 2>/dev/null) || exit 0
-SNAPSHOT="${GIT_DIR}/warp-ref-snapshot"
-
-# Capture current warp refs (sorted for stable comparison)
-CURRENT=$(git for-each-ref --format='%(refname) %(objectname)' --sort=refname refs/warp/ 2>/dev/null) || true
-
-if [ -z "$CURRENT" ]; then
-  # No warp refs exist — clean up any stale snapshot and exit
-  rm -f "$SNAPSHOT"
-  exit 0
-fi
-
-CHANGED=0
-
-if [ -f "$SNAPSHOT" ]; then
-  PREVIOUS=$(cat "$SNAPSHOT")
-  if [ "$CURRENT" != "$PREVIOUS" ]; then
-    CHANGED=1
-  fi
-else
-  # First encounter — refs exist but no snapshot yet
-  CHANGED=1
-fi
-
-# Save current state for next comparison
-printf '%s\n' "$CURRENT" > "$SNAPSHOT"
-
-if [ "$CHANGED" -eq 0 ]; then
-  exit 0
-fi
-
-AUTO_MAT=$(git config --bool warp.autoMaterialize 2>/dev/null) || true
-
-if [ "$AUTO_MAT" = "true" ]; then
-  echo "[warp] Refs changed — auto-materializing..."
-  if command -v git-warp >/dev/null 2>&1; then
-    git-warp materialize || echo "[warp] Warning: auto-materialize failed."
-  elif command -v warp-graph >/dev/null 2>&1; then
-    warp-graph materialize || echo "[warp] Warning: auto-materialize failed."
-  else
-    echo "[warp] Warning: neither git-warp nor warp-graph found in PATH."
-  fi
-else
-  echo "[warp] Writer refs changed during merge. Call materialize() to see updates."
-fi
-
-exit 0
-# --- end @git-stunts/git-warp ---