@unbrained/pm-cli 2026.8.30 → 2026.9.1

package/dist/core/history/drift-scan.js

@@ -1,14 +1,14 @@
 
-!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]="65c0fed6-315a-5930-a23f-83996d3f5081")}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]="1c6c65ef-115b-50e2-815e-84f6e91158cd")}catch(e){}}();
 import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { getHistoryPath } from "../store/paths.js";
 import { isFileMissingError, writeFileAtomic } from "../fs/fs-utils.js";
-import { CURRENT_HISTORY_ITEM_HASH_VERSION, SUPPORTED_HISTORY_ITEM_HASH_VERSIONS, hashDocumentForVersion, } from "./history.js";
+import { CURRENT_HISTORY_ITEM_HASH_VERSION, SUPPORTED_HISTORY_ITEM_HASH_VERSIONS, hashDocumentVerificationCandidates, } from "./history.js";
 import { verifyHistoryChainWithVersion } from "./replay.js";
 import { getWorkspaceHistoryPath, inspectWorkspaceHistoryState, WORKSPACE_HISTORY_ID, } from "./workspace-history.js";
-const DRIFT_CACHE_VERSION = 7;
+const DRIFT_CACHE_VERSION = 9;
 const DRIFT_CACHE_FILENAME = "history-drift-cache.json";
 function getDriftCachePath(pmRoot) {
     return path.join(pmRoot, "runtime", DRIFT_CACHE_FILENAME);
@@ -237,8 +237,8 @@ async function scanItemHistory(pmRoot, item, cache, accumulator) {
     const { body, ...itemMetadata } = item;
     if (!resolved.verification.latestHashComparable)
         return resolved.cacheDirty;
-    const currentHash = hashDocumentForVersion({ metadata: itemMetadata, body }, resolved.verification.itemHashVersion);
-    if (currentHash !== resolved.verification.latestAfterHash)
+    const currentHashes = hashDocumentVerificationCandidates({ metadata: itemMetadata, body }, resolved.verification.itemHashVersion);
+    if (!currentHashes.includes(resolved.verification.latestAfterHash))
         accumulator.hashMismatches.push(item.id);
     return resolved.cacheDirty;
 }
@@ -330,4 +330,4 @@ export async function scanHistoryDrift(pmRoot, items, options = {}) {
     return { ...accumulator, driftedItems };
 }
 //# sourceMappingURL=drift-scan.js.map
-//# debugId=65c0fed6-315a-5930-a23f-83996d3f5081
+//# debugId=1c6c65ef-115b-50e2-815e-84f6e91158cd

package/dist/core/history/history.d.ts

@@ -12,6 +12,12 @@ declare function isDefinedPointerPath(document: unknown, path: string): boolean;
 export declare function hashDocument(document: ItemDocument): string;
 /** Hash an item with an explicit canonicalization epoch for replay compatibility. */
 export declare function hashDocumentForVersion(document: ItemDocument, version: HistoryItemHashVersion): string;
+/**
+ * Return the ordered hash candidates accepted when verifying one immutable
+ * history epoch. Epoch 2 has both its established expanded hash first and the
+ * earlier field-frozen writer hash second; the other epochs have one form.
+ */
+export declare function hashDocumentVerificationCandidates(document: ItemDocument, version: HistoryItemHashVersion): [string, ...string[]];
 /** Implements hash empty document for the public runtime surface of this module. */
 export declare function hashEmptyDocument(): string;
 /** Implements create history entry for the public runtime surface of this module. */

package/dist/core/history/history.js

@@ -4,7 +4,7 @@
  * 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]="8581413f-e74e-5db3-86bf-5e39290de741")}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]="60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
 import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { runActiveServiceOverride } from "../extensions/index.js";
@@ -117,7 +117,7 @@ function normalizeHistoryPatchOps(beforeDocument, patch) {
     }
     return normalized;
 }
