codemem 0.44.1 → 0.45.0-rc.1

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { DEDUP_KEY_BACKFILL_JOB, DEFAULT_COORDINATOR_DB_PATH, DedupKeyBackfillRunner, DeviceIdentityError, EXTRACTION_BENCHMARK_QUALITY_WEIGHTS, MUTATING_TOOL_NAMES, MemoryStore, ObserverClient, ObserverOutputError, ObserverOutputTransportError, PROMPT_TRANSPORT_PROTOCOL_RANGE, REF_BACKFILL_JOB, RawEventIngestValidationError, RawEventSweeper, RefBackfillRunner, SCOPE_BACKFILL_JOB, SESSION_CONTEXT_BACKFILL_JOB, SUMMARY_DEDUP_BACKFILL_JOB, ScopeBackfillRunner, SessionContextBackfillRunner, SummaryDedupBackfillRunner, SyncRetentionRunner, TRUSTED_HOOK_MAPPER_OPTIONS, VERSION, VectorModelMigrationRunner, aiBackfillStructuredContent, applyBootstrapSnapshot, applyDistillRule, arePromptTransportProtocolRangesCompatible, backfillMemoryDedupKeys, backfillNarrativeFromBody, backfillTagsText, backfillVectors, buildBaseUrl, buildDirectPeerAuthHeaders, buildDistillReport, buildRawEventEnvelopeFromCodexHook, buildRawEventEnvelopeFromHook, buildViewerIdentityTarget, classifyPromptTransportFailure, clonePromptPackAttempt, collectOperationalStatus, compareMemoryRoleReports, connect, connectReadOnly, coordinatorCreateGroupAction, coordinatorCreateInviteAction, coordinatorCreateScopeAction, coordinatorDisableDeviceAction, coordinatorEnrollDeviceAction, coordinatorGrantScopeMembershipAction, coordinatorImportInviteAction, coordinatorListBootstrapGrantsAction, coordinatorListDevicesAction, coordinatorListGroupsAction, coordinatorListJoinRequestsAction, coordinatorListScopeMembershipsAction, coordinatorListScopesAction, coordinatorRemoveDeviceAction, coordinatorRenameDeviceAction, coordinatorReviewJoinRequestAction, coordinatorRevokeBootstrapGrantAction, coordinatorRevokeScopeMembershipAction, coordinatorUpdateScopeAction, createBetterSqliteCoordinatorApp, deactivateLowSignalMemories, deactivateLowSignalObservations, dedupNearDuplicateMemories, detectInstallKind, draftDistillRule, ensureDeviceIdentity, ensureSchemaBootstrapped, estimateExtractionModelCost, exportMemories, extractApplyPatchPaths, extractionReplayObserverIdentity, fetchAllSnapshotPages, fingerprintPublicKey, flushRawEvents, formatHostPort, getAttributionDiagnostics, getExtractionBenchmarkProfile, getExtractionModelPricing, getInjectionEvalScenarioPack, getInjectionEvalScenarioPrompts, getMaintenanceJob, getMemoryArtifactReport, getMemoryRoleReport, getRawEventRelinkPlan, getRawEventRelinkReport, getRawEventStatus, getSemanticIndexDiagnostics, getSessionExtractionEval, getSessionExtractionEvalScenario, getUpdateStatus, getWorkspaceCodememConfigPath, hasPendingDedupKeyBackfill, hasPendingRefBackfill, hasPendingScopeBackfill, hasPendingSessionContextBackfill, hasPendingSummaryDedupBackfill, hasUnsyncedSharedMemoryChanges, importMemories, ingestRawEvents, initDatabase, isAutomaticRecallMeasurement, isEmbeddingDisabled, isReleaseVersionForChannel, judgeDistillReport, listMaintenanceJobs, listPerPeerScopeSyncState, listRetentionScopeIds, loadObserverConfig, loadPublicKey, loadSqliteVec, mdnsEnabled, normalizePromptTransportProtocolRange, planReplicationOpsAgePrune, probeCodememViewerLiveness, probeCodememViewerLiveness as probeCodememViewerLiveness$1, probeRequiredNativeRuntime, projectMatchesFilter, promptPackArtifactFingerprint, pruneReplicationOpsUntilCaughtUp, rawEventsGate, readCodememConfigFile, readCodememConfigFileAtPath, readCoordinatorSyncConfig, readImportPayload, recordAutomaticRecall, recordPromptPackArtifacts, recordPromptPackTerminal, recordRetrievalSurface, renderUnifiedDiff, replayBatchExtraction, replayBatchExtractionWithTierRouting, requestJson, resolveCodememConfigPath, resolveDbPath, resolveHookProject, resolveProject, resolveProjectRoot, resolveRetrievalSession, retryRawEventFailures, runSyncDaemon, runSyncPass, scanSecretsRetroactive, schema, scoreExtractionBenchmarkOutput, setPeerProjectFilter, stripJsonComments, stripTrailingCommas, syncPassPreflight, tryUpdateRetrievalDelivery, updatePeerAddresses, vacuumDatabase, viewerUrl, writeCodememConfigFile } from "@codemem/core";
+import { ContextOnlyReplayError, DEDUP_KEY_BACKFILL_JOB, DEFAULT_COORDINATOR_DB_PATH, DedupKeyBackfillRunner, DeviceIdentityError, EXTRACTION_BENCHMARK_QUALITY_WEIGHTS, MUTATING_TOOL_NAMES, MemoryStore, ObserverClient, ObserverOutputError, ObserverOutputTransportError, PROMPT_TRANSPORT_PROTOCOL_RANGE, REF_BACKFILL_JOB, RawEventIngestValidationError, RawEventSweeper, RefBackfillRunner, SCOPE_BACKFILL_JOB, SESSION_CONTEXT_BACKFILL_JOB, SUMMARY_DEDUP_BACKFILL_JOB, ScopeBackfillRunner, SessionContextBackfillRunner, SummaryDedupBackfillRunner, SyncRetentionRunner, TRUSTED_HOOK_MAPPER_OPTIONS, VERSION, VectorModelMigrationRunner, aiBackfillStructuredContent, applyBootstrapSnapshot, applyDistillRule, arePromptTransportProtocolRangesCompatible, backfillMemoryDedupKeys, backfillNarrativeFromBody, backfillTagsText, backfillVectors, buildBaseUrl, buildDirectPeerAuthHeaders, buildDistillReport, buildRawEventEnvelopeFromCodexHook, buildRawEventEnvelopeFromHook, buildViewerIdentityTarget, classifyPromptTransportFailure, clonePromptPackAttempt, collectOperationalStatus, compareMemoryRoleReports, connect, connectReadOnly, coordinatorCreateGroupAction, coordinatorCreateInviteAction, coordinatorCreateScopeAction, coordinatorDisableDeviceAction, coordinatorEnrollDeviceAction, coordinatorGrantScopeMembershipAction, coordinatorImportInviteAction, coordinatorListBootstrapGrantsAction, coordinatorListDevicesAction, coordinatorListGroupsAction, coordinatorListJoinRequestsAction, coordinatorListScopeMembershipsAction, coordinatorListScopesAction, coordinatorRemoveDeviceAction, coordinatorRenameDeviceAction, coordinatorReviewJoinRequestAction, coordinatorRevokeBootstrapGrantAction, coordinatorRevokeScopeMembershipAction, coordinatorUpdateScopeAction, createBetterSqliteCoordinatorApp, deactivateLowSignalMemories, deactivateLowSignalObservations, dedupNearDuplicateMemories, detectInstallKind, draftDistillRule, ensureDeviceIdentity, ensureSchemaBootstrapped, estimateExtractionModelCost, exportMemories, extractApplyPatchPaths, extractionReplayObserverIdentity, fetchAllSnapshotPages, fingerprintPublicKey, flushRawEvents, formatHostPort, getAttributionDiagnostics, getExtractionBenchmarkProfile, getExtractionModelPricing, getInjectionEvalScenarioPack, getInjectionEvalScenarioPrompts, getMaintenanceJob, getMemoryArtifactReport, getMemoryRoleReport, getRawEventRelinkPlan, getRawEventRelinkReport, getRawEventStatus, getSemanticIndexDiagnostics, getSessionExtractionEval, getSessionExtractionEvalScenario, getUpdateStatus, getWorkspaceCodememConfigPath, hasPendingDedupKeyBackfill, hasPendingRefBackfill, hasPendingScopeBackfill, hasPendingSessionContextBackfill, hasPendingSummaryDedupBackfill, hasUnsyncedSharedMemoryChanges, importMemories, ingestRawEvents, initDatabase, isAutomaticRecallMeasurement, isEmbeddingDisabled, isExplicitUpdateInstallEligible, isReleaseVersionForChannel, judgeDistillReport, listMaintenanceJobs, listPerPeerScopeSyncState, listRetentionScopeIds, loadObserverConfig, loadPublicKey, loadSqliteVec, mdnsEnabled, normalizePromptTransportProtocolRange, planReplicationOpsAgePrune, probeCodememViewerLiveness, probeCodememViewerLiveness as probeCodememViewerLiveness$1, probeRequiredNativeRuntime, projectMatchesFilter, promptPackArtifactFingerprint, pruneReplicationOpsUntilCaughtUp, rawEventsGate, readCodememConfigFile, readCodememConfigFileAtPath, readCoordinatorSyncConfig, readImportPayload, recordAutomaticRecall, recordPromptPackArtifacts, recordPromptPackTerminal, recordRetrievalSurface, renderUnifiedDiff, replayBatchExtraction, replayBatchExtractionWithTierRouting, requestJson, resolveCodememConfigPath, resolveComparablePath, resolveDbPath, resolveHookProject, resolveProject, resolveProjectRoot, resolveRetrievalSession, retryRawEventFailures, runSyncDaemon, runSyncPass, scanSecretsRetroactive, schema, scoreExtractionBenchmarkOutput, setPeerProjectFilter, stripJsonComments, stripTrailingCommas, syncPassPreflight, tryUpdateRetrievalDelivery, updatePeerAddresses, vacuumDatabase, viewerUrl, writeCodememConfigFile } from "@codemem/core";
 import { Command, Option } from "commander";
 import omelette from "omelette";
 import { randomInt, randomUUID } from "node:crypto";
