akm-cli 0.9.15-beta.1 → 0.9.15-beta.3

package/dist/commands/health.js

@@ -27,6 +27,7 @@ import { buildImproveSkipSummary, computeWallTimeStats, countAgentFailureReasons
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
 import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, } from "./health/metrics.js";
 import { collectPluginStalenessAdvisories } from "./health/plugin-staleness.js";
+import { collectSchedulerBinaryAdvisory } from "./health/scheduler-binary.js";
 import { collectStashExposureAdvisory } from "./health/stash-exposure.js";
 import { collectSurfacesAdvisories } from "./health/surfaces.js";
 import { buildPerRunSummaries } from "./health/task-runs.js";
@@ -542,6 +543,12 @@ export async function akmHealth(options = {}) {
         // above — started here, alongside it, and awaited later.
         const versionDriftPromise = collectVersionDriftAdvisory(Boolean(options.probe), { cliVersion: pkgVersion });
         versionDriftPromise.catch(() => undefined);
+        // #953: same --probe-gated, best-effort discipline as versionDriftPromise
+        // above.
+        const schedulerBinaryDriftPromise = collectSchedulerBinaryAdvisory(Boolean(options.probe), {
+            cliVersion: pkgVersion,
+        });
+        schedulerBinaryDriftPromise.catch(() => undefined);
         const taskHistory = gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now);
         const { tableNames, missingTables, probe } = taskHistory;
         const { egressConfigView, thinkingOffEngines } = gatherEgressConfigPhase();
