@unbrained/pm-cli 2026.9.2 → 2026.9.3

package/dist/core/history/history.js

@@ -4,18 +4,20 @@
  * Implements append-only history and replay behavior for History.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1f78448d-a042-588a-84ce-369bd9ce8726")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
-import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
+import { EXIT_CODE, ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { runActiveServiceOverride } from "../extensions/index.js";
 import { appendLineAtomic } from "../fs/fs-utils.js";
 import { canonicalDocument } from "../item/item-format.js";
 import { toItemRecord } from "../item/item-record.js";
 import { orderObject, sha256Hex, stableStringify, } from "../shared/serialization.js";
-import { nowIso } from "../shared/time.js";
+import { isMillisecondPrecisionRfc3339DateTime, nowIso, } from "../shared/time.js";
 import { diagnoseAgentIdentity, resolveHistoryAgentIdentity, resolveHistoryAuthorSource, } from "../shared/author.js";
-import { removeHistoryEventIndexForHistoryPath, updateHistoryEventIndexAfterAppend, } from "./event-index.js";
+import { appendHistoryEntryWithEventIndex, removeHistoryEventIndexForHistoryPath, } from "./event-index.js";
+import { classifyHistoryEvent } from "./event-classification.js";
 import { invalidateHistoryDriftCacheForPath } from "./drift-cache.js";
+import { PmCliError } from "../shared/errors.js";
 const EMPTY_LEGACY_HASH_DOCUMENT = {
     front_matter: {},
     body: "",
@@ -42,7 +44,8 @@ function compareLegacyLinkedTests(left, right) {
         compareOptionalStrings(left.command, right.command),
         compareOptionalNumbers(left.timeout_seconds, right.timeout_seconds),
         compareOptionalStrings(left.pm_context_mode, right.pm_context_mode),
-        Number(Boolean(left.shared_host_safe)) - Number(Boolean(right.shared_host_safe)),
+        Number(Boolean(left.shared_host_safe)) -
+            Number(Boolean(right.shared_host_safe)),
         compareJsonValues(left.env_clear, right.env_clear, []),
         compareJsonValues(left.env_set, right.env_set, {}),
         compareJsonValues(left.assert_stdout_contains, right.assert_stdout_contains, []),
@@ -222,13 +225,14 @@ export function createHistoryEntry(params) {
     const provenanceOutcomes = agentIdentity.harness
         ? Object.fromEntries(Object.entries(diagnoseAgentIdentity().provenance_outcomes).filter(([, outcome]) => outcome.resolver !== undefined && outcome.status !== "resolved"))
         : undefined;
-    const context = provenanceOutcomes === undefined || Object.keys(provenanceOutcomes).length === 0
+    const context = provenanceOutcomes === undefined ||
+        Object.keys(provenanceOutcomes).length === 0
         ? params.context
         : {
             ...params.context,
             agent_provenance_outcomes: provenanceOutcomes,
         };
-    return {
+    const entry = {
         ts: params.nowIso,
         author: params.author,
         author_source: params.authorSource ?? resolveHistoryAuthorSource(params.author),
@@ -243,9 +247,7 @@ export function createHistoryEntry(params) {
         ...(agentIdentity.provenance
             ? { agent_provenance: agentIdentity.provenance }
             : {}),
-        ...(agentIdentity.episode
-            ? { agent_episode: agentIdentity.episode }
-            : {}),
+        ...(agentIdentity.episode ? { agent_episode: agentIdentity.episode } : {}),
         op: params.op,
         patch,
         before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
@@ -254,17 +256,34 @@ export function createHistoryEntry(params) {
         message: params.message === undefined ? undefined : params.message,
         ...(context === undefined ? {} : { context }),
     };
+    return { ...entry, event_class: classifyHistoryEvent(entry) };
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function invalidHistoryTimestamp(message) {
+    return new PmCliError(message, EXIT_CODE.GENERIC_FAILURE, {
+        code: "history_timestamp_invalid",
+    });
+}
 function fallbackHistoryTimestamp(entry) {
     const ts = entry.ts.trim();
-    return ts.length > 0 ? ts : nowIso();
+    if (ts.length === 0)
+        return nowIso();
+    if (!isMillisecondPrecisionRfc3339DateTime(ts)) {
+        throw invalidHistoryTimestamp("History timestamp must be a valid RFC 3339 date-time with millisecond precision");
+    }
+    if (ts !== entry.ts) {
+        throw invalidHistoryTimestamp("History timestamp must not contain surrounding whitespace");
+    }
+    return entry.ts;
 }
 function withHistoryTimestamp(value, fallbackTs) {
     const ts = value.ts;
     if (typeof ts === "string" && ts.trim().length > 0) {
+        if (!isMillisecondPrecisionRfc3339DateTime(ts)) {
+            throw invalidHistoryTimestamp("History timestamp must be a valid RFC 3339 date-time with millisecond precision");
+        }
         return value;
     }
     return { ...value, ts: fallbackTs };
@@ -272,14 +291,16 @@ function withHistoryTimestamp(value, fallbackTs) {
 function serializeHistoryLine(value, fallbackEntry) {
     const fallbackTs = fallbackHistoryTimestamp(fallbackEntry);
     if (typeof value === "string") {
+        let parsed;
         try {
-            const parsed = JSON.parse(value);
-            if (isRecord(parsed)) {
-                return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
-            }
+            parsed = JSON.parse(value);
         }
         catch {
             // Non-JSON extension lines are preserved for compatibility.
+            return value;
+        }
+        if (isRecord(parsed)) {
+            return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
         }
         return value;
     }
@@ -324,9 +345,17 @@ export async function appendHistoryEntry(historyPath, entry) {
             return;
         }
     }
-    await appendLineAtomic(historyPath, serializeHistoryLine(entry, entry));
+    const timestampedEntry = entry.ts.trim().length > 0
+        ? entry
+        : { ...entry, ts: fallbackHistoryTimestamp(entry) };
+    const normalizedEntry = {
+        ...timestampedEntry,
+        event_class: classifyHistoryEvent(timestampedEntry),
+    };
+    await appendHistoryEntryWithEventIndex(historyPath, normalizedEntry, async () => {
+        await appendLineAtomic(historyPath, serializeHistoryLine(normalizedEntry, normalizedEntry));
+    });
     await invalidateHistoryDriftCacheForPath(historyPath);
-    await updateHistoryEventIndexAfterAppend(historyPath, entry);
 }
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
 export const _testOnly = {
@@ -334,4 +363,4 @@ export const _testOnly = {
     isDefinedPointerPath,
 };
 //# sourceMappingURL=history.js.map
-//# debugId=60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79
+//# debugId=1f78448d-a042-588a-84ce-369bd9ce8726

package/dist/core/history/workspace-history.js

@@ -5,7 +5,7 @@
  * HistoryEntry format used by item mutations.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9027d972-ce29-5511-ba81-27e17d97446e")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4df21a17-43c0-5b63-adf3-657699e6a058")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { readFileIfExists, writeFileAtomic } from "../fs/fs-utils.js";
@@ -13,6 +13,7 @@ import { acquireLock } from "../lock/lock.js";
 import { EMPTY_CANONICAL_DOCUMENT, EXIT_CODE } from "../shared/constants.js";
 import { PmCliError } from "../shared/errors.js";
 import { stableStringify } from "../shared/serialization.js";
+import { nowIso } from "../shared/time.js";
 import { appendHistoryEntry, createHistoryEntry } from "./history.js";
 import { readHistoryEntries } from "./read.js";
 import { cloneEmptyReplayDocument, replayToItemDocument, tryApplyReplayPatch, verifyHistoryChain, } from "./replay.js";
@@ -153,7 +154,7 @@ async function appendWorkspaceHistoryChangeLocked(change) {
     if (idempotentEntry) {
         return { entry: idempotentEntry, historyPath };
     }
-    const timestamp = new Date().toISOString();
+    const timestamp = nowIso();
     const beforeDocument = entries.length === 0
         ? EMPTY_CANONICAL_DOCUMENT
         : replayWorkspaceEntries(entries);
@@ -222,7 +223,7 @@ export async function appendWorkspaceAuditEvent(options) {
             ? EMPTY_CANONICAL_DOCUMENT
             : replayWorkspaceEntries(entries);
         const entry = createHistoryEntry({
-            nowIso: new Date().toISOString(),
+            nowIso: nowIso(),
             author: options.author,
             op: options.op,
             before: beforeDocument,
@@ -340,7 +341,7 @@ export async function reconcileWorkspaceJsonHistory(options) {
         if (stableStringify(priorDocuments[documentPath]) === stableStringify(current)) {
             return { changed: false, historyPath };
         }
-        const timestamp = new Date().toISOString();
+        const timestamp = nowIso();
         const entry = createHistoryEntry({
             nowIso: timestamp,
             author: options.author,
@@ -393,7 +394,7 @@ export async function restoreWorkspaceJsonFromHistory(options) {
                 changed: false,
             };
         const beforeDocument = replayWorkspaceEntries(entries);
-        const timestamp = new Date().toISOString();
+        const timestamp = nowIso();
         const entry = createHistoryEntry({
             nowIso: timestamp,
             author: options.author,
@@ -430,4 +431,4 @@ export async function restoreWorkspaceJsonFromHistory(options) {
     }
 }
 //# sourceMappingURL=workspace-history.js.map
-//# debugId=9027d972-ce29-5511-ba81-27e17d97446e
+//# debugId=4df21a17-43c0-5b63-adf3-657699e6a058

package/dist/core/lock/lock.d.ts

@@ -2,6 +2,7 @@ interface LockInfo {
     id: string;
     pid: number;
     owner: string;
+    token?: string;
     created_at: string;
     ttl_seconds: number;
 }
@@ -14,14 +15,31 @@ interface StaleLockRemovalResult {
     shouldRetryCreate: boolean;
     staleRemovalCounted: boolean;
 }
+/** Stable operating-system identity for a process when the host exposes one. */
+export interface ProcessIdentity {
+    /** Operating-system process identifier captured with the owner record. */
+    pid: number;
+    /** Host process-start coordinate that distinguishes reuse of the same PID. */
+    process_start_identity?: string;
+}
 declare function parseLockInfo(raw: string): LockReadResult;
-declare function readLockInfo(lockPath: string): Promise<LockReadResult>;
+declare function readLockInfo(lockPath: string, emitReadHook?: boolean): Promise<LockReadResult>;
 declare function isErrno(error: unknown, code: string): boolean;
-declare function buildLockPayload(id: string, owner: string, ttlSeconds: number): LockInfo;
+declare function buildLockPayload(id: string, owner: string, ttlSeconds: number, token?: string): LockInfo;
 declare function isStaleLock(info: LockInfo | null, ttlSeconds: number): boolean;
 declare function lockOwnerSuffix(info: LockInfo | null): string;
 /** Resolves the effective bounded wait budget for a contended lock: the PM_LOCK_WAIT_MS environment override wins when it parses as a non-negative integer, then the caller-provided budget (settings `locks.wait_ms`), then 0 (fail-fast, the pre-wait behavior). */
 declare function resolveLockWaitMs(waitMs: number | undefined): number;
+declare function parseLinuxProcessStartIdentity(raw: string): string | null;
+/** Read the host process-start coordinate used to distinguish PID reuse. */
+export declare function readProcessStartIdentity(pid: number): Promise<string | null>;
+/** Capture the current PID plus a host process-start coordinate when available. */
+export declare function captureProcessIdentity(pid?: number): Promise<ProcessIdentity>;
+/**
+ * Verify that a captured process owner still exists, with a bounded grace
+ * period when the host cannot expose a reusable-PID-safe start coordinate.
+ */
+export declare function isProcessIdentityAlive(identity: ProcessIdentity, unverifiedAgeMs: number, maxUnverifiedAgeMs: number): Promise<boolean>;
 declare function acquireStaleCleanupGate(lockPath: string, _id: string): Promise<(() => Promise<void>) | null>;
 declare function removeConfirmedStaleLock(params: {
     lockPath: string;
@@ -43,6 +61,8 @@ export declare const _testOnly: {
     isStaleLock: typeof isStaleLock;
     lockOwnerSuffix: typeof lockOwnerSuffix;
     resolveLockWaitMs: typeof resolveLockWaitMs;
+    parseLinuxProcessStartIdentity: typeof parseLinuxProcessStartIdentity;
+    readProcessStartIdentity: typeof readProcessStartIdentity;
     acquireStaleCleanupGate: typeof acquireStaleCleanupGate;
     removeConfirmedStaleLock: typeof removeConfirmedStaleLock;
 };

package/dist/core/lock/lock.js

@@ -4,7 +4,7 @@
  * Coordinates tracker lock ownership and cleanup for Lock.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a9ad8a9f-de6e-5bce-8685-844f1129d5fb")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7352375d-55f2-5751-934e-ba0cd5c358d5")}catch(e){}}();
 import { isFileMissingError } from "../fs/fs-utils.js";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -36,12 +36,15 @@ function parseLockInfo(raw) {
     const id = candidate.id;
     const pid = candidate.pid;
     const owner = candidate.owner;
+    const token = candidate.token;
     const createdAt = candidate.created_at;
     const ttlSeconds = candidate.ttl_seconds;
     if (typeof id !== "string" ||
         typeof pid !== "number" ||
         !Number.isFinite(pid) ||
         typeof owner !== "string" ||
+        (token !== undefined &&
+            (typeof token !== "string" || token.trim().length === 0)) ||
         typeof createdAt !== "string" ||
         typeof ttlSeconds !== "number" ||
         !Number.isFinite(ttlSeconds)) {
@@ -55,19 +58,22 @@ function parseLockInfo(raw) {
             id,
             pid,
             owner,
+            ...(typeof token === "string" ? { token } : {}),
             created_at: createdAt,
             ttl_seconds: ttlSeconds,
         },
         warnings: [],
     };
 }
-async function readLockInfo(lockPath) {
+async function readLockInfo(lockPath, emitReadHook = true) {
     try {
         const raw = await fs.readFile(lockPath, "utf8");
-        await runActiveOnReadHooks({
-            path: lockPath,
-            scope: "project",
-        });
+        if (emitReadHook) {
+            await runActiveOnReadHooks({
+                path: lockPath,
+                scope: "project",
+            });
+        }
         return parseLockInfo(raw);
     }
     catch (error) {
@@ -96,20 +102,21 @@ async function emitLockWriteHook(lockPath, op) {
         op,
     });
 }
-function buildLockPayload(id, owner, ttlSeconds) {
+function buildLockPayload(id, owner, ttlSeconds, token = randomUUID()) {
     return {
         id,
         pid: process.pid,
         owner,
+        token,
         created_at: nowIso(),
         ttl_seconds: ttlSeconds,
     };
 }
-async function createLockFile(lockPath, id, owner, ttlSeconds) {
+async function createLockFile(lockPath, id, owner, ttlSeconds, token) {
     await fs.mkdir(path.dirname(lockPath), { recursive: true });
     const handle = await fs.open(lockPath, "wx");
     try {
-        await handle.writeFile(`${JSON.stringify(buildLockPayload(id, owner, ttlSeconds), null, 2)}\n`, "utf8");
+        await handle.writeFile(`${JSON.stringify(buildLockPayload(id, owner, ttlSeconds, token), null, 2)}\n`, "utf8");
     }
     finally {
         await handle.close();
@@ -127,6 +134,41 @@ async function unlinkLockWithHook(lockPath, op) {
         return false;
     }
 }
+async function releaseOwnedLock(lockPath, id, owner, token) {
+    const startedAtMs = Date.now();
+    let backoffMs = LOCK_WAIT_INITIAL_DELAY_MS;
+    for (;;) {
+        const releaseCleanupGate = await acquireStaleCleanupGate(lockPath, id);
+        if (releaseCleanupGate !== null) {
+            try {
+                const current = await readLockInfo(lockPath, false);
+                if (isOwnedLock(current.info, id, owner, token)) {
+                    await unlinkLockWithHook(lockPath, "lock:release");
+                }
+            }
+            finally {
+                await releaseCleanupGate();
+            }
+            return;
+        }
+        const current = await readLockInfo(lockPath, false);
+        if (!isOwnedLock(current.info, id, owner, token)) {
+            return;
+        }
+        const elapsedMs = Date.now() - startedAtMs;
+        if (elapsedMs >= LOCK_RELEASE_GATE_WAIT_MS) {
+            return;
+        }
+        await sleepWithJitter(Math.min(backoffMs, LOCK_RELEASE_GATE_WAIT_MS - elapsedMs));
+        backoffMs = Math.min(backoffMs * 2, LOCK_WAIT_MAX_DELAY_MS);
+    }
+}
+function isOwnedLock(info, id, owner, token) {
+    return (info?.id === id &&
+        info.pid === process.pid &&
+        info.owner === owner &&
+        info.token === token);
+}
 function isStaleLock(info, ttlSeconds) {
     const createdAtMs = info?.created_at
         ? Date.parse(info.created_at)
@@ -146,8 +188,8 @@ const MAX_STALE_LOCK_REMOVALS = 3;
 const STALE_CLEANUP_GATE_SUFFIX = ".stale-cleanup";
 const STALE_CLEANUP_GATE_OWNER_FILE = "owner.json";
 const STALE_CLEANUP_GATE_STALE_MS = 10_000;
-// Bounds PID-reuse false positives: a live recycled PID can delay cleanup, but not indefinitely.
-const STALE_CLEANUP_GATE_MAX_ACTIVE_MS = 5 * 60_000;
+const LOCK_RELEASE_GATE_WAIT_MS = STALE_CLEANUP_GATE_STALE_MS + LOCK_WAIT_MAX_DELAY_MS;
+const STALE_CLEANUP_GATE_MAX_UNVERIFIED_MS = 60 * 60_000;
 function parseNonNegativeIntegerWaitMs(value) {
     if (typeof value === "string") {
         const trimmed = value.trim();
@@ -220,14 +262,24 @@ function parseStaleCleanupGateOwner(raw) {
     const candidate = parsed;
     const pid = candidate.pid;
     const token = candidate.token;
+    const processStartIdentity = candidate.process_start_identity;
     if (typeof pid !== "number" ||
         !Number.isInteger(pid) ||
         pid <= 0 ||
         typeof token !== "string" ||
-        token.length === 0) {
+        token.length === 0 ||
+        (processStartIdentity !== undefined &&
+            (typeof processStartIdentity !== "string" ||
+                !/^\d+$/u.test(processStartIdentity)))) {
         return null;
     }
-    return { pid, token };
+    return {
+        pid,
+        token,
+        ...(typeof processStartIdentity === "string"
+            ? { process_start_identity: processStartIdentity }
+            : {}),
+    };
 }
 async function readStaleCleanupGateOwner(gatePath) {
     try {
@@ -238,6 +290,8 @@ async function readStaleCleanupGateOwner(gatePath) {
     }
 }
 function isProcessAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
     try {
         process.kill(pid, 0);
         return true;
@@ -249,6 +303,49 @@ function isProcessAlive(pid) {
         return true;
     }
 }
+function parseLinuxProcessStartIdentity(raw) {
+    const closeParenIndex = raw.lastIndexOf(")");
+    if (closeParenIndex < 0)
+        return null;
+    const startTime = raw
+        .slice(closeParenIndex + 2)
+        .trim()
+        .split(/\s+/u)[19];
+    return startTime !== undefined && /^\d+$/u.test(startTime) ? startTime : null;
+}
+/** Read the host process-start coordinate used to distinguish PID reuse. */
+export async function readProcessStartIdentity(pid) {
+    try {
+        return parseLinuxProcessStartIdentity(await fs.readFile(`/proc/${pid}/stat`, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Capture the current PID plus a host process-start coordinate when available. */
+export async function captureProcessIdentity(pid = process.pid) {
+    const processStartIdentity = await readProcessStartIdentity(pid);
+    return {
+        pid,
+        ...(processStartIdentity === null
+            ? {}
+            : { process_start_identity: processStartIdentity }),
+    };
+}
+/**
+ * Verify that a captured process owner still exists, with a bounded grace
+ * period when the host cannot expose a reusable-PID-safe start coordinate.
+ */
+export async function isProcessIdentityAlive(identity, unverifiedAgeMs, maxUnverifiedAgeMs) {
+    if (!isProcessAlive(identity.pid))
+        return false;
+    const currentStartIdentity = await readProcessStartIdentity(identity.pid);
+    if (identity.process_start_identity !== undefined &&
+        currentStartIdentity !== null) {
+        return currentStartIdentity === identity.process_start_identity;
+    }
+    return unverifiedAgeMs <= maxUnverifiedAgeMs;
+}
 async function removeStaleCleanupGateDirectory(gatePath) {
     try {
         await fs.rm(gatePath, { recursive: true, force: true });
@@ -275,7 +372,10 @@ async function tryCreateStaleCleanupGate(gatePath) {
         }
         return null;
     }
-    const owner = { pid: process.pid, token: randomUUID() };
+    const owner = {
+        ...(await captureProcessIdentity()),
+        token: randomUUID(),
+    };
     try {
         await fs.writeFile(path.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), `${JSON.stringify(owner)}\n`, "utf8");
     }
@@ -299,8 +399,7 @@ async function removeExpiredStaleCleanupGate(gatePath) {
     }
     const owner = await readStaleCleanupGateOwner(gatePath);
     if (owner !== null &&
-        isProcessAlive(owner.pid) &&
-        gateAgeMs <= STALE_CLEANUP_GATE_MAX_ACTIVE_MS) {
+        (await isProcessIdentityAlive(owner, gateAgeMs, STALE_CLEANUP_GATE_MAX_UNVERIFIED_MS))) {
         return false;
     }
     return removeStaleCleanupGateDirectory(gatePath);
@@ -369,6 +468,8 @@ export const _testOnly = {
     isStaleLock,
     lockOwnerSuffix,
     resolveLockWaitMs,
+    parseLinuxProcessStartIdentity,
+    readProcessStartIdentity,
     acquireStaleCleanupGate,
     removeConfirmedStaleLock,
 };
@@ -400,11 +501,12 @@ export async function acquireLock(pmRoot, id, ttlSeconds, owner, force = false,
     const startedAtMs = Date.now();
     let staleRemovals = 0;
     let backoffMs = LOCK_WAIT_INITIAL_DELAY_MS;
+    const token = randomUUID();
     for (;;) {
         try {
-            await createLockFile(lockPath, id, owner, ttlSeconds);
+            await createLockFile(lockPath, id, owner, ttlSeconds, token);
             return async () => {
-                await unlinkLockWithHook(lockPath, "lock:release");
+                await releaseOwnedLock(lockPath, id, owner, token);
                 await runActiveServiceOverride("lock_release", {
                     pm_root: pmRoot,
                     id,
@@ -447,4 +549,4 @@ export async function acquireLock(pmRoot, id, ttlSeconds, owner, force = false,
     }
 }
 //# sourceMappingURL=lock.js.map
-//# debugId=a9ad8a9f-de6e-5bce-8685-844f1129d5fb
+//# debugId=7352375d-55f2-5751-934e-ba0cd5c358d5

package/dist/core/output/output.js

@@ -4,13 +4,14 @@
  * Formats compact human and machine output for Output.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="202cbb3e-71fe-5701-a1f5-eb515bf56561")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fa89762b-915f-5ef0-a091-f05338c11683")}catch(e){}}();
 import { getActiveCommandContext, runActiveCommandOverride, runActiveRendererOverride, runActiveServiceOverrideSync, setActiveCommandResult, } from "../extensions/index.js";
 import { EXIT_CODE } from "../shared/constants.js";
 import { isHostOutputSuppressed } from "./output-control.js";
 import { projectMutationResult } from "./mutation-projection.js";
 import { attachReadOutputContracts } from "../../sdk/context-intent-contracts.js";
 import { attachOutputTokenAccounting } from "../../sdk/output-token-accounting.js";
+import { propagateContextUsageServingReceipt } from "../../sdk/context-usage.js";
 import { isReadOutputBudgetExceeded, resolveReadOutputEncoding, } from "../../sdk/read-output-contracts.js";
 import { encode as encodeToon } from "@toon-format/toon";
 const DECLARED_PROCESS_EXIT_CODES = new Set(Object.values(EXIT_CODE));
@@ -19,6 +20,18 @@ let streamErrorHandlersInstalled = false;
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function setActiveCommandResultOmitted(source) {
+    const omitted = { read_output: { result_omitted: true } };
+    propagateContextUsageServingReceipt(source, omitted);
+    setActiveCommandResult(omitted);
+}
+function setActiveCommandDeliveryResult(result, receiptSource, structuredDeliveryPreserved) {
+    if (structuredDeliveryPreserved) {
+        setActiveCommandResult(result);
+        return;
+    }
+    setActiveCommandResultOmitted(receiptSource);
+}
 function shouldUseNativeOutput(result) {
     return isPlainObject(result) && result[NATIVE_OUTPUT_MARKER] === true;
 }
@@ -346,11 +359,13 @@ function resolveOutputService(effectiveResult, nativeOutput, options, format) {
             rendered: serviceOverride.result.endsWith("\n")
                 ? serviceOverride.result
                 : `${serviceOverride.result}\n`,
+            structuredDeliveryPreserved: false,
         };
     }
     return {
         result: serviceOverride.handled ? serviceOverride.result : effectiveResult,
         rendered: null,
+        structuredDeliveryPreserved: !serviceOverride.handled || isPlainObject(serviceOverride.result),
     };
 }
 /** Formats a command result after command-level output ownership is resolved. */
@@ -382,9 +397,12 @@ function formatEffectiveOutput(effectiveResult, nativeOutput, options) {
         commandOptions: resolvedCommandOptions,
     };
     const service = resolveOutputService(effectiveResult, nativeOutput, effectiveOptions, format);
-    if (service.rendered !== null)
+    if (service.rendered !== null) {
+        setActiveCommandResultOmitted(effectiveResult);
         return service.rendered;
+    }
     const outputResult = service.result;
+    propagateContextUsageServingReceipt(effectiveResult, outputResult);
     const projectedOutputResult = command === "test"
         ? projectLinkedTestEvidence(outputResult, options.lean === true)
         : outputResult;
@@ -392,6 +410,7 @@ function formatEffectiveOutput(effectiveResult, nativeOutput, options) {
     if (isReadOutputBudgetExceeded(intentOutputResult)) {
         process.exitCode ||= EXIT_CODE.USAGE;
     }
+    let { structuredDeliveryPreserved } = service;
     const renderResolvedOutput = (value) => {
         if (format === "toon") {
             const markdownDefault = renderDefaultMarkdownResult(value);
@@ -402,6 +421,7 @@ function formatEffectiveOutput(effectiveResult, nativeOutput, options) {
             ? { rendered: null }
             : runActiveRendererOverride(format, value);
         if (rendererOverride.rendered !== null) {
+            structuredDeliveryPreserved = false;
             return rendererOverride.rendered.endsWith("\n")
                 ? rendererOverride.rendered
                 : `${rendererOverride.rendered}\n`;
@@ -414,7 +434,9 @@ function formatEffectiveOutput(effectiveResult, nativeOutput, options) {
     const accountedOutputResult = options.tokenAccounting === true
         ? attachOutputTokenAccounting(intentOutputResult, renderResolvedOutput)
         : intentOutputResult;
-    return renderResolvedOutput(accountedOutputResult);
+    const rendered = renderResolvedOutput(accountedOutputResult);
+    setActiveCommandDeliveryResult(accountedOutputResult, effectiveResult, options.quiet !== true && structuredDeliveryPreserved);
+    return rendered;
 }
 /** Implements format output for the public runtime surface of this module. */
 export function formatOutput(result, options) {
@@ -427,9 +449,11 @@ export function formatOutput(result, options) {
         ? suppressedOutput.result
         : stripNativeOutputMarker(commandOverride.result);
     setActiveCommandResult(effectiveResult);
-    return suppressedOutput
-        ? ""
-        : formatEffectiveOutput(effectiveResult, nativeOutput, options);
+    if (suppressedOutput) {
+        setActiveCommandResultOmitted(effectiveResult);
+        return "";
+    }
+    return formatEffectiveOutput(effectiveResult, nativeOutput, options);
 }
 /** Implements print result for the public runtime surface of this module. */
 export function printResult(result, options) {
@@ -468,4 +492,4 @@ export const outputTestOnly = {
     renderToonValue,
 };
 //# sourceMappingURL=output.js.map
-//# debugId=202cbb3e-71fe-5701-a1f5-eb515bf56561
+//# debugId=fa89762b-915f-5ef0-a091-f05338c11683

package/dist/core/shared/time.d.ts

@@ -4,6 +4,8 @@ export declare function nowIso(): string;
 export declare function isTimestampLiteral(input: string): boolean;
 /** Return whether a string is a calendar-valid RFC 3339 date-time. */
 export declare function isRfc3339DateTime(input: string): boolean;
+/** Return whether a value is a calendar-valid RFC 3339 date-time whose fractional seconds carry no sub-millisecond information. */
+export declare function isMillisecondPrecisionRfc3339DateTime(input: string): boolean;
 /** Implements compare timestamp strings for the public runtime surface of this module. */
 export declare function compareTimestampStrings(left: string, right: string): number;
 /** Timestamp-bearing record accepted by shared inclusive bound filtering. */

package/dist/core/shared/time.js

@@ -4,7 +4,7 @@
  * Provides shared primitives and utilities for Time.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7887e752-b1b8-5c5e-9dd8-93b41cb757af")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fb1102d4-1beb-5de8-87e6-af2efebafe39")}catch(e){}}();
 import { PmCliError } from "./errors.js";
 import { evictOldestMemoEntries } from "./memo.js";
 import { EXIT_CODE } from "./constants.js";
@@ -48,6 +48,12 @@ export function isRfc3339DateTime(input) {
         (offsetHourRaw === undefined || Number(offsetHourRaw) <= 23) &&
         (offsetMinuteRaw === undefined || Number(offsetMinuteRaw) <= 59));
 }
+/** Return whether a value is a calendar-valid RFC 3339 date-time whose fractional seconds carry no sub-millisecond information. */
+export function isMillisecondPrecisionRfc3339DateTime(input) {
+    const fraction = /\.(\d+)(?:Z|[+-]\d{2}:\d{2})$/iu.exec(input)?.[1];
+    return (isRfc3339DateTime(input) &&
+        (fraction === undefined || /^\d{0,3}0*$/u.test(fraction)));
+}
 /**
  * Memoized `Date.parse` for {@link compareTimestampStrings}. Sort comparators call it
  * O(n log n) times over a corpus whose timestamp strings repeat heavily, and
@@ -298,4 +304,4 @@ export const _testOnly = {
     isWhitespaceCharacter,
 };
 //# sourceMappingURL=time.js.map
-//# debugId=7887e752-b1b8-5c5e-9dd8-93b41cb757af
+//# debugId=fb1102d4-1beb-5de8-87e6-af2efebafe39