plugnz 0.0.4 → 0.0.6

package/src/source.ts

@@ -1,224 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { join, basename, isAbsolute, resolve } from 'node:path';
-import { cacheRoot } from './paths';
-import { isGitUrl } from './exec';
-import { fingerprintTree } from './fingerprint';
-
-export interface PluginSource {
-  dir: string;
-  name: string;
-  version?: string;
-  marketplace?: string;
-  /** Stable digest of the source directory bytes, independent of version/SHA. */
-  contentFingerprint?: string;
-}
-
-/** Identity fields shared by canonical Agent Plugins and supported native inputs. */
-export interface PluginManifest {
-  name: string;
-  version?: string;
-  description?: string;
-}
-
-export interface ResolvedSource {
-  sourceUri: string;
-  sha: string;
-  isGit: boolean;
-  plugins: PluginSource[];
-}
-
-export function resolveSource(source: string): ResolvedSource {
-  const sourceUri = normalizeSource(source);
-  const isGit = isGitUrl(sourceUri);
-  let targetDir = sourceUri;
-  let sha = 'local';
-  
-  if (isGit) {
-    const ls = spawnSync('git', ['ls-remote', sourceUri, 'HEAD'], { encoding: 'utf8' });
-    if (ls.status !== 0) throw new Error(`Failed to resolve git remote: ${sourceUri}`);
-    sha = ls.stdout.split('\t')[0] || '';
-    if (!sha || sha.length !== 40) throw new Error(`Invalid sha from git ls-remote: ${sha}`);
-    
-    const cacheDir = cacheRoot();
-    mkdirSync(cacheDir, { recursive: true });
-    targetDir = join(cacheDir, sha);
-    
-    if (!existsSync(targetDir)) {
-      const clone = spawnSync('git', ['clone', '--depth=1', sourceUri, targetDir]);
-      if (clone.status !== 0) throw new Error(`Failed to clone ${sourceUri}`);
-    }
-  } else {
-    // An absolute source (what `add` records in state.json, and what `update`
-    // feeds back) must not be re-rooted at the cwd — path.join does not reset
-    // on an absolute second argument.
-    targetDir = sourceUri;
-    if (!existsSync(targetDir)) throw new Error(`Local source not found: ${targetDir}`);
-    const rev = spawnSync('git', ['-C', targetDir, 'rev-parse', 'HEAD'], { encoding: 'utf8' });
-    if (rev.status === 0) {
-      const match = rev.stdout.trim().match(/^[0-9a-f]{40}$/i);
-      if (match) sha = match[0];
-    }
-  }
-  targetDir = assertSafeSourceTree(targetDir);
-
-  const plugins: PluginSource[] = [];
-  
-  // 1. Marketplace index
-  const mp1 = join(targetDir, '.claude-plugin', 'marketplace.json');
-  const mp2 = join(targetDir, '.omp-plugin', 'marketplace.json');
-  const mp3 = join(targetDir, 'marketplace.json');
-  const mpPath = existsSync(mp1) ? mp1 : existsSync(mp2) ? mp2 : existsSync(mp3) ? mp3 : null;
-  
-  if (mpPath !== null) {
-    const data = parseMarketplace(mpPath);
-    const marketplaceName = typeof data['name'] === 'string' ? data['name'] : 'local';
-    assertSafeIdentity(marketplaceName, 'marketplace name');
-    const entries = data['plugins'];
-    if (!Array.isArray(entries)) throw new Error(`Malformed marketplace manifest: plugins must be an array (${mpPath})`);
-    if (entries.length === 0) throw new Error(`No plugins discovered in marketplace: ${mpPath}`);
-    for (const entry of entries) {
-      if (!isRecord(entry) || typeof entry['source'] !== 'string' || entry['source'].trim() === '') {
-        throw new Error(`Malformed marketplace manifest: every plugin needs a source (${mpPath})`);
-      }
-      const pDir = resolve(targetDir, entry['source']);
-      if (!isInside(targetDir, pDir)) throw new Error(`Marketplace plugin source escapes collection root: ${entry['source']}`);
-      if (!existsSync(pDir) || !statSync(pDir).isDirectory()) throw new Error(`Marketplace plugin source is not a directory: ${entry['source']}`);
-      plugins.push(pluginFromDir(pDir, marketplaceName));
-    }
-  }
-  
-  if (plugins.length > 0) return resolvedSource(sourceUri, sha, isGit, plugins);
-
-  // 2. Root plugin
-  if (isPluginDir(targetDir)) {
-    plugins.push(pluginFromDir(targetDir));
-    return resolvedSource(sourceUri, sha, isGit, plugins);
-  }
-
-  // 3. Recursive scan (1 level deep)
-  for (const entry of readdirSync(targetDir)) {
-    const subDir = join(targetDir, entry);
-    if (statSync(subDir).isDirectory() && isPluginDir(subDir)) {
-      plugins.push(pluginFromDir(subDir));
-    }
-  }
-  
-  if (plugins.length === 0) throw new Error(`No plugins discovered in source: ${sourceUri}`);
-  return resolvedSource(sourceUri, sha, isGit, plugins);
-}
-
-function resolvedSource(sourceUri: string, sha: string, isGit: boolean, plugins: PluginSource[]): ResolvedSource {
-  const seen = new Set<string>();
-  for (const plugin of plugins) {
-    const identity = `${plugin.name}@${plugin.marketplace ?? 'local'}`;
-    if (seen.has(identity)) throw new Error(`Duplicate plugin identity discovered: ${identity}`);
-    seen.add(identity);
-  }
-  return { sourceUri, sha, isGit, plugins };
-}
-
-/** Owner/repo is the public GitHub shorthand; all local roots become absolute. */
-export function normalizeSource(source: string): string {
-  if (source.startsWith('./') || source.startsWith('../') || isAbsolute(source)) return resolve(source);
-  if (/^[^/\s]+\/[^/\s]+$/.test(source)) return `https://github.com/${source}.git`;
-  if (isGitUrl(source)) return source;
-  return resolve(source);
-}
-
-function withFingerprint(plugin: PluginSource): PluginSource {
-  return { ...plugin, contentFingerprint: fingerprintTree(plugin.dir) };
-}
-
-function pluginFromDir(dir: string, marketplace?: string): PluginSource {
-  const manifest = readPluginManifest(dir);
-  const name = manifest?.name ?? inferredPluginName(dir);
-  return withFingerprint({ dir, name, ...(manifest?.version === undefined ? {} : { version: manifest.version }), ...(marketplace === undefined ? {} : { marketplace }) });
-}
-
-function assertSafeSourceTree(path: string): string {
-  assertNoSymlinks(path);
-  const canonical = realpath(path);
-  assertNoSymlinks(canonical);
-  return canonical;
-}
-
-function assertNoSymlinks(path: string): void {
-  const links = spawnSync('find', [path, '-type', 'l', '-print'], { encoding: 'utf8' });
-  if (links.status !== 0) throw new Error(`Could not inspect source tree: ${path}`);
-  if (links.stdout.trim() !== '') throw new Error(`Symlink resources are not supported: ${links.stdout.trim()}`);
-}
-
-function parseMarketplace(path: string): Record<string, unknown> {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
-    if (!isRecord(parsed)) throw new Error('manifest must be an object');
-    return parsed;
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Malformed marketplace manifest: ${path} (${detail})`);
-  }
-}
-
-function realpath(path: string): string {
-  const result = spawnSync('realpath', [path], { encoding: 'utf8' });
-  if (result.status !== 0 || result.stdout.trim() === '') throw new Error(`Could not resolve source path: ${path}`);
-  return result.stdout.trim();
-}
-
-function isInside(root: string, candidate: string): boolean {
-  return candidate === root || candidate.startsWith(`${root}/`);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function isPluginDir(dir: string): boolean {
-  return manifestPaths(dir).some(existsSync) || existsSync(join(dir, '.mcp.json')) || existsSync(join(dir, 'mcp.json'));
-}
-
-/**
- * Canonical manifests take precedence. `.claude-plugin/plugin.json` is a
- * supported source-only fallback; it is never rewritten into a source tree.
- */
-export function readPluginManifest(dir: string): PluginManifest | undefined {
-  let selected: PluginManifest | undefined;
-  for (const path of manifestPaths(dir)) {
-    if (!existsSync(path)) continue;
-    const current = parsePluginManifest(path);
-    if (selected === undefined) {
-      selected = current;
-      continue;
-    }
-    if (current.name !== selected.name || (current.version !== undefined && selected.version !== undefined && current.version !== selected.version)) {
-      throw new Error(`Conflicting plugin manifest identity: ${path}`);
-    }
-  }
-  return selected;
-}
-
-function manifestPaths(dir: string): string[] {
-  return [join(dir, 'plugin.json'), join(dir, '.plugin', 'plugin.json'), join(dir, '.claude-plugin', 'plugin.json')];
-}
-
-function parsePluginManifest(path: string): PluginManifest {
-  let data: unknown;
-  try { data = JSON.parse(readFileSync(path, 'utf8')); }
-  catch (error) { throw new Error(`Malformed plugin manifest: ${path} (${(error as Error).message})`); }
-  if (!isRecord(data) || typeof data['name'] !== 'string') throw new Error(`Plugin manifest needs a name: ${path}`);
-  assertSafeIdentity(data['name'], 'plugin name');
-  if (data['version'] !== undefined && (typeof data['version'] !== 'string' || data['version'].trim() === '')) throw new Error(`Plugin manifest version is invalid: ${path}`);
-  if (data['description'] !== undefined && typeof data['description'] !== 'string') throw new Error(`Plugin manifest description is invalid: ${path}`);
-  return { name: data['name'], ...(typeof data['version'] === 'string' ? { version: data['version'] } : {}), ...(typeof data['description'] === 'string' ? { description: data['description'] } : {}) };
-}
-
-function inferredPluginName(dir: string): string {
-  const inferred = basename(dir);
-  assertSafeIdentity(inferred, 'plugin name');
-  return inferred;
-}
-
-function assertSafeIdentity(value: string, label: string): void {
-  if (!/^[a-z0-9][a-z0-9._-]*$/iu.test(value)) throw new Error(`Unsafe ${label}: ${value}`);
-}

package/src/state-write.ts

@@ -1,25 +0,0 @@
-/**
- * The write side of the install ledger (src/state.ts) — `add`, `pin` and
- * `update` write through this; doctor imports only the readers, and a module
- * is evaluated whole, so keeping `writeState` out of src/state.ts keeps
- * writer code out of doctor's import graph (AGENTS.md;
- * test/doctor-imports.test.ts pins it).
- */
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import * as fs from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import { stateFile } from './paths';
-import type { InstallRecord } from './state';
-
-export function writeState(records: InstallRecord[], file: string = stateFile()): void {
-  const parent = dirname(file);
-  mkdirSync(parent, { recursive: true });
-  const temporary = join(parent, `.${basename(file)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-  try {
-    writeFileSync(temporary, JSON.stringify({ version: 1, installs: records }, null, 2));
-    (fs as unknown as { renameSync(from: string, to: string): void }).renameSync(temporary, file);
-  } catch (error) {
-    rmSync(temporary, { force: true });
-    throw error;
-  }
-}

package/src/state.ts

@@ -1,118 +0,0 @@
-/**
- * open-plugin's own install ledger — `$OPEN_PLUGIN_HOME/state.json`
- * (see src/paths.ts `stateFile()`). Readers only: doctor imports this module,
- * so the writer (`writeState`) lives in src/state-write.ts — a module is
- * evaluated whole, and doctor must not load writer code (AGENTS.md).
- *
- * Schema (version 1):
- * {
- *   "version": 1,
- *   "installs": [
- *     {
- *       "host": "claude-code",
- *       "id": "omakase@oh-my-ai-sdk",       // same id as listInstalled()
- *       "source": "/path/to/git/checkout",  // local git source whose HEAD is the freshness yardstick
- *       "sourceSha": "4f6f7f0a414e…",       // source HEAD at install time
- *       "installedAt": "2026-09-16T14:08:23.259Z",
- *       "pins": ["omakase"]                 // server names `pin` rewrote to an absolute path
- *     }
- *   ]
- * }
- *
- * `pins` (optional) is what `update` re-applies: re-adding a plugin restores
- * the source's bare `command`, so a recorded pin must be re-run on the fresh
- * copy. Absent means `pin` never rewrote anything for that install.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { stateFile } from './paths';
-
-export interface InstallRecord {
-  host: string;
-  id: string;
-  source: string;
-  sourceSha: string;
-  installedAt?: string;
-  /** Server names `pin` rewrote to an absolute path in this host's copy, sorted. */
-  pins?: string[];
-  /** Reserved for the content-based refresh increment; legacy records remain valid. */
-  fingerprint?: string;
-  /** Canonical selected package directory whose bytes produced `fingerprint`. */
-  sourceDir?: string;
-  /** Raw-byte fingerprint of the activated host-native representation. */
-  installedFingerprint?: string;
-  /** Reserved for explicit owned-artifact cleanup; legacy records remain valid. */
-  ownership?: string;
-  /** Durable intent written before a host mutation and cleared only after it completes. */
-  pending?: 'install' | 'remove';
-}
-
-const RECORD_FIELDS = new Set(['host', 'id', 'source', 'sourceSha', 'installedAt', 'pins', 'fingerprint', 'sourceDir', 'installedFingerprint', 'ownership', 'pending']);
-
-function asRecord(v: unknown): Record<string, unknown> | null {
-  return typeof v === 'object' && v !== null ? (v as Record<string, unknown>) : null;
-}
-
-function coerceInstall(v: unknown): InstallRecord {
-  const rec = asRecord(v);
-  if (!rec) throw new Error('Invalid state.json: install record must be an object');
-  const unknown = Object.keys(rec).find((key) => !RECORD_FIELDS.has(key));
-  if (unknown !== undefined) throw new Error(`Invalid state.json: unsupported install field '${unknown}'`);
-  const host = typeof rec['host'] === 'string' ? rec['host'] : null;
-  const id = typeof rec['id'] === 'string' ? rec['id'] : null;
-  const source = typeof rec['source'] === 'string' ? rec['source'] : null;
-  const sourceSha = typeof rec['sourceSha'] === 'string' ? rec['sourceSha'] : null;
-  if (host === null || id === null || source === null || sourceSha === null) {
-    throw new Error('Invalid state.json: install record is missing required fields');
-  }
-  if (rec['installedAt'] !== undefined && typeof rec['installedAt'] !== 'string') throw new Error('Invalid state.json: installedAt must be a string');
-  if (rec['pins'] !== undefined && (!Array.isArray(rec['pins']) || rec['pins'].some((pin) => typeof pin !== 'string' || pin.length === 0))) {
-    throw new Error('Invalid state.json: pins must be non-empty strings');
-  }
-  if (rec['fingerprint'] !== undefined && typeof rec['fingerprint'] !== 'string') throw new Error('Invalid state.json: fingerprint must be a string');
-  if (rec['sourceDir'] !== undefined && typeof rec['sourceDir'] !== 'string') throw new Error('Invalid state.json: sourceDir must be a string');
-  if (rec['installedFingerprint'] !== undefined && typeof rec['installedFingerprint'] !== 'string') throw new Error('Invalid state.json: installedFingerprint must be a string');
-  if (rec['ownership'] !== undefined && typeof rec['ownership'] !== 'string') throw new Error('Invalid state.json: ownership must be a string');
-  if (rec['pending'] !== undefined && rec['pending'] !== 'install' && rec['pending'] !== 'remove') throw new Error('Invalid state.json: pending must be install or remove');
-  const installedAt = rec['installedAt'] as string | undefined;
-  const rawPins = rec['pins'];
-  const pins = rawPins as string[] | undefined;
-  const record: InstallRecord = { host, id, source, sourceSha };
-  if (installedAt !== undefined) record.installedAt = installedAt;
-  if (pins !== undefined && pins.length > 0) record.pins = pins;
-  if (typeof rec['fingerprint'] === 'string') record.fingerprint = rec['fingerprint'];
-  if (typeof rec['sourceDir'] === 'string') record.sourceDir = rec['sourceDir'];
-  if (typeof rec['installedFingerprint'] === 'string') record.installedFingerprint = rec['installedFingerprint'];
-  if (typeof rec['ownership'] === 'string') record.ownership = rec['ownership'];
-  if (rec['pending'] === 'install' || rec['pending'] === 'remove') record.pending = rec['pending'];
-  return record;
-}
-
-/** Read the ledger; a missing file is empty, while corrupt state is surfaced. */
-export function readState(file: string = stateFile()): InstallRecord[] {
-  if (!existsSync(file)) return [];
-  let text: string;
-  try {
-    text = readFileSync(file, 'utf8');
-  } catch (error) {
-    throw new Error(`Unable to read state.json: ${(error as Error).message}`);
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    throw new Error(`Invalid state.json: ${(error as Error).message}`);
-  }
-  const root = asRecord(parsed);
-  if (root === null) throw new Error('Invalid state.json: root must be an object');
-  const unknownRoot = Object.keys(root).find((key) => key !== 'version' && key !== 'installs');
-  if (unknownRoot !== undefined) throw new Error(`Invalid state.json: unsupported root field '${unknownRoot}'`);
-  if (root['version'] !== 1) throw new Error(`Unsupported state.json version: ${String(root['version'])}`);
-  const installs = root['installs'];
-  if (!Array.isArray(installs)) throw new Error('Invalid state.json: installs must be an array');
-  return installs.map(coerceInstall);
-}
-
-/** Find the ledger row for one install on one host. */
-export function findRecord(records: InstallRecord[], host: string, id: string): InstallRecord | undefined {
-  return records.find((r) => r.host === host && r.id === id);
-}