@@ -559,6 +566,7 @@ export async function akmHealth(options = {}) {
         const improveRunsInLookbackWindow = countImproveRunsSince(db, engineLastUsedSinceIso);
         const engineProbes = await engineProbesPromise;
         const versionDrift = await versionDriftPromise;
+        const schedulerBinaryDrift = await schedulerBinaryDriftPromise;
         // Read once, shared by the `thinking-control` check (#949) and the
         // `metrics.llmUsage` report field below — same window, same aggregate.
         const llmUsage = readLlmUsageAggregate(stateDbPath, since);
@@ -592,6 +600,7 @@ export async function akmHealth(options = {}) {
             activeImproveStrategyEngines,
             engineLastUsed,
             improveRunsInLookbackWindow,
+            schedulerBinaryDrift,
         };
         for (const check of HEALTH_CHECKS) {
             const result = check.run(checkContext);

package/dist/commands/improve/locks.js

@@ -6,7 +6,7 @@ import { ConfigError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { releaseLock } from "../../core/file-lock.js";
 import { tryWithMaintenanceStartBarrier, withMaintenanceStartBarrier } from "../../core/maintenance-barrier.js";
-import { tryAcquireRunLock } from "../../core/run-lock.js";
+import { formatLockHolderPid, tryAcquireRunLock } from "../../core/run-lock.js";
 import { warn } from "../../core/warn.js";
 export function improveLockPath(lockBaseDir) {
     return path.join(lockBaseDir, "improve.lock");
@@ -59,7 +59,8 @@ function tryAcquireImproveLockUnlocked(lockPath, skipIfLocked, onRecovered) {
     if (result.state === "acquired") {
         return { state: "acquired", ownership: result.ownership };
     }
-    const { pid, startedAt } = result.holder;
+    const { startedAt } = result.holder;
+    const pid = formatLockHolderPid(result.holder);
     if (skipIfLocked) {
         warn(`[improve] another improve run holds the lock (PID ${pid}, started ${startedAt}); skipping (--skip-if-locked)`);
         return { state: "skipped" };

package/dist/commands/sources/installed-stashes.js

@@ -26,7 +26,7 @@ import { beginImmediateTransaction, getStateDbPath, openStateDatabase } from "..
 import { warn } from "../../core/warn.js";
 import { resolveGitContentRoot } from "../../core/write-source.js";
 import { withAssetMutationLease } from "../../indexer/index-writer-lock.js";
-import { akmIndex } from "../../indexer/indexer.js";
+import { akmIndex, runEmbeddingPass } from "../../indexer/indexer.js";
 import { compareAndSwapLockfileSnapshot, publishLockfileUpdate, readLockfile, readLockfileForUpdate, } from "../../integrations/lockfile.js";
 import { parseRegistryRef } from "../../registry/resolve.js";
 import { sha256Hex } from "../../runtime.js";
@@ -350,11 +350,19 @@ export async function akmRemove(input) {
         },
     };
 }
-/** Read the current index generation without creating or hydrating anything. */
+/**
+ * Read the current index generation without creating or hydrating anything.
+ * This path never ran an embedding pass (#954, field-report follow-up), so it has no
+ * `verification` to report — {@link buildUpdateResponse} falls back to the
+ * two facts it can actually know (whether semantic search is configured on
+ * at all) rather than fabricating verification numbers (`entryCount: 0`,
+ * `ok: true`) for a run that never verified anything.
+ */
 function readCurrentIndexSummary() {
     const db = openReadonlyExistingDatabase(getDbPath());
-    if (!db)
+    if (!db) {
         return { mode: "incremental", totalEntries: 0, directoriesScanned: 0, directoriesSkipped: 0 };
+    }
     try {
         return {
             mode: "incremental",
@@ -388,6 +396,12 @@ function buildUpdateResponse(stashDir, target, all, processed, opts) {
             directoriesScanned: index.directoriesScanned,
             directoriesSkipped: index.directoriesSkipped,
             ...(index.scanComplete !== undefined ? { scanComplete: index.scanComplete } : {}),
+            // A real embedding pass (`akmIndex`/`runEmbeddingPass`) reports its own
+            // verified `semanticStatus`. When no pass ran this update (the
+            // no-op/nothing-configured fallback) the only two facts known without
+            // fabricating a verification are whether semantic search is off at all
+            // or, if not, that its state is simply unverified this run.
+            semanticStatus: index.verification?.semanticStatus ?? (finalConfig.semanticSearchMode === "off" ? "disabled" : "pending"),
         },
     };
 }
@@ -499,6 +513,45 @@ function closeUnifiedUpdateTransaction(transaction, committed) {
             : `[akm bundle update] rolled back, but closing its database handles failed: ${String(closeError)}`);
     }
 }
+/**
+ * Run the embedding phase AFTER the coordinator's atomic commit, on its own
+ * fresh connection (#954). Before this, `akmUpdate` called
+ * `akmIndex()` for its embedding phase too, INSIDE this same unified
+ * `BEGIN IMMEDIATE` — so every per-batch commit the materializer opened
+ * nested as an unobservable SAVEPOINT, and a SIGKILL mid-run lost every
+ * embedding of the run rather than just the one in flight. The
+ * ambient-transaction drift guard (#954) now rejects that outright, so
+ * `akmIndex`'s own embedding phase is skipped for a deferred update
+ * transaction and this runs instead, once content/lock/index/state are
+ * already durably committed.
+ *
+ * A failing pass (provider down, timeout) does NOT fail the update: the
+ * bundle content and index are already committed successfully, exactly like
+ * a plain `akm index` whose embedding phase fails — only the reported
+ * `verification` reflects the shortfall (`semanticStatus: "blocked"`).
+ */
+async function runPostCommitEmbeddingPass(index) {
+    const config = loadConfig();
+    let db;
+    try {
+        const embeddingDim = config.embedding?.dimension;
+        db = openIndexDatabase(getDbPath(), embeddingDim ? { embeddingDim } : undefined);
+        const { verification } = await runEmbeddingPass({ db, config, onProgress: () => { } });
+        return { ...index, verification };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warn(`[akm bundle update] post-commit embedding pass failed: ${message}`);
+        return {
+            ...index,
+            verification: { ...index.verification, ok: false, semanticStatus: "blocked", message },
+        };
+    }
+    finally {
+        if (db)
+            closeDatabase(db);
+    }
+}
 function pathAtOrBelow(candidate, root) {
     const relative = path.relative(path.resolve(root), path.resolve(candidate));
     return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
@@ -779,14 +832,8 @@ async function publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowInse
                 updateTransactionHook("before-commit", id, { db: transaction.db });
                 commitUnifiedUpdateTransaction(transaction);
                 committed = true;
-                try {
-                    transaction.deferred.afterCommit?.();
-                }
-                catch (error) {
-                    warn(`[akm bundle update] committed, but semantic status refresh failed: ${String(error)}`);
-                }
                 prepared.publication?.commit();
-                return index;
+                return await runPostCommitEmbeddingPass(index);
             }
             catch (error) {
                 let recoveryError = transaction ? rollbackUnifiedUpdateTransaction(transaction) : undefined;
@@ -1093,12 +1140,6 @@ async function updateManagedInstall(managed, force, yes, stashDir, allowInsecure
                 updateTransactionHook("before-commit", managed.installId, { db: transaction.db });
                 commitUnifiedUpdateTransaction(transaction);
                 committed = true;
-                try {
-                    transaction.deferred.afterCommit?.();
-                }
-                catch (error) {
-                    warn(`[akm bundle update] committed, but semantic status refresh failed: ${String(error)}`);
-                }
             }
             catch (error) {
                 let recoveryError = transaction ? rollbackUnifiedUpdateTransaction(transaction) : undefined;
@@ -1146,6 +1187,7 @@ async function updateManagedInstall(managed, force, yes, stashDir, allowInsecure
                 }
             }
             prepared.publication?.commit();
+            index = await runPostCommitEmbeddingPass(index);
             if (movedRoot) {
                 const currentConfig = loadConfig();
                 const currentLocks = readLockfile();

package/dist/commands/sources/stash-cli.js

@@ -47,6 +47,8 @@ import { akmIndex } from "../../indexer/indexer.js";
 import { getHyphenatedBoolean, getOutputMode } from "../../output/context.js";
 import { inferAssetName, mergeXrefsIntoContent, readKnowledgeInput, resolveSupersedesForWrite, resolveSupersedesWriteTarget, resolveXrefsForWrite, writeMarkdownAsset, } from "../read/knowledge.js";
 import { assembleInfo } from "./info.js";
+/** Matches the high-frequency per-committed-batch progress line (#954), excluded from non-verbose JSON-mode stderr. */
+const EMBEDDED_BATCH_PROGRESS_PATTERN = /^Embedded \d+\/\d+ entries\.$/;
 export const indexCommand = defineCommand({
     meta: { name: "index", description: "Build search index (incremental by default; --full forces full reindex)" },
     args: {
@@ -98,6 +100,10 @@ export const indexCommand = defineCommand({
                     skipped: {
                         reason: "lock-held",
                         pid: lockAcquisition.holder.pid,
+                        // #956: the launcher pid (when known) alongside the pid that
+                        // actually holds the lock — every process listing and task log
+                        // shows the launcher pid, not the bun/node child's.
+                        launcherPid: lockAcquisition.holder.launcherPid,
                         startedAt: lockAcquisition.holder.startedAt,
                     },
                 });
@@ -137,6 +143,17 @@ export const indexCommand = defineCommand({
                             spin.stop(`${progressPrefix}${message}`);
                             spin.start(`${progressPrefix}${message}`);
                         }
+                        else if (!EMBEDDED_BATCH_PROGRESS_PATTERN.test(message)) {
+                            // Non-verbose, non-text (JSON/yaml/etc) mode: silence used to be
+                            // total until the run finished (#954) — a stalled
+                            // run looked identical to "nothing written". Phase-start
+                            // messages and the embedding heartbeat now reach stderr here
+                            // too; the high-frequency per-batch `Embedded N/M entries.`
+                            // line (emitted after every committed batch)
+                            // is deliberately excluded — that would be spam, not a
+                            // heartbeat.
+                            info(`[index:${phase}] ${progressPrefix}${message}`);
+                        }
                     },
                     signal: controller.signal,
                 });

package/dist/core/config/schema/embedding.js

@@ -33,10 +33,50 @@ export const EmbeddingConnectionConfigSchema = z
     // `akm index` when ensureSchema rejects it (§24.2 "Semantic" gate).
     dimension: positiveInt.max(4096).optional(),
     localModel: z.string().min(1).optional(),
+    /**
+     * Per-document token cap applied BEFORE batching (default 512,
+     * `DEFAULT_MAX_INPUT_TOKENS` in `src/llm/embedders/remote.ts`, #956).
+     * The materializer truncates a document's embedded text to
+     * this cap (head only, unicode-safe) instead of skipping it outright, so
+     * one oversized entry can no longer fail a whole batch. Distinct from
+     * `maxTokens` below, which bounds a whole HTTP REQUEST (many documents);
+     * this bounds one DOCUMENT.
+     */
+    maxInputTokens: positiveInt.optional(),
+    /**
+     * Client-side per-request token budget — how many documents' estimated
+     * tokens fit in one HTTP request (default `DEFAULT_TOKEN_BUDGET` = 6000
+     * in `src/llm/embedders/remote.ts`). With the 512-token `maxInputTokens`
+     * cap above, a request carries about 11 documents by default.
+     */
     maxTokens: positiveInt.optional(),
     batchSize: positiveInt.optional(),
-    chunkSize: positiveInt.optional(),
+    /**
+     * Ollama's `num_ctx` ONLY (#956) — sent verbatim as
+     * `options.num_ctx` on the native `/api/embed` request. It no longer also
+     * feeds the client-side request token budget (`maxTokens` above): the two
+     * used to share this one field, so setting it for the server's context
+     * window silently changed request batching too.
+     */
     contextLength: positiveInt.optional(),
     ollamaOptions: EmbeddingOllamaOptionsSchema.optional(),
+    /**
+     * Per-request timeout in milliseconds for a remote embedding request
+     * (default 120_000, `DEFAULT_EMBEDDING_TIMEOUT_MS` in
+     * `src/llm/embedders/remote.ts`). The prior fixed 30s cut off a slow
+     * local model server on a large token-bounded batch mid-response, with
+     * no retry — every batch that hit it was silently dropped (#954).
+     */
+    timeoutMs: positiveInt.optional(),
+    /**
+     * Overrides the fixed in-flight request window (#954, added after field
+     * evidence from multi-slot local servers). Bounded 1-16. Unset keeps
+     * today's default: 1 for a loopback endpoint, 2 for a remote one
+     * (`resolveEmbeddingConcurrency`, `src/llm/embedders/remote.ts`). Set it
+     * only for an endpoint that genuinely serves parallel requests (llama.cpp
+     * `--parallel N`, vLLM) — request SIZE (`batchSize`, `maxTokens`/
+     * `contextLength`) remains the first throughput lever.
+     */
+    concurrency: positiveInt.max(16).optional(),
 })
     .passthrough();

package/dist/core/errors.js

@@ -82,6 +82,7 @@ const USAGE_HINTS = {
 const TRANSIENT_HINTS = {
     RUN_LEASE_HELD: "Wait for the named engine invocation to finish or for the lease to expire, then retry. `akm workflow status <id>` shows the current lease.",
     STATE_DB_CONTENDED: "Another akm process is writing state.db right now. Wait a few seconds and retry; commands that support --skip-if-locked can skip instead of failing.",
+    INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs.",
 };
 /** Default hint for each NotFoundError code. */
 const NOT_FOUND_HINTS = {

package/dist/core/file-lock.js

@@ -120,9 +120,36 @@ function releaseLockRaw(lockPath) {
 export function tryAcquireLockSync(lockPath, payload) {
     return withLockOperationMutex(lockPath, () => tryAcquireLockRaw(lockPath, payload));
 }
-/** Build a PID-bearing payload with a unique token for one acquisition attempt. */
+/**
+ * Best-effort launcher pid from `AKM_LAUNCHER_PID` (set by
+ * `scripts/node-runtime/akm`/`akm-migrate`, #956) — undefined when unset,
+ * empty, or not a positive integer (never trust an ambient env var blindly
+ * into a lock message). Also the gate the parent-death watchdog
+ * (`core/parent-watchdog.ts`) uses to stay inert outside a launcher-managed
+ * run.
+ */
+export function launcherPidFromEnv() {
+    const raw = process.env.AKM_LAUNCHER_PID;
+    if (!raw)
+        return undefined;
+    const pid = Number.parseInt(raw, 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+/**
+ * Build a PID-bearing payload with a unique token for one acquisition attempt.
+ * Adds `launcherPid` (#956) whenever this process is running under the
+ * published launcher, so a lock's holder can be identified by the pid every
+ * process listing and task log actually shows (the launcher's) as well as
+ * the pid that holds the lock (the bun/node child).
+ */
 export function createLockPayload(metadata = {}) {
-    return JSON.stringify({ ...metadata, pid: process.pid, lockId: randomUUID() });
+    const launcherPid = launcherPidFromEnv();
+    return JSON.stringify({
+        ...metadata,
+        pid: process.pid,
+        ...(launcherPid !== undefined ? { launcherPid } : {}),
+        lockId: randomUUID(),
+    });
 }
 /**
  * Inspect an existing sentinel at `lockPath` without modifying it.
@@ -153,17 +180,17 @@ export function probeLock(lockPath, opts) {
         return { state: "absent" };
     const { rawContent, identity } = snapshot;
     const ageMs = Date.now() - identity.mtimeMs;
-    const holderPid = extractHolderPid(rawContent);
+    const { holderPid, launcherPid } = extractLockIdentity(rawContent);
     if (holderPid === undefined) {
         return { state: "stale", reason: "invalid_pid", ageMs, rawContent, identity };
     }
     if (!isProcessAlive(holderPid)) {
-        return { state: "stale", reason: "pid_dead", holderPid, ageMs, rawContent, identity };
+        return { state: "stale", reason: "pid_dead", holderPid, launcherPid, ageMs, rawContent, identity };
     }
     if (opts?.staleAfterMs !== undefined && ageMs > opts.staleAfterMs) {
-        return { state: "stale", reason: "age_exceeded", holderPid, ageMs, rawContent, identity };
+        return { state: "stale", reason: "age_exceeded", holderPid, launcherPid, ageMs, rawContent, identity };
     }
-    return { state: "held", holderPid, ageMs, rawContent, identity };
+    return { state: "held", holderPid, launcherPid, ageMs, rawContent, identity };
 }
 /**
  * Revalidate and quarantine the probed sentinel while holding the same operation
@@ -254,25 +281,32 @@ export function releaseLock(ownership) {
     });
 }
 /**
- * Extract a PID from a sentinel body. Accepts the two shapes used across
- * the codebase: a bare numeric string (config-io, vault, lockfile) and
- * a JSON object with a `pid` field (improve). Returns undefined when the
- * body is unparseable or yields a non-positive integer.
+ * Extract a holder pid, and (#956) a launcher pid when the payload recorded
+ * one, from a sentinel body. Accepts the two shapes used across the
+ * codebase: a bare numeric string (config-io, vault, lockfile — never
+ * carries a `launcherPid`) and a JSON object with `pid`/`launcherPid` fields
+ * (`createLockPayload`). `holderPid` is undefined when the body is
+ * unparseable or yields a non-positive integer; `launcherPid` is undefined
+ * whenever the payload has none, independent of whether `holderPid` parsed.
  */
-function extractHolderPid(content) {
+function extractLockIdentity(content) {
     const trimmed = content.trim();
     if (!trimmed)
-        return undefined;
+        return {};
     if (trimmed.startsWith("{")) {
         try {
             const parsed = JSON.parse(trimmed);
             const pid = typeof parsed.pid === "number" ? parsed.pid : Number.NaN;
-            return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+            const rawLauncherPid = typeof parsed.launcherPid === "number" ? parsed.launcherPid : Number.NaN;
+            return {
+                holderPid: Number.isInteger(pid) && pid > 0 ? pid : undefined,
+                launcherPid: Number.isInteger(rawLauncherPid) && rawLauncherPid > 0 ? rawLauncherPid : undefined,
+            };
         }
         catch {
-            return undefined;
+            return {};
         }
     }
     const pid = Number.parseInt(trimmed, 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+    return { holderPid: Number.isInteger(pid) && pid > 0 ? pid : undefined };
 }

package/dist/core/parent-watchdog.js

@@ -0,0 +1,64 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Parent-death watchdog (#956).
+ *
+ * The published launcher (`scripts/node-runtime/akm`) now forwards SIGTERM to
+ * its child, so a `kill <launcher-pid>` no longer orphans it — but a launcher
+ * that dies WITHOUT delivering a signal (SIGKILL, an out-of-memory kill, a
+ * supervisor that force-removes the process) still reparents the child to
+ * init with nothing to catch. Field evidence: 40 orphaned
+ * `bun …/dist/cli.js` processes over one day, up to 10h old, some created by
+ * a curate hook killing its own launcher on timeout — every akm invocation
+ * under the launcher is exposed to this, not only `akm index`, so this
+ * watchdog runs for every command (wired at the CLI entry point in
+ * `src/cli.ts`), not just index.
+ *
+ * `process.ppid` on POSIX changes the instant the parent exits (the child is
+ * reparented, usually to pid 1) — polling it is the standard orphan-detection
+ * trick when no direct death notification exists. This module owns only the
+ * poll/compare mechanics; the caller's `onOrphaned` decides what "stop"
+ * means. `src/cli.ts` wires it to `process.kill(process.pid, "SIGTERM")`,
+ * reusing the same self-signal every command already has rather than a
+ * second, parallel abort path. Only `akm index`/`improve` register their own
+ * SIGTERM listener (the index command's AbortController in
+ * `commands/sources/stash-cli.ts`) and get a graceful, in-process shutdown
+ * from it. Every other command has no listener of its own, so the runtime's
+ * default disposition terminates it directly — `exit` handlers (lock
+ * release included) do NOT run — and any lock it held is cleared later by
+ * the next acquirer's dead-pid stale-reclaim (`file-lock.ts`), not by
+ * in-process release. Either way the orphaned process stops, which is this
+ * watchdog's actual job.
+ */
+/** Pure comparison seam: true once the observed ppid differs from the one seen at startup. */
+export function isReparented(initialPpid, currentPpid) {
+    return currentPpid !== initialPpid;
+}
+/**
+ * Start polling `getPpid()` every `intervalMs` and invoke `onOrphaned` once,
+ * the first time the observed ppid no longer matches `initialPpid`. The timer
+ * is unref'ed so it never keeps the process alive on its own — a command that
+ * finishes normally still exits promptly.
+ */
+export function startParentDeathWatchdog(options) {
+    const { initialPpid, onOrphaned } = options;
+    const intervalMs = options.intervalMs ?? 2000;
+    const getPpid = options.getPpid ?? (() => process.ppid);
+    const setIntervalFn = options.setIntervalFn ?? setInterval;
+    const clearIntervalFn = options.clearIntervalFn ?? clearInterval;
+    let fired = false;
+    const timer = setIntervalFn(() => {
+        if (fired)
+            return;
+        if (isReparented(initialPpid, getPpid())) {
+            fired = true;
+            onOrphaned();
+        }
+    }, intervalMs);
+    if (typeof timer !== "number")
+        timer.unref?.();
+    return {
+        stop: () => clearIntervalFn(timer),
+    };
+}

package/dist/core/run-lock.js

@@ -31,6 +31,17 @@ import path from "node:path";
 import { ConfigError } from "./errors.js";
 import { createLockPayload, probeLock, reclaimStaleLock, tryAcquireLockSync } from "./file-lock.js";
 import { describeInaccessiblePath } from "./path-access.js";
+/**
+ * Render a lock holder's pid for a message: `"4242"`, or `"4242 (launcher
+ * 4240)"` when the holder's launcher pid is known (#956) — every process
+ * listing and task log shows the launcher pid, not the bun/node child's, so
+ * naming only the holder pid left an operator unable to connect the two.
+ */
+export function formatLockHolderPid(holder) {
+    if (holder.pid === null)
+        return "unknown";
+    return holder.launcherPid !== null ? `${holder.pid} (launcher ${holder.launcherPid})` : String(holder.pid);
+}
 function parseLockPayload(rawContent) {
     if (!rawContent)
         return null;
@@ -42,7 +53,7 @@ function parseLockPayload(rawContent) {
     }
 }
 function holderOf(lock) {
-    return { pid: lock?.pid ?? null, startedAt: lock?.startedAt ?? null };
+    return { pid: lock?.pid ?? null, startedAt: lock?.startedAt ?? null, launcherPid: lock?.launcherPid ?? null };
 }
 /**
  * Attempt to acquire `lockPath`. Returns `{ state: "acquired" }` with an
@@ -69,7 +80,7 @@ export function tryAcquireRunLock(lockPath, options) {
             return { state: "acquired", ownership };
         // Re-grabbed by another racer in this exact window — no holder detail
         // available without re-probing (which could itself race again).
-        return { state: "held", holder: { pid: null, startedAt: null } };
+        return { state: "held", holder: { pid: null, startedAt: null, launcherPid: null } };
     }
     if (probe.state === "inaccessible") {
         throw new ConfigError(`${options.label} lock exists but is not readable: ${describeInaccessiblePath(lockPath, probe.code)}.`, "DATA_DIR_UNREADABLE");

package/dist/indexer/index-rebuild-lock.js

@@ -22,7 +22,7 @@
 import { releaseLock } from "../core/file-lock.js";
 import { tryWithMaintenanceStartBarrier, withMaintenanceStartBarrier } from "../core/maintenance-barrier.js";
 import { getIndexRebuildLockPath } from "../core/paths.js";
-import { tryAcquireRunLock } from "../core/run-lock.js";
+import { formatLockHolderPid, tryAcquireRunLock } from "../core/run-lock.js";
 import { warn, warnVerbose } from "../core/warn.js";
 export function indexRebuildLockPath() {
     return getIndexRebuildLockPath();
@@ -53,18 +53,18 @@ export function tryAcquireIndexRebuildLock(skipIfLocked) {
         const result = tryWithMaintenanceStartBarrier(acquire);
         if (!result) {
             warn("[index] maintenance barrier held; skipping (--skip-if-locked)");
-            return { state: "skipped", holder: { pid: null, startedAt: null } };
+            return { state: "skipped", holder: { pid: null, startedAt: null, launcherPid: null } };
         }
         if (result.state === "acquired")
             return result;
-        warn(`[index] another index run holds the lock (PID ${result.holder.pid}, started ${result.holder.startedAt}); ` +
+        warn(`[index] another index run holds the lock (PID ${formatLockHolderPid(result.holder)}, started ${result.holder.startedAt}); ` +
             "skipping (--skip-if-locked)");
         return { state: "skipped", holder: result.holder };
     }
     const result = withMaintenanceStartBarrier(acquire);
     if (result.state === "acquired")
         return result;
-    warn(`[index] another index run is active (pid ${result.holder.pid}, started ${result.holder.startedAt}); ` +
+    warn(`[index] another index run is active (pid ${formatLockHolderPid(result.holder)}, started ${result.holder.startedAt}); ` +
         "this run will contend with it — pass --skip-if-locked for scheduled runs");
     return { state: "contended", holder: result.holder };
 }

package/dist/indexer/index-written-assets.js

@@ -27,6 +27,7 @@ import { isDataDirUnreadableError } from "../core/errors.js";
 import { probeLock } from "../core/file-lock.js";
 import { isPathAbsent } from "../core/path-access.js";
 import { getDbPath, getIndexRebuildLockPath } from "../core/paths.js";
+import { formatLockHolderPid } from "../core/run-lock.js";
 import { warn, warnVerbose } from "../core/warn.js";
 import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
 import { deleteEntriesByIds, getEntryCount, upsertEntry } from "../storage/repositories/index-entries-repository.js";
@@ -75,7 +76,14 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
             // rebuild in progress will pick up the change on its own.
             const rebuildProbe = probeLock(getIndexRebuildLockPath());
             if (rebuildProbe.state === "held") {
-                warn(`index rebuild in progress (pid ${rebuildProbe.holderPid}); the next index pass will index ${filePaths.join(", ")}`);
+                // #956: name the launcher pid alongside the holder pid when known —
+                // every process listing and task log shows the launcher's pid, not
+                // the bun/node child's.
+                const holderLabel = formatLockHolderPid({
+                    pid: rebuildProbe.holderPid,
+                    launcherPid: rebuildProbe.launcherPid ?? null,
+                });
+                warn(`index rebuild in progress (pid ${holderLabel}); the next index pass will index ${filePaths.join(", ")}`);
                 return true;
             }
             const dbPath = getDbPath();