-function canonicalHashDocument(document, version) {
+function canonicalHashDocument(document, version, legacyV2Fields = false) {
     const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
     if (!hasMetadata) {
         return {
@@ -126,12 +126,40 @@ function canonicalHashDocument(document, version) {
         };
     }
     const canonical = canonicalDocument(document);
-    const metadata = version === 1 && canonical.metadata.tests
+    // Epoch 1 and the earliest epoch-2 writer predate linked-test provenance,
+    // workspace isolation, per-execution receipts, and case-preserving
+    // dependency ids. Later epoch-2 writers included those fields without
+    // advancing the marker, so verification must retain both immutable forms.
+    const usesLegacyFields = version === 1 || (version === 2 && legacyV2Fields);
+    const epochMetadata = usesLegacyFields
         ? {
             ...canonical.metadata,
-            tests: [...canonical.metadata.tests].sort(compareLegacyLinkedTests),
+            ...(canonical.metadata.dependencies === undefined
+                ? {}
+                : {
+                    dependencies: canonical.metadata.dependencies.map((dependency) => ({
+                        ...dependency,
+                        id: dependency.id.toLowerCase(),
+                    })),
+                }),
+            ...(canonical.metadata.tests === undefined
+                ? {}
+                : {
+                    tests: canonical.metadata.tests.map(({ workspace_context_mode: _workspaceContextMode, provenance: _provenance, provenance_invalid: _provenanceInvalid, ...test }) => test),
+                }),
+            ...(canonical.metadata.test_runs === undefined
+                ? {}
+                : {
+                    test_runs: canonical.metadata.test_runs.map(({ executions: _executions, ...testRun }) => testRun),
+                }),
         }
         : canonical.metadata;
+    const metadata = version === 1 && epochMetadata.tests
+        ? {
+            ...epochMetadata,
+            tests: [...epochMetadata.tests].sort(compareLegacyLinkedTests),
+        }
+        : epochMetadata;
     const orderedMetadata = orderObject(toItemRecord(metadata), ITEM_METADATA_KEY_ORDER);
     return {
         front_matter: orderedMetadata,
@@ -164,6 +192,20 @@ export function hashDocumentForVersion(document, version) {
     }
     return sha256Hex(stableStringify(canonicalHashDocument(document, version)));
 }
+/**
+ * Return the ordered hash candidates accepted when verifying one immutable
+ * history epoch. Epoch 2 has both its established expanded hash first and the
+ * earlier field-frozen writer hash second; the other epochs have one form.
+ */
+export function hashDocumentVerificationCandidates(document, version) {
+    const canonicalHash = hashDocumentForVersion(document, version);
+    return version === 2
+        ? [
+            canonicalHash,
+            sha256Hex(stableStringify(canonicalHashDocument(document, version, true))),
+        ]
+        : [canonicalHash];
+}
 /** Implements hash empty document for the public runtime surface of this module. */
 export function hashEmptyDocument() {
     return sha256Hex(stableStringify(EMPTY_LEGACY_HASH_DOCUMENT));
@@ -292,4 +334,4 @@ export const _testOnly = {
     isDefinedPointerPath,
 };
 //# sourceMappingURL=history.js.map
-//# debugId=8581413f-e74e-5db3-86bf-5e39290de741
+//# debugId=60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79

package/dist/core/history/replay.d.ts

@@ -21,6 +21,12 @@ export declare const EMPTY_REPLAY_DOCUMENT: ReplayDocument;
 export declare function cloneEmptyReplayDocument(): ReplayDocument;
 /** Implements replay hash for the public runtime surface of this module. */
 export declare function replayHash(document: ReplayDocument, version?: HistoryItemHashVersion): string;
+/**
+ * Return hash candidates that preserve the semantic variant within an epoch.
+ * Duplicate values are intentional: before and after candidates use the same
+ * index when a patch introduces a field that distinguishes legacy epoch 2.
+ */
+export declare function replayHashVerificationCandidates(document: ReplayDocument, version: HistoryItemHashVersion): [string, ...string[]];
 /** Implements replay to item document for the public runtime surface of this module. */
 export declare function replayToItemDocument(document: ReplayDocument): ItemDocument;
 /** Converts a materialized replay document into a canonical item document. Use this when callers have already rejected the empty/deleted replay state and need restored metadata validated through the normal item-metadata rules. */
@@ -98,6 +104,11 @@ export interface ReanchorResult {
     /** Whether rewritten entries explicitly carry the hash epoch field. */
     explicitItemHashVersion: boolean;
 }
+/** Controls whether re-anchoring preserves historical writer transitions or emits one exact hash surface. */
+export interface ReanchorHistoryOptions {
+    /** Keep one semantic hash candidate for the complete rewritten stream so adjacent stored endpoints are identical. */
+    continuousHashSurface?: boolean;
+}
 /**
  * Resolve the hash epoch a repair must retain.
  *
@@ -108,6 +119,6 @@ export interface ReanchorResult {
  */
 export declare function resolveHistoryRepairItemHashVersion(entries: HistoryEntry[]): HistoryItemHashVersion;
 /** Re-anchor a drifted history chain: replay every entry from empty, recompute the before/after hashes, and only rewrite a patch when the original op set no longer strictly applies (legacy drift). Clean entries keep their patch verbatim so the on-disk diff stays minimal. The returned chain verifies via verifyHistoryChain. */
-export declare function reanchorHistoryEntries(entries: HistoryEntry[], itemHashVersion?: 1 | 2 | 3): ReanchorResult;
+export declare function reanchorHistoryEntries(entries: HistoryEntry[], itemHashVersion?: 1 | 2 | 3, options?: ReanchorHistoryOptions): ReanchorResult;
 /** Implements history entries to raw for the public runtime surface of this module. */
 export declare function historyEntriesToRaw(entries: HistoryEntry[]): string;

package/dist/core/history/replay.js

@@ -4,13 +4,13 @@
  * Implements append-only history and replay behavior for Replay.
  */
 
-!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]="c823af51-0cfd-536b-8f85-1f3e72db1c86")}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]="c9488ed4-8228-5e7c-9717-69dd7a3275c4")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
 import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { canonicalDocument } from "../item/item-format.js";
 import { toItemRecord } from "../item/item-record.js";
 import { orderObject, sha256Hex, stableStringify, } from "../shared/serialization.js";