-import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, networkInterfaces } from "node:os";
 import { dirname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { styleText } from "node:util";
@@ -4701,6 +4701,20 @@ function parseStrictPositiveId(value) {
 	const n = Number(value.trim());
 	return Number.isFinite(n) && n >= 1 && Number.isInteger(n) ? n : null;
 }
+function contextOnlyReplayOutcome(error, target) {
+	return {
+		...target,
+		status: "context_only",
+		code: error.code,
+		evaluated: false,
+		message: error.message
+	};
+}
+function emitContextOnlyReplayOutcome(outcome, opts) {
+	if (opts.json) console.log(JSON.stringify(outcome, null, 2));
+	else p.log.info(outcome.message);
+	process.exitCode = 0;
+}
 function resolveOpenAIResponsesOverride(cliEnabled, configured) {
 	return cliEnabled === true ? true : configured;
 }
@@ -5177,6 +5191,13 @@ function createMemoryExtractionReplayCommand() {
 			].join("\n"));
 			p.outro("done");
 		} catch (error) {
+			if (error instanceof ContextOnlyReplayError) {
+				emitContextOnlyReplayOutcome(contextOnlyReplayOutcome(error, {
+					batchId: Number(opts.batchId),
+					scenarioId: opts.scenario.trim()
+				}), opts);
+				return;
+			}
 			const message = error instanceof Error ? error.message : "Extraction replay failed";
 			if (opts.json) emitJsonError("extraction_replay_failed", message);
 			else {
@@ -5414,6 +5435,7 @@ function createMemoryExtractionBenchmarkCommand() {
 			const observer = new ObserverClient(observerConfigWithOverrides);
 			const outputFailures = [];
 			const runs = [];
+			const contextOnlySkips = [];
 			for (let iteration = 1; iteration <= repetitions; iteration += 1) for (const batch of benchmark.batches) {
 				const scenarioId = batch.scenarioId ?? benchmark.scenarioId;
 				let selectedObserver = extractionReplayObserverIdentity(observer, null);
@@ -5432,6 +5454,17 @@ function createMemoryExtractionBenchmarkCommand() {
 						transcriptBudget: transcriptBudget ?? void 0
 					});
 				} catch (error) {
+					if (error instanceof ContextOnlyReplayError) {
+						contextOnlySkips.push({
+							...contextOnlyReplayOutcome(error, {
+								batchId: batch.batchId,
+								scenarioId
+							}),
+							iteration,
+							purpose: batch.purpose
+						});
+						continue;
+					}
 					if (!(error instanceof ObserverOutputError) && !(error instanceof ObserverOutputTransportError)) throw error;
 					if (opts.observerTierRouting !== true) selectedObserver = extractionReplayObserverIdentity(observer, null);
 					const failureCost = estimateBenchmarkAttemptCost(selectedObserver.model, error.telemetry.totalUsage);
@@ -5600,6 +5633,9 @@ function createMemoryExtractionBenchmarkCommand() {
 			const knownElapsedRuns = attempts.filter((run) => run.telemetry.totalElapsedMs != null);
 			const summary = {
 				repetitions,
+				scheduledTotal: benchmark.batches.length * repetitions,
+				contextOnlySkipped: contextOnlySkips.length,
+				contextOnlySkips,
 				...attemptSummary,
 				summaryDispositionTotal: runs.filter((run) => run.quality != null).length,
 				summaryDispositionMatches: runs.filter((run) => run.quality?.summaryDisposition.score === 1).length,
@@ -5674,6 +5710,7 @@ function createMemoryExtractionBenchmarkCommand() {
 				`Temperature: ${observerSummary.transport === "mixed" ? "mixed" : observerSummary.temperature ?? "not transmitted"}`,
 				`Transcript budget override: ${transcriptBudget ?? "default"}`,
 				`Repetitions: ${summary.repetitions}`,
+				`Context-only skips: ${summary.contextOnlySkipped} (${summary.scheduledTotal} scheduled; ${summary.total} observer attempts)`,
 				`Shape-quality passes: ${summary.shapeQualityPasses}/${summary.shapeQualityTotal}`,
 				`Shape-quality fails: ${summary.shapeQualityFails}`,
 				`Expected-tier matches: ${summary.expectedTierMatches}/${summary.expectedTierTotal}`,
@@ -5687,6 +5724,7 @@ function createMemoryExtractionBenchmarkCommand() {
 				`Tokens input/output: ${summary.output.overall.inputTokens}/${summary.output.overall.outputTokens} (${summary.output.overall.knownTokenRuns} measured run(s)); retained observations: ${summary.output.overall.retainedObservations}`,
 				`Summary disposition matches: ${summary.output.overall.summaryDispositionMatches}/${summary.output.overall.summaryDispositionEvaluated}; contract integrity/semantic quality: ${summary.output.overall.contractIntegrityRate?.toFixed(3) ?? "n/a"}/${summary.output.overall.meanSemanticQuality?.toFixed(3) ?? "n/a"}`
 			].join("\n"));
+			for (const skipped of contextOnlySkips) p.log.message(`  [${skipped.batchId}#${skipped.iteration}] context_only — ${skipped.code}; not evaluated`);
 			for (const run of runs) {
 				const qualityLabel = run.quality?.weightedQualityScore == null ? "n/a" : run.quality.weightedQualityScore.toFixed(3);
 				const costLabel = run.cost.total == null ? "n/a" : `$${run.cost.total.totalCostUsd.toFixed(6)}`;
@@ -5934,6 +5972,8 @@ function describeCandidate(candidate) {
 	if (candidate.section) lines.push(`   - section: ${candidate.section}`);
 	if (candidate.reasons.length > 0) lines.push(`   - reasons: ${candidate.reasons.join(", ")}`);
 	if (scoreParts) lines.push(`   - scores: ${scoreParts}`);
+	const fusion = candidate.scores.fusion;
+	if (fusion) lines.push(`   - hybrid: fused_score=${fusion.fused_score.toPrecision(8)} fusion_rank=${fusion.fusion_rank}; combined_score is a legacy diagnostic, not the hybrid selection key`);
 	if (candidate.preview) lines.push(`   - preview: ${candidate.preview}`);
 	return lines;
 }
@@ -7065,6 +7105,32 @@ var serveCommand = serveCmd.action(async (action, opts) => {
 });
 //#endregion
 //#region src/commands/setup-config.ts
+var OPENCODE_PLUGIN_SPEC = "@codemem/opencode-plugin";
+var LEGACY_OPENCODE_PLUGIN_SPECS = ["codemem", "@kunickiaj/codemem"];
+function matchesPluginSpec(entry, spec) {
+	return typeof entry === "string" && (entry === spec || entry.startsWith(`${spec}@`));
+}
+function reconcileOpencodePluginConfig(config, { force }) {
+	const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+	const isCanonicalSpec = (entry) => matchesPluginSpec(entry, OPENCODE_PLUGIN_SPEC);
+	const isLegacySpec = (entry) => LEGACY_OPENCODE_PLUGIN_SPECS.some((spec) => matchesPluginSpec(entry, spec));
+	const hasCanonicalSpec = plugins.some(isCanonicalSpec);
+	const hasLegacySpec = plugins.some(isLegacySpec);
+	if (hasCanonicalSpec && !hasLegacySpec && !force) return {
+		config,
+		changed: false,
+		removedLegacy: false
+	};
+	const preserved = plugins.filter((entry) => !isCanonicalSpec(entry) && !isLegacySpec(entry));
+	return {
+		config: {
+			...config,
+			plugin: [...preserved, OPENCODE_PLUGIN_SPEC]
+		},
+		changed: true,
+		removedLegacy: hasLegacySpec
+	};
+}
 function resolveOpencodeConfigPath(configDir) {
 	const jsonPath = join(configDir, "opencode.json");
 	if (existsSync(jsonPath)) return jsonPath;
@@ -7110,9 +7176,6 @@ function claudeConfigDir() {
 function codexConfigDir() {
 	return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
 }
-/** The npm package name used in the OpenCode plugin array. */
-var OPENCODE_PLUGIN_SPEC = "@codemem/opencode-plugin";
-var LEGACY_OPENCODE_PLUGIN_SPECS = ["codemem", "@kunickiaj/codemem"];
 /** Remove legacy copied plugin JS file from ~/.config/opencode/plugins/codemem.js */
 function migrateLegacyOpencodePlugin() {
 	const legacyPlugin = join(opencodeConfigDir(), "plugins", "codemem.js");
@@ -7196,21 +7259,14 @@ function installPlugin(force) {
 		p.log.error(`Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
 		return false;
 	}
-	let plugins = config.plugin;
-	if (!Array.isArray(plugins)) plugins = [];
-	const isManagedPluginSpec = (entry) => typeof entry === "string" && [OPENCODE_PLUGIN_SPEC, ...LEGACY_OPENCODE_PLUGIN_SPECS].some((spec) => entry === spec || entry.startsWith(`${spec}@`));
-	const hasCanonicalSpec = plugins.some((entry) => typeof entry === "string" && (entry === OPENCODE_PLUGIN_SPEC || entry.startsWith(`${OPENCODE_PLUGIN_SPEC}@`)));
-	const hasLegacySpec = plugins.some((entry) => typeof entry === "string" && LEGACY_OPENCODE_PLUGIN_SPECS.some((spec) => entry === spec || entry.startsWith(`${spec}@`)));
-	if (hasCanonicalSpec && !hasLegacySpec && !force) {
+	const result = reconcileOpencodePluginConfig(config, { force });
+	if (!result.changed) {
 		p.log.info(`Plugin "${OPENCODE_PLUGIN_SPEC}" already in plugin array`);
 		return true;
 	}
-	plugins = plugins.filter((entry) => !isManagedPluginSpec(entry));
-	if (hasLegacySpec) p.log.step("Removed legacy OpenCode plugin spec(s): codemem / @kunickiaj/codemem");
-	plugins.push(OPENCODE_PLUGIN_SPEC);
-	config.plugin = plugins;
+	if (result.removedLegacy) p.log.step("Removed legacy OpenCode plugin spec(s): codemem / @kunickiaj/codemem");
 	try {
-		writeJsonConfig(configPath, config);
+		writeJsonConfig(configPath, result.config);
 		p.log.success(`Plugin "${OPENCODE_PLUGIN_SPEC}" added to ${configPath}`);
 	} catch (err) {
 		p.log.error(`Failed to write ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
@@ -9083,7 +9139,64 @@ var INSTALL_TIMEOUT_MS = 42e4;
 var VERIFY_TIMEOUT_MS = 3e4;
 var PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
 var UPDATE_LOCK_FILE = "update-install.lock";
+var UPDATE_COMMAND_MAX_OUTPUT_BYTES = 65536;
 var UpdateInstallLockedError = class extends Error {};
+var PnpmOwnershipError = class extends Error {};
+function commandStderr(outputExceeded, timedOut, stderr) {
+	if (outputExceeded) return "command output too large";
+	if (timedOut) return "command timed out";
+	return stderr;
+}
+function createOutputCapture(maxOutputBytes) {
+	let exceeded = false;
+	let outputBytes = 0;
+	let stderr = "";
+	let stdout = "";
+	return {
+		append(stream, chunk) {
+			if (exceeded) return;
+			outputBytes += Buffer.byteLength(chunk);
+			if (maxOutputBytes !== void 0 && outputBytes > maxOutputBytes) {
+				exceeded = true;
+				return;
+			}
+			if (stream === "stderr") stderr += chunk;
+			else stdout += chunk;
+		},
+		exceeded: () => exceeded,
+		stderr: () => stderr,
+		stdout: () => stdout
+	};
+}
+function terminateWindowsProcessTree(pid) {
+	if (process.platform !== "win32" || !pid) return false;
+	const systemRoot = process.env.SystemRoot?.trim();
+	if (!systemRoot || !isAbsolute(systemRoot)) return false;
+	spawnSync(join(systemRoot, "System32", "taskkill.exe"), [
+		"/PID",
+		String(pid),
+		"/T",
+		"/F"
+	], {
+		stdio: "ignore",
+		windowsHide: true
+	});
+	return true;
+}
+function terminatePosixProcessGroup(pid, signal) {
+	if (process.platform === "win32" || !pid) return false;
+	try {
+		process.kill(-pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function terminateCommand(child, signal) {
+	if (terminateWindowsProcessTree(child.pid)) return;
+	if (terminatePosixProcessGroup(child.pid, signal)) return;
+	child.kill(signal);
+}
 function updateInstallLockPath() {
 	return join(process.env.HOME?.trim() || homedir(), ".codemem", UPDATE_LOCK_FILE);
 }
@@ -9143,8 +9256,7 @@ function runCommand(command, args, timeoutMs, options = {}) {
 		});
 		let settled = false;
 		let timedOut = false;
-		let stdout = "";
-		let stderr = "";
+		const output = createOutputCapture(options.maxOutputBytes);
 		let timer;
 		const finish = (result) => {
 			if (settled) return;
@@ -9152,28 +9264,7 @@ function runCommand(command, args, timeoutMs, options = {}) {
 			clearTimeout(timer);
 			resolve(result);
 		};
-		const terminate = (signal) => {
-			if (process.platform === "win32" && child.pid) {
-				const systemRoot = process.env.SystemRoot?.trim();
-				if (systemRoot && isAbsolute(systemRoot)) {
-					spawnSync(join(systemRoot, "System32", "taskkill.exe"), [
-						"/PID",
-						String(child.pid),
-						"/T",
-						"/F"
-					], {
-						stdio: "ignore",
-						windowsHide: true
-					});
-					return;
-				}
-			}
-			if (process.platform !== "win32" && child.pid) try {
-				process.kill(-child.pid, signal);
-				return;
-			} catch {}
-			child.kill(signal);
-		};
+		const terminate = (signal) => terminateCommand(child, signal);
 		timer = setTimeout(() => {
 			timedOut = true;
 			terminate("SIGTERM");
@@ -9182,34 +9273,43 @@ function runCommand(command, args, timeoutMs, options = {}) {
 		child.stdout.setEncoding("utf8");
 		child.stderr.setEncoding("utf8");
 		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
+			output.append("stdout", chunk);
 		});
 		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
+			output.append("stderr", chunk);
 		});
 		child.once("error", (error) => {
 			clearTimeout(timer);
 			if (!settled) reject(error);
 		});
-		child.once("close", (code) => finish({
-			exitCode: code ?? 1,
-			stdout,
-			stderr: timedOut ? "command timed out" : stderr
-		}));
+		child.once("close", (code) => {
+			const stderr = commandStderr(output.exceeded(), timedOut, output.stderr());
+			finish({
+				exitCode: code ?? 1,
+				outputExceeded: output.exceeded(),
+				stdout: output.stdout(),
+				stderr
+			});
+		});
 	});
 }
 async function resolveWindowsShim(name) {
 	const systemRoot = process.env.SystemRoot?.trim();
 	if (!systemRoot || !isAbsolute(systemRoot)) throw new Error("Windows SystemRoot is unavailable");
-	const result = await runCommand(join(systemRoot, "System32", "where.exe"), [name], 1e4, { cwd: join(systemRoot, "System32") });
+	const result = await runCommand(join(systemRoot, "System32", "where.exe"), [name], 1e4, {
+		cwd: join(systemRoot, "System32"),
+		maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES
+	});
+	if (result.outputExceeded) throw new Error(`unable to resolve ${name}: where.exe output too large`);
 	const shim = result.stdout.split(/\r?\n/).map((value) => value.trim()).find((value) => isAbsolute(value));
-	if (result.exitCode !== 0 || !shim) throw new Error(`unable to resolve ${name} from PATH`);
+	if (!shim) throw Object.assign(/* @__PURE__ */ new Error(`unable to resolve ${name} from PATH`), { code: "ENOENT" });
+	if (result.exitCode !== 0) throw new Error(`where.exe failed while resolving ${name}`);
 	return shim;
 }
 function windowsCommandLine(shim, args) {
 	return `""${shim}" ${args.join(" ")}"`;
 }
-async function resolveInstallCommand() {
+async function resolveNpmInstallCommand() {
 	if (process.platform !== "win32") return {
 		command: "npm",
 		args: []
@@ -9227,6 +9327,31 @@ async function resolveInstallCommand() {
 		cwd: join(systemRoot, "System32")
 	};
 }
+async function resolvePnpmCommand() {
+	if (process.platform !== "win32") return {
+		command: "pnpm",
+		args: []
+	};
+	const systemRoot = process.env.SystemRoot?.trim();
+	if (!systemRoot || !isAbsolute(systemRoot)) throw new Error("Windows SystemRoot is unavailable");
+	return {
+		command: join(systemRoot, "System32", "cmd.exe"),
+		args: [
+			"/d",
+			"/s",
+			"/c",
+			await resolveWindowsShim("pnpm.cmd")
+		],
+		cwd: join(systemRoot, "System32"),
+		windowsVerbatimArguments: true
+	};
+}
+function resolvedCommandArgs(command, args) {
+	if (process.platform !== "win32") return args;
+	const shim = command.args[3];
+	if (!shim) throw new Error("Windows command shim is unavailable");
+	return [...command.args.slice(0, 3), windowsCommandLine(shim, args)];
+}
 async function resolveVerificationCommand() {
 	if (process.platform !== "win32") return {
 		command: "codemem",
@@ -9260,6 +9385,7 @@ function renderStatusWarning(error) {
 }
 function renderHumanStatus(status) {
 	const warning = renderStatusWarning(status.error);
+	if (status.install_kind === "repo-dev") return `Running from repository source (package metadata: ${status.current_version}). ${status.recommended_action}${warning}`;
 	if (status.update_available) return `Update available${cacheQualifier(status.stale)}: ${status.current_version} → ${status.latest_version}. ${status.recommended_action}${warning}`;
 	if (!status.channel || !isReleaseVersionForChannel(status.current_version, status.channel)) return `Unable to compare current version ${status.current_version} with ${status.latest_version}. ${status.recommended_action}${warning}`;
 	return `${status.current_version} is up to date${cacheQualifier(status.stale)}.${warning}`;
@@ -9311,56 +9437,487 @@ function updateInstallArgs(npmArgs, targetVersion) {
 	if (process.platform !== "win32") return installArgs;
 	return [...npmArgs.slice(0, 3), windowsCommandLine(npmArgs[3] ?? "", installArgs)];
 }
-async function installUpdate(options) {
-	let releaseInstallLock = null;
+function packageManagerEnvironment() {
+	const env = { ...process.env };
+	const protectedKeys = /* @__PURE__ */ new Set(["npm_config_registry", "npm_config_@codemem:registry"]);
+	if (process.platform === "linux") protectedKeys.add("onnxruntime_node_install");
+	for (const key of Object.keys(env)) if (protectedKeys.has(key.toLowerCase())) delete env[key];
+	env.npm_config_registry = PUBLIC_NPM_REGISTRY;
+	env["npm_config_@codemem:registry"] = PUBLIC_NPM_REGISTRY;
+	if (process.platform === "linux") env.ONNXRUNTIME_NODE_INSTALL = "skip";
+	return env;
+}
+function miseGlobalCwd() {
+	if (process.platform !== "win32") return "/";
+	const systemRoot = process.env.SystemRoot?.trim();
+	if (systemRoot) {
+		const root = win32.parse(systemRoot).root;
+		if (root) return root;
+	}
+	return process.env.HOME?.trim() || homedir();
+}
+function updateInstallCwd() {
+	return dirname(updateInstallLockPath());
+}
+async function resolveUpdateInstallCommand(installKind, targetVersion, pnpmCommand) {
+	if (installKind === "mise") return {
+		command: "mise",
+		args: [
+			"use",
+			"-g",
+			`npm:codemem@${targetVersion}`
+		],
+		cwd: miseGlobalCwd(),
+		env: packageManagerEnvironment()
+	};
+	if (installKind === "pnpm-global") {
+		const pnpm = pnpmCommand ?? await resolvePnpmCommand();
+		return {
+			...pnpm,
+			args: resolvedCommandArgs(pnpm, [
+				"add",
+				"-g",
+				"--registry",
+				PUBLIC_NPM_REGISTRY,
+				`--config.@codemem:registry=${PUBLIC_NPM_REGISTRY}`,
+				`codemem@${targetVersion}`,
+				`@codemem/embeddings@${targetVersion}`
+			]),
+			cwd: updateInstallCwd(),
+			env: packageManagerEnvironment()
+		};
+	}
+	const npm = await resolveNpmInstallCommand();
+	return {
+		command: npm.command,
+		args: updateInstallArgs(npm.args, targetVersion),
+		cwd: npm.cwd,
+		env: process.platform === "linux" ? {
+			...process.env,
+			ONNXRUNTIME_NODE_INSTALL: "skip"
+		} : void 0,
+		windowsVerbatimArguments: process.platform === "win32"
+	};
+}
+function installLaunchErrorMessage(installKind, targetVersion, error) {
+	if ((installKind === "mise" || installKind === "pnpm-global") && error instanceof Error && error.code === "ENOENT") {
+		if (installKind === "pnpm-global") return "pnpm was not found on PATH; install pnpm, then retry codemem update install";
+		return `mise was not found on PATH; install mise, then run mise use -g npm:codemem@${targetVersion}`;
+	}
+	return error instanceof Error ? error.message : "update installation failed";
+}
+function failedInstallMessage(installKind) {
+	if (installKind === "mise") return "mise installation failed";
+	if (installKind === "pnpm-global") return "pnpm installation failed";
+	return "npm installation failed";
+}
+async function runUpdateInstallCommand(installKind, targetVersion, pnpmCommand) {
+	const install = await resolveUpdateInstallCommand(installKind, targetVersion, pnpmCommand);
 	try {
-		const installKind = detectInstallKind({
-			entryPath: process.argv[1] ?? "",
-			env: process.env
+		return await runCommand(install.command, install.args, INSTALL_TIMEOUT_MS, {
+			cwd: install.cwd,
+			env: install.env,
+			maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES,
+			windowsVerbatimArguments: install.windowsVerbatimArguments
 		});
-		const status = await getUpdateStatus({
-			currentVersion: VERSION,
-			installKind,
-			refresh: true
+	} catch (error) {
+		throw new Error(installLaunchErrorMessage(installKind, targetVersion, error));
+	}
+}
+function parseMiseSourcePath(source) {
+	if (!source || typeof source !== "object" || Array.isArray(source)) return null;
+	const sourcePath = source.path;
+	return typeof sourcePath === "string" && sourcePath ? sourcePath : null;
+}
+function parseMiseStateRecord(record) {
+	if (!record || typeof record !== "object" || Array.isArray(record)) return null;
+	const candidate = record;
+	const sourcePath = parseMiseSourcePath(candidate.source);
+	const version = candidate.version;
+	const requestedVersion = candidate.requested_version;
+	if (typeof candidate.active !== "boolean" || typeof candidate.install_path !== "string" || !candidate.install_path || version !== void 0 && (typeof version !== "string" || !version) || requestedVersion !== void 0 && (typeof requestedVersion !== "string" || !requestedVersion) || typeof version !== "string" && typeof requestedVersion !== "string" || !sourcePath) return null;
+	return {
+		active: candidate.active,
+		installPath: candidate.install_path,
+		requestedVersion: typeof requestedVersion === "string" ? requestedVersion : null,
+		sourceIdentity: resolveComparablePath(sourcePath),
+		sourcePath,
+		version: typeof version === "string" ? version : null
+	};
+}
+function parseMiseState(raw) {
+	if (Buffer.byteLength(raw) > UPDATE_COMMAND_MAX_OUTPUT_BYTES) return null;
+	let payload;
+	try {
+		payload = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!Array.isArray(payload)) return null;
+	if (payload.length === 0) return {
+		empty: true,
+		state: null
+	};
+	if (payload.length !== 1) return null;
+	const state = parseMiseStateRecord(payload[0]);
+	return state ? {
+		empty: false,
+		state
+	} : null;
+}
+async function readMiseState(args, targetVersion, options = {}) {
+	try {
+		const result = await runCommand("mise", args, VERIFY_TIMEOUT_MS, {
+			cwd: options.cwd,
+			env: packageManagerEnvironment(),
+			maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES
 		});
-		if (!status.auto_update_eligible || !status.latest_version) {
-			failInstall(options, "update_install_refused", status.recommended_action);
-			return;
-		}
-		const targetVersion = status.latest_version;
-		if (!status.channel || !isReleaseVersionForChannel(targetVersion, status.channel)) {
-			failInstall(options, "update_install_refused", "release version does not match the installed channel");
-			return;
-		}
-		releaseInstallLock = await acquireInstallLock();
-		const npm = await resolveInstallCommand();
-		const installation = await runCommand(npm.command, updateInstallArgs(npm.args, targetVersion), INSTALL_TIMEOUT_MS, {
-			cwd: npm.cwd,
-			env: process.platform === "linux" ? {
-				...process.env,
-				ONNXRUNTIME_NODE_INSTALL: "skip"
-			} : void 0,
-			windowsVerbatimArguments: process.platform === "win32"
+		if (result.exitCode !== 0 || result.outputExceeded) return null;
+		return parseMiseState(result.stdout);
+	} catch (error) {
+		throw new Error(installLaunchErrorMessage("mise", targetVersion, error));
+	}
+}
+function isPathWithin(path, root) {
+	return path === root || path.startsWith(`${root}/`);
+}
+function isPathBelow(path, root) {
+	return path.startsWith(`${root}/`);
+}
+function isPortableAbsolutePath(value) {
+	return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function isSafeAbsoluteDirectory(value) {
+	if (!isPortableAbsolutePath(value)) return false;
+	const normalized = resolveComparablePath(value);
+	return normalized !== "/" && !/^[a-z]:$/i.test(normalized);
+}
+function resolveExistingComparablePath(value) {
+	try {
+		return resolveComparablePath(realpathSync(value));
+	} catch {
+		return null;
+	}
+}
+function parsePnpmPackageState(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.path !== "string" || !isPortableAbsolutePath(record.path) || typeof record.version !== "string" || !record.version) return null;
+	return {
+		path: record.path,
+		version: record.version
+	};
+}
+function parsePnpmGlobalState(raw) {
+	if (Buffer.byteLength(raw) > UPDATE_COMMAND_MAX_OUTPUT_BYTES) return null;
+	let payload;
+	try {
+		payload = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!Array.isArray(payload) || payload.length !== 1) return null;
+	const topLevel = payload[0];
+	if (!topLevel || typeof topLevel !== "object" || Array.isArray(topLevel)) return null;
+	const topLevelRecord = topLevel;
+	if (typeof topLevelRecord.private !== "boolean" || typeof topLevelRecord.path !== "string" || !isPortableAbsolutePath(topLevelRecord.path)) return null;
+	const dependencies = topLevelRecord.dependencies;
+	if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) return null;
+	const records = dependencies;
+	if (!Object.hasOwn(records, "codemem")) return null;
+	const codemem = parsePnpmPackageState(records.codemem);
+	if (!codemem) return null;
+	if (!Object.hasOwn(records, "@codemem/embeddings")) return {
+		codemem,
+		embeddings: null,
+		listRootPath: topLevelRecord.path
+	};
+	const embeddings = parsePnpmPackageState(records["@codemem/embeddings"]);
+	return embeddings ? {
+		codemem,
+		embeddings,
+		listRootPath: topLevelRecord.path
+	} : null;
+}
+function parsePnpmDirectory(raw) {
+	if (Buffer.byteLength(raw) > UPDATE_COMMAND_MAX_OUTPUT_BYTES) return null;
+	const directories = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).filter(isSafeAbsoluteDirectory).map(resolveExistingComparablePath).filter((directory) => directory !== null);
+	return directories.length === 1 ? directories[0] ?? null : null;
+}
+var PNPM_SETUP_GUIDANCE = "Run pnpm setup, then retry codemem update install";
+function isMissingPnpmGlobalBinDirectory(result) {
+	const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+	return output.includes("err_pnpm_global_bin_dir_not_in_path") || output.includes("configured global bin directory") && output.includes("is not in path");
+}
+async function runPnpmQuery(command, args) {
+	try {
+		return await runCommand(command.command, resolvedCommandArgs(command, args), VERIFY_TIMEOUT_MS, {
+			cwd: updateInstallCwd(),
+			maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES,
+			windowsVerbatimArguments: command.windowsVerbatimArguments
 		});
-		if (installation.exitCode !== 0) {
-			failInstall(options, "update_install_failed", installation.stderr.trim() || "npm installation failed");
-			return;
-		}
-		const codemem = await resolveVerificationCommand();
-		const verification = await runCommand(codemem.command, process.platform === "win32" ? [...codemem.args.slice(0, 3), windowsCommandLine(codemem.args[3] ?? "", ["version"])] : ["version"], VERIFY_TIMEOUT_MS, {
-			cwd: codemem.cwd,
-			windowsVerbatimArguments: process.platform === "win32"
+	} catch (error) {
+		if (error instanceof Error && error.code === "ENOENT") throw new PnpmOwnershipError("pnpm was not found on PATH; install pnpm, then retry codemem update install");
+		throw error;
+	}
+}
+async function requirePnpmQuery(command, args) {
+	const result = await runPnpmQuery(command, args);
+	const label = `pnpm ${args.join(" ")}`;
+	if (isMissingPnpmGlobalBinDirectory(result)) throw new PnpmOwnershipError(PNPM_SETUP_GUIDANCE);
+	if (result.outputExceeded) throw new PnpmOwnershipError(`${label} returned too much output; inspect pnpm global state`);
+	if (result.exitCode !== 0) throw new PnpmOwnershipError(`${label} failed${result.stderr.trim() ? `: ${result.stderr.trim()}` : "; inspect pnpm global configuration"}`);
+	return result.stdout;
+}
+async function provePnpmGlobalOwnership(plan) {
+	let command;
+	try {
+		command = await resolvePnpmCommand();
+	} catch (error) {
+		throw new PnpmOwnershipError(installLaunchErrorMessage("pnpm-global", plan.targetVersion, error));
+	}
+	const rootRaw = await requirePnpmQuery(command, ["root", "-g"]);
+	const binRaw = await requirePnpmQuery(command, ["bin", "-g"]);
+	const listRaw = await requirePnpmQuery(command, [
+		"list",
+		"-g",
+		"--depth",
+		"0",
+		"--json"
+	]);
+	const rootPath = parsePnpmDirectory(rootRaw);
+	if (!rootPath) throw new PnpmOwnershipError("pnpm root -g did not return one absolute non-root path");
+	const binPath = parsePnpmDirectory(binRaw);
+	if (!binPath) throw new PnpmOwnershipError("pnpm bin -g did not return one absolute non-root path");
+	const state = parsePnpmGlobalState(listRaw);
+	if (!state) throw new PnpmOwnershipError("pnpm list -g returned malformed or ambiguous global package state");
+	if (state.codemem.version !== VERSION) throw new PnpmOwnershipError(`pnpm global codemem is ${state.codemem.version}, but the running CLI is ${VERSION}`);
+	const listRootPath = resolveExistingComparablePath(state.listRootPath);
+	const legacyModulesPath = listRootPath ? resolveExistingComparablePath(join(listRootPath, "node_modules")) : null;
+	if (!listRootPath || rootPath !== listRootPath && rootPath !== legacyModulesPath) throw new PnpmOwnershipError("pnpm root -g is neither the pnpm list -g root nor its node_modules directory");
+	const packagePath = resolveExistingComparablePath(state.codemem.path);
+	if (!packagePath || !isPathBelow(packagePath, listRootPath)) throw new PnpmOwnershipError("pnpm list -g root does not own the listed codemem package path");
+	const entryPath = plan.runningEntryPath;
+	const canonicalEntryPath = entryPath ? resolveExistingComparablePath(entryPath) : null;
+	if (!canonicalEntryPath || !isPathWithin(canonicalEntryPath, packagePath)) throw new PnpmOwnershipError("the pnpm global codemem package does not own the running JavaScript entry");
+	return {
+		binPath,
+		command,
+		listRootPath
+	};
+}
+function isUserOwnedMiseSource(state) {
+	if (!isPortableAbsolutePath(state.sourcePath)) return false;
+	const sourcePath = resolveComparablePath(state.sourcePath);
+	const homePath = resolveComparablePath(process.env.HOME?.trim() || homedir());
+	if (homePath === "/" || /^[a-z]:$/i.test(homePath)) return false;
+	return isPathWithin(sourcePath, homePath);
+}
+function isLegacyUserMiseSource(state) {
+	if (!isUserOwnedMiseSource(state)) return false;
+	const home = process.env.HOME?.trim() || homedir();
+	const configHome = process.env.XDG_CONFIG_HOME?.trim() || join(home, ".config");
+	return state.sourceIdentity === resolveComparablePath(join(configHome, "mise.toml"));
+}
+function miseStateOwnsEntry(state, runningEntryPath) {
+	if (!runningEntryPath) return false;
+	if (!isPortableAbsolutePath(state.installPath)) return false;
+	const installPath = resolveComparablePath(state.installPath);
+	const entryPath = resolveComparablePath(runningEntryPath);
+	if (installPath === "/" || /^[a-z]:$/i.test(installPath)) return false;
+	return entryPath === installPath || entryPath.startsWith(`${installPath}/`);
+}
+async function proveGlobalMiseOwnership(plan) {
+	const activeState = (await readMiseState([
+		"ls",
+		"npm:codemem",
+		"--current",
+		"--json"
+	], plan.targetVersion))?.state;
+	if (!activeState?.active || !miseStateOwnsEntry(activeState, plan.runningEntryPath)) return null;
+	const globalQuery = await readMiseState([
+		"ls",
+		"npm:codemem",
+		"--global",
+		"--json"
+	], plan.targetVersion, { cwd: miseGlobalCwd() });
+	if (globalQuery?.empty && isLegacyUserMiseSource(activeState)) return activeState;
+	const globalState = globalQuery?.state;
+	if (!globalState?.active || activeState.sourceIdentity !== globalState.sourceIdentity || !isUserOwnedMiseSource(globalState)) return null;
+	return globalState;
+}
+async function resolveExplicitUpdatePlan(options) {
+	const detectedInstallKind = detectInstallKind({
+		entryPath: process.argv[1] ?? "",
+		env: process.env
+	});
+	const status = await getUpdateStatus({
+		currentVersion: VERSION,
+		installKind: detectedInstallKind,
+		refresh: true
+	});
+	if (!isExplicitUpdateInstallEligible(status) || !status.latest_version) {
+		failInstall(options, "update_install_refused", status.recommended_action);
+		return null;
+	}
+	if (!status.channel || !isReleaseVersionForChannel(status.latest_version, status.channel)) {
+		failInstall(options, "update_install_refused", "release version does not match the installed channel");
+		return null;
+	}
+	return {
+		installKind: status.install_kind,
+		manualGuidance: status.recommended_action,
+		runningEntryPath: detectedInstallKind === "mise" || detectedInstallKind === "pnpm-global" ? resolveRunningEntryPath(process.argv[1] ?? "") : null,
+		targetVersion: status.latest_version
+	};
+}
+function resolveRunningEntryPath(entryPath) {
+	return resolveComparablePath(entryPath);
+}
+async function verifyMiseInstalledVersion(plan) {
+	const globalState = (await readMiseState([
+		"ls",
+		"npm:codemem",
+		"--global",
+		"--json"
+	], plan.targetVersion, { cwd: miseGlobalCwd() }))?.state;
+	if (!globalState?.active || globalState.version !== plan.targetVersion && globalState.requestedVersion !== plan.targetVersion) return false;
+	const verification = await runCommand("mise", [
+		"exec",
+		"--",
+		"codemem",
+		"version"
+	], VERIFY_TIMEOUT_MS, {
+		cwd: miseGlobalCwd(),
+		env: packageManagerEnvironment(),
+		maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES
+	});
+	return !verification.outputExceeded && verification.exitCode === 0 && verification.stdout.trim() === plan.targetVersion;
+}
+function pnpmPackageStateError(state, ownership, targetVersion) {
+	if (!state.embeddings) return "pnpm update completed, but @codemem/embeddings is absent from global package state";
+	if (state.codemem.version !== targetVersion || state.embeddings.version !== targetVersion) return `pnpm update completed, but global package versions do not both equal ${targetVersion}`;
+	if (resolveExistingComparablePath(state.listRootPath) !== ownership.listRootPath) return "pnpm update completed, but the pnpm list -g root changed after ownership was proven";
+	if ([state.codemem.path, state.embeddings.path].map(resolveExistingComparablePath).some((packagePath) => !packagePath || !isPathBelow(packagePath, ownership.listRootPath))) return "pnpm update completed, but the pnpm list -g root does not own both package paths";
+	return null;
+}
+async function verifyPnpmOwnedLauncher(plan, ownership) {
+	const shimName = process.platform === "win32" ? "codemem.cmd" : "codemem";
+	const shimPath = join(ownership.binPath, shimName);
+	let verification;
+	try {
+		if (process.platform === "win32") verification = await runCommand(ownership.command.command, [
+			"/d",
+			"/s",
+			"/c",
+			windowsCommandLine(shimPath, ["version"])
+		], VERIFY_TIMEOUT_MS, {
+			cwd: updateInstallCwd(),
+			maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES,
+			windowsVerbatimArguments: true
 		});
-		if (verification.exitCode !== 0 || verification.stdout.trim() !== targetVersion) {
-			failInstall(options, "update_verification_failed", "installed version verification failed");
-			return;
-		}
-		const result = {
-			previous_version: VERSION,
-			installed_version: targetVersion
-		};
-		if (options.json) console.log(JSON.stringify(result));
-		else console.log(`Updated codemem from ${VERSION} to ${targetVersion}.`);
+		else verification = await runCommand(shimPath, ["version"], VERIFY_TIMEOUT_MS, {
+			cwd: updateInstallCwd(),
+			maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES
+		});
+	} catch (error) {
+		return `pnpm-owned codemem launcher could not be executed${error instanceof Error ? `: ${error.message}` : ""}`;
+	}
+	if (verification.outputExceeded) return "pnpm-owned codemem launcher returned too much output during version verification";
+	if (verification.exitCode !== 0) return "pnpm-owned codemem launcher failed during version verification";
+	const versionLines = verification.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(line));
+	if (versionLines.length !== 1 || versionLines[0] !== plan.targetVersion) return `pnpm-owned codemem launcher did not report ${plan.targetVersion}`;
+	return null;
+}
+async function verifyPnpmInstalledVersion(plan, ownership) {
+	let listRaw;
+	try {
+		listRaw = await requirePnpmQuery(ownership.command, [
+			"list",
+			"-g",
+			"--depth",
+			"0",
+			"--json"
+		]);
+	} catch (error) {
+		return error instanceof Error ? `pnpm update completed, but package-state verification failed: ${error.message}` : "pnpm update completed, but package-state verification failed";
+	}
+	const state = parsePnpmGlobalState(listRaw);
+	if (!state) return "pnpm update completed, but global package state is malformed or ambiguous";
+	const packageStateError = pnpmPackageStateError(state, ownership, plan.targetVersion);
+	if (packageStateError) return packageStateError;
+	return verifyPnpmOwnedLauncher(plan, ownership);
+}
+async function verifyInstalledVersion(plan) {
+	if (plan.installKind === "mise") return verifyMiseInstalledVersion(plan);
+	const codemem = await resolveVerificationCommand();
+	const verificationArgs = process.platform === "win32" ? [...codemem.args.slice(0, 3), windowsCommandLine(codemem.args[3] ?? "", ["version"])] : ["version"];
+	const verification = await runCommand(codemem.command, verificationArgs, VERIFY_TIMEOUT_MS, {
+		cwd: codemem.cwd,
+		maxOutputBytes: UPDATE_COMMAND_MAX_OUTPUT_BYTES,
+		windowsVerbatimArguments: process.platform === "win32"
+	});
+	return !verification.outputExceeded && verification.exitCode === 0 && verification.stdout.trim() === plan.targetVersion;
+}
+function emitInstallSuccess(options, targetVersion) {
+	const result = {
+		previous_version: VERSION,
+		installed_version: targetVersion
+	};
+	if (options.json) console.log(JSON.stringify(result));
+	else console.log(`Updated codemem from ${VERSION} to ${targetVersion}.`);
+}
+async function resolvePnpmOwnershipForExecution(options, plan) {
+	try {
+		return await provePnpmGlobalOwnership(plan);
+	} catch (error) {
+		failInstall(options, "update_install_refused", error instanceof Error ? error.message : "could not prove pnpm global ownership");
+		return null;
+	}
+}
+async function executeExplicitUpdate(options, plan) {
+	const globalMiseState = plan.installKind === "mise" ? await proveGlobalMiseOwnership(plan) : null;
+	if (plan.installKind === "mise" && !globalMiseState) {
+		failInstall(options, "update_install_refused", `Could not prove the active mise codemem installation is globally configured. ${plan.manualGuidance}`);
+		return;
+	}
+	const pnpmOwnership = plan.installKind === "pnpm-global" ? await resolvePnpmOwnershipForExecution(options, plan) : null;
+	if (plan.installKind === "pnpm-global" && !pnpmOwnership) return;
+	if (pnpmOwnership) {
+		await executePnpmUpdate(options, plan, pnpmOwnership);
+		return;
+	}
+	const installation = await runUpdateInstallCommand(plan.installKind, plan.targetVersion);
+	if (installation.exitCode !== 0 || installation.outputExceeded) {
+		failInstall(options, "update_install_failed", installation.stderr.trim() || failedInstallMessage(plan.installKind));
+		return;
+	}
+	if (!await verifyInstalledVersion(plan)) {
+		failInstall(options, "update_verification_failed", plan.installKind === "mise" ? "mise updated global configuration, but installed version verification failed; inspect the global mise codemem state before retrying" : "installed version verification failed");
+		return;
+	}
+	emitInstallSuccess(options, plan.targetVersion);
+}
+async function executePnpmUpdate(options, plan, ownership) {
+	const installation = await runUpdateInstallCommand(plan.installKind, plan.targetVersion, ownership.command);
+	if (installation.exitCode !== 0) {
+		failInstall(options, "update_install_failed", isMissingPnpmGlobalBinDirectory(installation) ? PNPM_SETUP_GUIDANCE : installation.stderr.trim() || failedInstallMessage(plan.installKind));
+		return;
+	}
+	const verificationError = await verifyPnpmInstalledVersion(plan, ownership);
+	if (verificationError) {
+		failInstall(options, "update_verification_failed", verificationError);
+		return;
+	}
+	emitInstallSuccess(options, plan.targetVersion);
+}
+async function installUpdate(options) {
+	let releaseInstallLock = null;
+	try {
+		const plan = await resolveExplicitUpdatePlan(options);
+		if (!plan) return;
+		releaseInstallLock = await acquireInstallLock();
+		await executeExplicitUpdate(options, plan);
 	} catch (error) {
 		failInstall(options, error instanceof UpdateInstallLockedError ? "update_install_locked" : "update_install_failed", error instanceof Error ? error.message : "update installation failed");
 	} finally {