package/src/update.ts

@@ -1,230 +0,0 @@
-/**
- * `plgnz update [name]` — bring installed plugins up to their source.
- *
- * The ledger (`state.json`) is the whole authority here. `update` walks the
- * records *this tool wrote* — never the host stores — and for each one:
- *
- *   1. re-resolves the recorded source (a git source is re-read at its head),
- *   2. re-runs the host's `add` against that source, which is idempotent:
- *      version-addressed stores (claude-code, codex, omp) land in a fresh
- *      slot, and the copy-based stores (kimi, cursor) replace the copy —
- *      re-materializing it rather than keeping the first one,
- *   3. re-applies the pins `pin` recorded, because the fresh copy carries the
- *      source's bare `command` again.
- *
- * A plugin with no record — one another tool installed — is reported, never
- * modified: plgnz has no basis for saying what "up to date" means for it,
- * and a re-add would silently take ownership of someone else's install.
- */
-import type { HostWriter, InstalledPlugin } from './host';
-import type { Mark } from './doctor';
-import { writers as allWriters } from './hosts/writers';
-import { resolveSource, type PluginSource } from './source';
-import { readState, type InstallRecord } from './state';
-import { writeState } from './state-write';
-import { fingerprintInstallation } from './fingerprint';
-import { CompatibilityError } from './compatibility';
-
-export interface UpdateFinding {
-  host: string;
-  mark: Mark;
-  /** A typed adapter refusal keeps its public InstallOutcome status. */
-  status?: 'unsupported' | 'unverified';
-  message: string;
-}
-
-export interface UpdateResult {
-  findings: UpdateFinding[];
-  exitCode: number;
-}
-
-export interface UpdateOptions {
-  dryRun?: boolean;
-  /** Ledger to read/update; defaults to the real `state.json`. */
-  state?: InstallRecord[];
-  /** Hosts to consider; defaults to the registry. */
-  writers?: readonly HostWriter[];
-  /** Test seam for ledger persistence failure regressions. */
-  writeState?: (records: InstallRecord[]) => void;
-}
-
-/** The plugin name part of a host-native id (`name@marketplace` or bare name). */
-function idName(id: string): string {
-  const at = id.indexOf('@');
-  return at === -1 ? id : id.slice(0, at);
-}
-
-function idOf(plugin: PluginSource): string {
-  return plugin.marketplace === undefined ? plugin.name : `${plugin.name}@${plugin.marketplace}`;
-}
-
-function shortSha(sha: string): string {
-  return sha.length > 8 ? sha.slice(0, 8) : sha;
-}
-
-export async function runUpdate(name?: string, options: UpdateOptions = {}): Promise<UpdateResult> {
-  const hosts = options.writers ?? allWriters;
-  let state = options.state ?? readState();
-  const save = options.writeState ?? writeState;
-  const prefix = options.dryRun === true ? '[dry-run] ' : '';
-  const findings: UpdateFinding[] = [];
-
-  const selectedHosts = new Set(hosts.map((host) => host.id));
-  const records = state.filter((record) => selectedHosts.has(record.host)).filter((record) => name === undefined || record.id === name || idName(record.id) === name);
-  if (name !== undefined && records.length === 0) {
-    findings.push({
-      host: 'plgnz',
-      mark: '✗',
-      message: `no install record for '${name}' in state.json — not installed by plgnz; refusing to modify it`,
-    });
-    return { findings, exitCode: 1 };
-  }
-  if (records.length === 0) {
-    findings.push({
-      host: 'plgnz',
-      mark: '!',
-      message: 'nothing to update — state.json has no install records',
-    });
-    return { findings, exitCode: 0 };
-  }
-
-  for (const initialRecord of records) {
-    const found = state.find((candidate) => candidate.host === initialRecord.host && candidate.id === initialRecord.id);
-    if (found === undefined) continue;
-    let record: InstallRecord = found;
-    const host = hosts.find((w) => w.id === record.host);
-    if (host === undefined) {
-      findings.push({
-        host: record.host,
-        mark: '✗',
-        message: `unknown host in state.json for '${record.id}' — no host module owns it`,
-      });
-      continue;
-    }
-    if (!host.detect()) {
-      findings.push({
-        host: host.id,
-        mark: '!',
-        message: `host not present on this machine — '${record.id}' skipped`,
-      });
-      continue;
-    }
-    if (record.pending === 'remove') {
-      findings.push({ host: host.id, mark: '✗', message: `removal of '${record.id}' is pending — retry remove before update` });
-      continue;
-    }
-
-    let resolved;
-    try {
-      resolved = resolveSource(record.source);
-    } catch (e) {
-      findings.push({
-        host: host.id,
-        mark: '✗',
-        message: `cannot resolve source of '${record.id}': ${record.source} — ${(e as Error).message}`,
-      });
-      continue;
-    }
-
-    const plugin = resolved.plugins.find((p) => idOf(p) === record.id) ?? resolved.plugins.find((p) => p.name === idName(record.id));
-    if (plugin === undefined) {
-      findings.push({
-        host: host.id,
-        mark: '✗',
-        message: `source ${record.source} no longer provides '${record.id}' — re-add it by hand`,
-      });
-      continue;
-    }
-
-    try {
-      if (options.dryRun !== true) {
-        const pending = { ...record, pending: 'install' as const };
-        const next = state.map((candidate) => candidate === record ? pending : candidate);
-        save(next);
-        state = next;
-        record = pending;
-      }
-      await host.add(plugin, resolved, { dryRun: options.dryRun });
-    } catch (e) {
-      findings.push(e instanceof CompatibilityError
-        ? { host: host.id, mark: e.status === 'unverified' ? '!' : '✗', status: e.status, message: `re-add of '${record.id}' refused — ${e.message}` }
-        : { host: host.id, mark: '✗', message: `re-add of '${record.id}' failed — ${(e as Error).message}` });
-      continue;
-    }
-    let pinsOk: boolean;
-    try {
-      pinsOk = await repin(host, record, plugin, options, findings, prefix);
-    } catch (error) {
-      findings.push({ host: host.id, mark: '✗', message: `updated '${record.id}' but pin finalization failed — ${(error as Error).message}` });
-      continue;
-    }
-    if (!pinsOk) continue;
-
-    if (options.dryRun === true) {
-      findings.push({ host: host.id, mark: '✓', message: `${prefix}updated '${record.id}' from ${record.source} → ${shortSha(resolved.sha)}` });
-      continue;
-    }
-    try {
-      const installed = host.listInstalled().find((candidate) => candidate.id === record.id);
-      if (installed === undefined || installed.enabled === false || installed.path === undefined) throw new Error('updated native representation is not enabled or has no readable path');
-      const finalized: InstallRecord = {
-        ...record,
-        sourceSha: resolved.sha,
-        installedAt: new Date().toISOString(),
-        ownership: record.ownership ?? 'plgnz',
-        sourceDir: plugin.dir,
-        installedFingerprint: fingerprintInstallation(installed),
-        ...(plugin.contentFingerprint !== undefined ? { fingerprint: plugin.contentFingerprint } : {}),
-      };
-      delete finalized.pending;
-      const next = state.map((candidate) => candidate === record ? finalized : candidate);
-      save(next);
-      state = next;
-      findings.push({ host: host.id, mark: '✓', message: `updated '${record.id}' from ${record.source} → ${shortSha(resolved.sha)}` });
-    } catch (error) {
-      findings.push({ host: host.id, mark: '✗', message: `updated '${record.id}' but could not finalize its ledger record — ${(error as Error).message}` });
-    }
-  }
-
-  return { findings, exitCode: findings.some((f) => f.mark === '✗' || f.status === 'unverified') ? 1 : 0 };
-}
-
-/** Re-apply the pins recorded for this install onto the freshly added copy. */
-async function repin(
-  host: HostWriter,
-  record: InstallRecord,
-  plugin: PluginSource,
-  options: UpdateOptions,
-  findings: UpdateFinding[],
-  prefix: string,
-): Promise<boolean> {
-  const pins = record.pins ?? [];
-  if (pins.length === 0) return true;
-  const installed: InstalledPlugin | undefined = host.listInstalled().find((p) => p.id === record.id);
-  if (installed === undefined) {
-    findings.push({
-      host: host.id,
-      mark: '!',
-      message: `cannot re-apply pins for '${record.id}' — not found in the ${host.id} store after the update`,
-    });
-    return false;
-  }
-  const outcome = await host.pin(installed, { only: pins, dryRun: options.dryRun });
-  for (const change of outcome.changes) {
-    findings.push({
-      host: host.id,
-      mark: '✓',
-      message: `${prefix}re-pinned '${change.server}': '${change.from}' → ${change.to} (plugin ${plugin.name})`,
-    });
-  }
-  for (const refusal of outcome.refusals) {
-    findings.push({
-      host: host.id,
-      mark: '✗',
-      message:
-        `${prefix}failed to re-apply the pin for '${refusal.server}': bare command '${refusal.command}' ` +
-        `not found on PATH (plugin ${plugin.name})`,
-    });
-  }
-  return outcome.refusals.length === 0;
-}