-import { CURRENT_HISTORY_ITEM_HASH_VERSION, SUPPORTED_HISTORY_ITEM_HASH_VERSIONS, hashDocumentForVersion, } from "./history.js";
+import { CURRENT_HISTORY_ITEM_HASH_VERSION, SUPPORTED_HISTORY_ITEM_HASH_VERSIONS, hashDocumentVerificationCandidates, } from "./history.js";
 /** Public contract for empty replay document, shared by SDK and presentation-layer consumers. */
 export const EMPTY_REPLAY_DOCUMENT = {
     metadata: {},
@@ -22,23 +22,42 @@ export function cloneEmptyReplayDocument() {
 }
 /** Implements replay hash for the public runtime surface of this module. */
 export function replayHash(document, version = CURRENT_HISTORY_ITEM_HASH_VERSION) {
+    return replayHashVerificationCandidates(document, version)[0];
+}
+/**
+ * Return hash candidates that preserve the semantic variant within an epoch.
+ * Duplicate values are intentional: before and after candidates use the same
+ * index when a patch introduces a field that distinguishes legacy epoch 2.
+ */
+export function replayHashVerificationCandidates(document, version) {
     if (Object.keys(document.metadata).length === 0 ||
         Array.isArray(document.metadata.tags)) {
         try {
-            return hashDocumentForVersion(replayToItemDocument(document), version);
+            return hashDocumentVerificationCandidates(replayToItemDocument(document), version);
         }
         catch {
             // Fall through when another malformed legacy field cannot be canonicalized.
         }
     }
-    // Preserve the structural hashes recorded before missing tags became safe to
-    // normalize. Pre-create/legacy replay states and other malformed metadata cannot
-    // switch hash algorithms without invalidating immutable history chains.
-    return sha256Hex(stableStringify({
+    const fallback = sha256Hex(stableStringify({
         replay_fallback: true,
         metadata: document.metadata,
         body: document.body,
     }));
+    return version === 2 ? [fallback, fallback] : [fallback];
+}
+/** Match one recorded entry against corresponding before/after hash variants. */
+function matchReplayHashCandidates(before, after, version, entry) {
+    const beforeHashes = replayHashVerificationCandidates(before, version);
+    const afterHashes = replayHashVerificationCandidates(after, version);
+    return {
+        beforeHashes,
+        afterHashes,
+        pairIndex: beforeHashes.findIndex((beforeHash, hashIndex) => beforeHash === entry.before_hash &&
+            afterHashes[hashIndex] === entry.after_hash),
+        beforeIndex: beforeHashes.indexOf(entry.before_hash),
+        afterIndex: afterHashes.indexOf(entry.after_hash),
+    };
 }
 /** Implements replay to item document for the public runtime surface of this module. */
 export function replayToItemDocument(document) {
@@ -156,22 +175,9 @@ export function verifyHistoryChainWithVersion(entries) {
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         const explicitVersion = entry.item_hash_version;
-        if (isUnsupportedExplicitHistoryItemHashVersion(explicitVersion)) {
+        const unsupportedVersion = isUnsupportedExplicitHistoryItemHashVersion(explicitVersion);
+        if (unsupportedVersion) {
             errors.push(`verify_failed:unsupported_item_hash_version:${String(explicitVersion)}:entry_${index + 1}`);
-            const applied = tryApplyReplayPatch(replay, entry.patch);
-            if (!applied.ok) {
-                return {
-                    ok: false,
-                    errors: [
-                        ...errors,
-                        `verify_failed:patch_apply_failed:entry_${index + 1}`,
-                    ],
-                };
-            }
-            replay = applied.document;
-            detectedVersion = undefined;
-            authoritativeExplicitVersion = undefined;
-            continue;
         }
         const applied = tryApplyReplayPatch(replay, entry.patch);
         if (!applied.ok) {
@@ -183,30 +189,32 @@ export function verifyHistoryChainWithVersion(entries) {
                 ],
             };
         }
+        if (unsupportedVersion) {
+            replay = applied.document;
+            detectedVersion = undefined;
+            authoritativeExplicitVersion = undefined;
+            continue;
+        }
         // Prefer legacy epoch 1 when an unversioned entry is valid under both
         // algorithms, but retain compatibility with transitional epoch-2 writers
         // that shipped before item_hash_version became explicit.
         const candidates = historyEntryHashCandidates(explicitVersion, authoritativeExplicitVersion);
-        const beforeMatches = candidates.filter((version) => replayHash(replay, version) === entry.before_hash);
-        if (beforeMatches.length === 0) {
+        const candidateMatches = candidates.map((version) => ({
+            version,
+            match: matchReplayHashCandidates(replay, applied.document, version, entry),
+        }));
+        const matchingVersion = candidateMatches.find(({ match }) => match.pairIndex >= 0);
+        if (matchingVersion === undefined) {
+            const beforeMatches = candidateMatches.some(({ match }) => match.beforeIndex >= 0);
             return {
                 ok: false,
                 errors: [
                     ...errors,
-                    `verify_failed:before_hash_mismatch:entry_${index + 1}`,
-                ],
-            };
-        }
-        const version = beforeMatches.find((candidate) => replayHash(applied.document, candidate) === entry.after_hash);
-        if (version === undefined) {
-            return {
-                ok: false,
-                errors: [
-                    ...errors,
-                    `verify_failed:after_hash_mismatch:entry_${index + 1}`,
+                    `verify_failed:${beforeMatches ? "after" : "before"}_hash_mismatch:entry_${index + 1}`,
                 ],
             };
         }
+        const version = matchingVersion.version;
         replay = applied.document;
         detectedVersion = version;
         authoritativeExplicitVersion =
@@ -297,7 +305,7 @@ export function resolveHistoryRepairItemHashVersion(entries) {
     return CURRENT_HISTORY_ITEM_HASH_VERSION;
 }
 /** Re-anchor a drifted history chain: replay every entry from empty, recompute the before/after hashes, and only rewrite a patch when the original op set no longer strictly applies (legacy drift). Clean entries keep their patch verbatim so the on-disk diff stays minimal. The returned chain verifies via verifyHistoryChain. */
-export function reanchorHistoryEntries(entries, itemHashVersion = resolveHistoryRepairItemHashVersion(entries)) {
+export function reanchorHistoryEntries(entries, itemHashVersion = resolveHistoryRepairItemHashVersion(entries), options = {}) {
     const unsupportedIndex = entries.findIndex((entry) => isUnsupportedExplicitHistoryItemHashVersion(entry.item_hash_version));
     if (unsupportedIndex >= 0) {
         throw new TypeError(`unsupported_item_hash_version:${String(entries[unsupportedIndex]?.item_hash_version)}:entry_${unsupportedIndex + 1}`);
@@ -309,11 +317,11 @@ export function reanchorHistoryEntries(entries, itemHashVersion = resolveHistory
     let entriesPatchRepaired = 0;
     let convertedReplaceToAdd = 0;
     let skippedOps = 0;
+    let semanticIndex;
     const explicitItemHashVersion = itemHashVersion !== 1 ||
         entries.some((entry) => entry.item_hash_version !== undefined);
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        const beforeHash = replayHash(replay, itemHashVersion);
         const strict = tryApplyReplayPatch(replay, entry.patch);
         let next;
         let outPatch;
@@ -335,7 +343,20 @@ export function reanchorHistoryEntries(entries, itemHashVersion = resolveHistory
             skippedOps += entrySkipped;
             entriesPatchRepaired += 1;
         }
-        const afterHash = replayHash(next, itemHashVersion);
+        const hashMatch = matchReplayHashCandidates(replay, next, itemHashVersion, entry);
+        if (semanticIndex === undefined || options.continuousHashSurface !== true) {
+            semanticIndex = [
+                hashMatch.pairIndex,
+                hashMatch.beforeIndex,
+                hashMatch.afterIndex,
+                Math.min(semanticIndex ?? 0, hashMatch.beforeHashes.length - 1),
+            ].find((candidate) => candidate >= 0);
+        }
+        else {
+            semanticIndex = Math.min(semanticIndex, hashMatch.beforeHashes.length - 1);
+        }
+        const beforeHash = hashMatch.beforeHashes[semanticIndex];
+        const afterHash = hashMatch.afterHashes[semanticIndex];
         const rehashed = beforeHash !== entry.before_hash || afterHash !== entry.after_hash;
         if (rehashed) {
             entriesRehashed += 1;
@@ -382,4 +403,4 @@ export function historyEntriesToRaw(entries) {
     return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
 }
 //# sourceMappingURL=replay.js.map
-//# debugId=c823af51-0cfd-536b-8f85-1f3e72db1c86
+//# debugId=c9488ed4-8228-5e7c-9717-69dd7a3275c4

package/dist/core/schema/runtime-schema.d.ts

@@ -75,6 +75,10 @@ export interface RuntimeStatusRegistry {
     draft_statuses: Set<string>;
     /** Configured status id representing the open lifecycle state. */
     open_status: string;
+    /** Configured status id representing the in-progress lifecycle state. */
+    in_progress_status: string;
+    /** Configured status id representing the blocked lifecycle state. */
+    blocked_status: string;
     /** Configured status id representing the closed lifecycle state. */
     close_status: string;
     /** Configured status id representing the canceled lifecycle state. */

package/dist/core/schema/runtime-schema.js

@@ -4,7 +4,7 @@
  * Resolves configurable schema, fields, statuses, and workflows for Runtime Schema.
  */
 
-!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]="88b9179f-569e-5cd6-b67c-c27431961554")}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]="633ef301-42a3-5b73-a4ed-7af0e0e40371")}catch(e){}}();
 import path from "node:path";
 import { pathExists, readFileIfExists, writeFileAtomic, } from "../fs/fs-utils.js";
 import { DEFAULT_STATUS_DEFINITIONS, DEFAULT_WORKFLOW_DEFINITION, } from "../shared/constants.js";
@@ -52,8 +52,7 @@ const RUNTIME_FIELD_VALUE_SCHEMA_SHAPE_VALIDATORS = [
         (Array.isArray(schema.enum) &&
             schema.enum.every((entry) => isStructuredJsonValue(entry))),
     (schema) => schema.min_length === undefined ||
-        (Number.isInteger(schema.min_length) &&
-            schema.min_length >= 0),
+        (Number.isInteger(schema.min_length) && schema.min_length >= 0),
     (schema) => schema.min_items === undefined ||
         (Number.isInteger(schema.min_items) && schema.min_items >= 0),
     (schema) => schema.format === undefined || schema.format === "date-time",
@@ -62,8 +61,7 @@ const RUNTIME_FIELD_VALUE_SCHEMA_SHAPE_VALIDATORS = [
             schema.required.every((entry) => typeof entry === "string" && entry.length > 0)),
     (schema) => schema.additional_properties === undefined ||
         typeof schema.additional_properties === "boolean",
-    (schema) => schema.properties === undefined ||
-        isPlainObject(schema.properties),
+    (schema) => schema.properties === undefined || isPlainObject(schema.properties),
     (schema) => schema.one_of === undefined ||
         (Array.isArray(schema.one_of) && schema.one_of.length > 0),
 ];
@@ -137,9 +135,7 @@ function normalizeRuntimeFieldValueSchema(value, depth = 0, ancestors = new Set(
         min_items: minItems,
         format: format,
         properties: normalizedProperties,
-        required: required === undefined
-            ? undefined
-            : [...new Set(required)],
+        required: required === undefined ? undefined : [...new Set(required)],
         additional_properties: additionalProperties,
         items: normalizedItems,
         one_of: normalizedOneOf,
@@ -329,7 +325,10 @@ function normalizeRuntimeFieldDefinition(definition) {
         description: description && description.length > 0 ? description : undefined,
         type,
         commands,
-        repeatable: [definition.repeatable === true, type === "string_array"].includes(true),
+        repeatable: [
+            definition.repeatable === true,
+            type === "string_array",
+        ].includes(true),
         required: definition.required === true,
         required_on_create: definition.required_on_create === true,
         required_types: requiredTypes,
@@ -658,27 +657,22 @@ export async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
         created_paths: [],
     };
 }
-function preferredStatusForRole(definitions, role, fallbackValues) {
-    const withRole = definitions.filter((definition) => definition.roles.includes(role));
-    if (withRole.length > 0) {
-        return withRole[0].id;
-    }
+function preferredStatusForRole(definitions, role, fallbackValues, fallbackFirst = false) {
     const normalizedFallbacks = fallbackValues
         .map((value) => normalizeStatusId(value))
         .filter((value) => typeof value === "string");
-    for (const normalized of normalizedFallbacks) {
-        if (definitions.some((definition) => definition.id === normalized)) {
-            return normalized;
-        }
+    const fallbackMatch = normalizedFallbacks.find((normalized) => definitions.some((definition) => definition.id === normalized));
+    if (fallbackFirst && fallbackMatch !== undefined) {
+        return fallbackMatch;
     }
-    return definitions[0]?.id;
+    const withRole = definitions.find((definition) => definition.roles.includes(role));
+    if (withRole !== undefined) {
+        return withRole.id;
+    }
+    return fallbackMatch ?? definitions[0]?.id;
 }
-/** Implements resolve runtime status registry for the public runtime surface of this module. */
-export function resolveRuntimeStatusRegistry(schema) {
-    const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
-    const definitions = normalizedSchema.statuses
-        .map((definition, index) => normalizeRuntimeStatusDefinition(definition, index))
-        .filter((definition) => definition !== null);
+/** Build normalized identifier and alias indexes for runtime status lookup. */
+function buildRuntimeStatusIndexes(definitions) {
     const aliasToId = new Map();
     const byId = new Map();
     for (const definition of definitions) {
@@ -692,42 +686,58 @@ export function resolveRuntimeStatusRegistry(schema) {
             aliasToId.set(alias.replaceAll("_", " "), definition.id);
         }
     }
-    const terminalStatuses = new Set();
-    const terminalDoneStatuses = new Set();
-    const terminalCanceledStatuses = new Set();
-    const activeStatuses = new Set();
-    const blockedStatuses = new Set();
-    const draftStatuses = new Set();
+    return { aliasToId, byId };
+}
+/** Classify runtime statuses into lifecycle role sets used by all consumers. */
+function buildRuntimeStatusRoleSets(definitions) {
+    const result = {
+        activeStatuses: new Set(),
+        blockedStatuses: new Set(),
+        draftStatuses: new Set(),
+        terminalCanceledStatuses: new Set(),
+        terminalDoneStatuses: new Set(),
+        terminalStatuses: new Set(),
+    };
     for (const definition of definitions) {
         const roles = new Set(definition.roles);
         if (roles.has("terminal") ||
             roles.has("terminal_done") ||
             roles.has("terminal_canceled")) {
-            terminalStatuses.add(definition.id);
-        }
-        if (roles.has("terminal_done")) {
-            terminalDoneStatuses.add(definition.id);
+            result.terminalStatuses.add(definition.id);
         }
+        if (roles.has("terminal_done"))
+            result.terminalDoneStatuses.add(definition.id);
         if (roles.has("terminal_canceled")) {
-            terminalCanceledStatuses.add(definition.id);
-        }
-        if (roles.has("active")) {
-            activeStatuses.add(definition.id);
-        }
-        if (roles.has("blocked")) {
-            blockedStatuses.add(definition.id);
-        }
-        if (roles.has("draft")) {
-            draftStatuses.add(definition.id);
+            result.terminalCanceledStatuses.add(definition.id);
         }
+        if (roles.has("active"))
+            result.activeStatuses.add(definition.id);
+        if (roles.has("blocked"))
+            result.blockedStatuses.add(definition.id);
+        if (roles.has("draft"))
+            result.draftStatuses.add(definition.id);
     }
+    return result;
+}
+/** Implements resolve runtime status registry for the public runtime surface of this module. */
+export function resolveRuntimeStatusRegistry(schema) {
+    const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
+    const definitions = normalizedSchema.statuses
+        .map((definition, index) => normalizeRuntimeStatusDefinition(definition, index))
+        .filter((definition) => definition !== null);
+    const { aliasToId, byId } = buildRuntimeStatusIndexes(definitions);
+    const { activeStatuses, blockedStatuses, draftStatuses, terminalCanceledStatuses, terminalDoneStatuses, terminalStatuses, } = buildRuntimeStatusRoleSets(definitions);
     const workflow = normalizedSchema.workflow;
-    const openStatus = normalizeStatusId(workflow.open_status) ??
+    const openStatus = (normalizeStatusId(workflow.open_status) ??
         preferredStatusForRole(definitions, "default_open", [
             "open",
             "in_progress",
             STATUS_VALUES[0],
-        ]);
+        ]));
+    const inProgressStatus = normalizeStatusId(workflow.in_progress_status) ??
+        preferredStatusForRole(definitions, "active", ["in_progress", "in-progress", openStatus], true);
+    const blockedStatus = normalizeStatusId(workflow.blocked_status) ??
+        preferredStatusForRole(definitions, "blocked", ["blocked"]);
     const closeStatus = normalizeStatusId(workflow.close_status) ??
         preferredStatusForRole(definitions, "default_close", [
             "closed",
@@ -750,6 +760,8 @@ export function resolveRuntimeStatusRegistry(schema) {
         blocked_statuses: blockedStatuses,
         draft_statuses: draftStatuses,
         open_status: openStatus,
+        in_progress_status: inProgressStatus,
+        blocked_status: blockedStatus,
         close_status: closeStatus,
         canceled_status: canceledStatus,
     };
@@ -812,4 +824,4 @@ export function statusIsTerminal(status, registry) {
     return registry.terminal_statuses.has(normalized);
 }
 //# sourceMappingURL=runtime-schema.js.map
-//# debugId=88b9179f-569e-5cd6-b67c-c27431961554
+//# debugId=633ef301-42a3-5b73-a4ed-7af0e0e40371

package/dist/core/schema/status-defs-file.js

@@ -4,7 +4,7 @@
  * Resolves configurable schema, fields, statuses, and workflows for Status Defs File.
  */
 
-!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]="3eac0218-43c9-5bd2-8eaf-589d02d2c8ad")}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]="ec456832-5120-5171-93fd-861ea4125acb")}catch(e){}}();
 import { RUNTIME_STATUS_ROLE_VALUES } from "../../types/index.js";
 import { DEFAULT_RUNTIME_STATUS_DEFINITIONS } from "./runtime-schema.js";
 import { normalizeStatusToken } from "./status-token.js";
@@ -72,6 +72,9 @@ export function normalizeAddStatusInput(raw) {
                 roles.push(role);
             }
         }
+        if (roles.length === 0) {
+            throw new Error(`Status role must include at least one lifecycle role. Allowed roles: ${RUNTIME_STATUS_ROLE_VALUES.join(", ")}.`);
+        }
     }
     const aliases = raw.aliases === undefined
         ? undefined
@@ -222,4 +225,4 @@ export function assertStatusTokensAvailable(input, resolvedAliasToId) {
     }
 }
 //# sourceMappingURL=status-defs-file.js.map
-//# debugId=3eac0218-43c9-5bd2-8eaf-589d02d2c8ad
+//# debugId=ec456832-5120-5171-93fd-861ea4125acb

package/dist/mcp/legacy-adapter.d.ts

@@ -1,11 +1,11 @@
 /**
  * @module mcp/legacy-adapter
  *
- * Isolates the bounded MCP 2025-06-18 stdio compatibility surface from the
+ * Isolates the bounded initialize-era stdio compatibility surface from the
  * canonical stateless dispatcher. No modern transport imports policy from it.
  */
 import { type AgentClientInfo } from "../sdk/runtime-primitives.js";
-import { type PmMcpImplementation, type PmMcpServerCapabilities } from "../sdk/mcp/protocol.js";
+import { PM_MCP_LEGACY_PROTOCOL_VERSIONS, type PmMcpImplementation, type PmMcpServerCapabilities } from "../sdk/mcp/protocol.js";
 /** Minimal request shape consumed by the compatibility adapter. */
 export interface LegacyMcpRequest {
     /** Legacy method name. */
@@ -36,6 +36,15 @@ export interface LegacyMcpAdapterOptions {
     /** Render one legacy prompt. */
     getPrompt: (params: Record<string, unknown> | undefined) => Record<string, unknown>;
 }
+/**
+ * Resolve the legacy revision a handshake negotiates, or refuse with the full
+ * supported set.
+ *
+ * A legacy client has no fall-forward mechanism, so the refusal names every
+ * accepted legacy revision alongside the canonical modern one: the error text
+ * is the only diagnostic such a client can surface.
+ */
+export declare function resolveLegacyProtocolVersion(requestedVersion: unknown): (typeof PM_MCP_LEGACY_PROTOCOL_VERSIONS)[number];
 /** Explicit compatibility adapter with no cross-process or modern-session role. */
 export declare class LegacyMcpAdapter {
     #private;