@unbrained/pm-cli 2026.8.10 → 2026.8.12

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]="ce2dace3-7c86-5edf-8bda-083a0b3e7f2b")}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]="2fc7f675-3500-5abb-8d5c-9ca9caa803b6")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
 import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { runActiveServiceOverride } from "../extensions/index.js";
@@ -20,6 +20,42 @@ const EMPTY_LEGACY_HASH_DOCUMENT = {
     front_matter: {},
     body: "",
 };
+/** Hash epoch that preserves linked-test insertion order in immutable history. */
+export const CURRENT_HISTORY_ITEM_HASH_VERSION = 2;
+/** Hash epochs understood by this runtime. */
+export const SUPPORTED_HISTORY_ITEM_HASH_VERSIONS = [1, 2];
+function compareOptionalStrings(left, right) {
+    return (left ?? "").localeCompare(right ?? "");
+}
+function compareOptionalNumbers(left, right) {
+    return (left ?? 0) - (right ?? 0);
+}
+function compareJsonValues(left, right, fallback) {
+    // Preserve the original v1 comparator byte-for-byte: replacing JSON.stringify
+    // with stableStringify would invalidate immutable hashes from legacy streams.
+    return JSON.stringify(left ?? fallback).localeCompare(JSON.stringify(right ?? fallback));
+}
+function compareLegacyLinkedTests(left, right) {
+    const comparisons = [
+        left.scope.localeCompare(right.scope),
+        compareOptionalStrings(left.path, right.path),
+        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)),
+        compareJsonValues(left.env_clear, right.env_clear, []),
+        compareJsonValues(left.env_set, right.env_set, {}),
+        compareJsonValues(left.assert_stdout_contains, right.assert_stdout_contains, []),
+        compareJsonValues(left.assert_stdout_regex, right.assert_stdout_regex, []),
+        compareJsonValues(left.assert_stderr_contains, right.assert_stderr_contains, []),
+        compareJsonValues(left.assert_stderr_regex, right.assert_stderr_regex, []),
+        compareOptionalNumbers(left.assert_stdout_min_lines, right.assert_stdout_min_lines),
+        compareJsonValues(left.assert_json_field_equals, right.assert_json_field_equals, {}),
+        compareJsonValues(left.assert_json_field_gte, right.assert_json_field_gte, {}),
+        compareOptionalStrings(left.note, right.note),
+    ];
+    return comparisons.find((comparison) => comparison !== 0) ?? 0;
+}
 function decodeJsonPointer(path) {
     if (!path || path === "/") {
         return [];
@@ -81,7 +117,7 @@ function normalizeHistoryPatchOps(beforeDocument, patch) {
     }
     return normalized;
 }
-function canonicalHashDocument(document) {
+function canonicalHashDocument(document, version) {
     const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
     if (!hasMetadata) {
         return {
@@ -90,7 +126,13 @@ function canonicalHashDocument(document) {
         };
     }
     const canonical = canonicalDocument(document);
-    const orderedMetadata = orderObject(toItemRecord(canonical.metadata), ITEM_METADATA_KEY_ORDER);
+    const metadata = version === 1 && canonical.metadata.tests
+        ? {
+            ...canonical.metadata,
+            tests: [...canonical.metadata.tests].sort(compareLegacyLinkedTests),
+        }
+        : canonical.metadata;
+    const orderedMetadata = orderObject(toItemRecord(metadata), ITEM_METADATA_KEY_ORDER);
     return {
         front_matter: orderedMetadata,
         body: canonical.body,
@@ -113,7 +155,14 @@ function canonicalPatchDocument(document) {
 }
 /** Implements hash document for the public runtime surface of this module. */
 export function hashDocument(document) {
-    return sha256Hex(stableStringify(canonicalHashDocument(document)));
+    return hashDocumentForVersion(document, CURRENT_HISTORY_ITEM_HASH_VERSION);
+}
+/** Hash an item with an explicit canonicalization epoch for replay compatibility. */
+export function hashDocumentForVersion(document, version) {
+    if (!SUPPORTED_HISTORY_ITEM_HASH_VERSIONS.some((supportedVersion) => supportedVersion === version)) {
+        throw new TypeError(`unsupported_item_hash_version:${String(version)}`);
+    }
+    return sha256Hex(stableStringify(canonicalHashDocument(document, version)));
 }
 /** Implements hash empty document for the public runtime surface of this module. */
 export function hashEmptyDocument() {
@@ -121,8 +170,8 @@ export function hashEmptyDocument() {
 }
 /** Implements create history entry for the public runtime surface of this module. */
 export function createHistoryEntry(params) {
-    const beforeHashCanonical = canonicalHashDocument(params.before);
-    const afterHashCanonical = canonicalHashDocument(params.after);
+    const beforeHashCanonical = canonicalHashDocument(params.before, CURRENT_HISTORY_ITEM_HASH_VERSION);
+    const afterHashCanonical = canonicalHashDocument(params.after, CURRENT_HISTORY_ITEM_HASH_VERSION);
     const beforePatchCanonical = canonicalPatchDocument(params.before);
     const afterPatchCanonical = canonicalPatchDocument(params.after);
     const rawPatch = jsonPatch.compare(beforePatchCanonical, afterPatchCanonical);
@@ -159,6 +208,7 @@ export function createHistoryEntry(params) {
         patch,
         before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
         after_hash: sha256Hex(stableStringify(afterHashCanonical)),
+        item_hash_version: CURRENT_HISTORY_ITEM_HASH_VERSION,
         message: params.message === undefined ? undefined : params.message,
         ...(context === undefined ? {} : { context }),
     };
@@ -242,4 +292,4 @@ export const _testOnly = {
     isDefinedPointerPath,
 };
 //# sourceMappingURL=history.js.map
-//# debugId=ce2dace3-7c86-5edf-8bda-083a0b3e7f2b
+//# debugId=2fc7f675-3500-5abb-8d5c-9ca9caa803b6

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

@@ -1,4 +1,5 @@
 import { canonicalDocument } from "../item/item-format.js";
+import { type HistoryItemHashVersion } from "./history.js";
 import type { HistoryEntry, HistoryPatchOp, ItemDocument } from "../../types/index.js";
 /**
  * Shared history replay/patch mechanics single-sourced for the history, restore,
@@ -19,7 +20,7 @@ export declare const EMPTY_REPLAY_DOCUMENT: ReplayDocument;
 /** Implements clone empty replay document for the public runtime surface of this module. */
 export declare function cloneEmptyReplayDocument(): ReplayDocument;
 /** Implements replay hash for the public runtime surface of this module. */
-export declare function replayHash(document: ReplayDocument): string;
+export declare function replayHash(document: ReplayDocument, version?: HistoryItemHashVersion): 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. */
@@ -41,6 +42,13 @@ export type ReplayApplyResult = {
 /** Strictly apply a history patch (front_matter->metadata normalized) to a replay document. Returns a result envelope rather than throwing so each caller can format its own error contract. */
 export declare function tryApplyReplayPatch(current: ReplayDocument, patch: HistoryPatchOp[]): ReplayApplyResult;
 /** Deterministically verify a history chain: each entry's before_hash must equal the prior replayed after_hash, the patch must strictly apply, and the recorded after_hash must equal the replayed result. */
+/** Verify a chain and report the explicit or auto-detected item hash epoch. */
+export declare function verifyHistoryChainWithVersion(entries: HistoryEntry[]): {
+    ok: boolean;
+    errors: string[];
+    item_hash_version?: HistoryItemHashVersion;
+};
+/** Deterministically verify a history chain while preserving the legacy result shape. */
 export declare function verifyHistoryChain(entries: HistoryEntry[]): {
     ok: boolean;
     errors: 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]="c8668470-7e57-5dee-8e41-298e7c697b77")}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]="a1283470-00c7-5e91-8676-e1c1a667537f")}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 { hashDocument } from "./history.js";
+import { CURRENT_HISTORY_ITEM_HASH_VERSION, SUPPORTED_HISTORY_ITEM_HASH_VERSIONS, hashDocumentForVersion, } from "./history.js";
 /** Public contract for empty replay document, shared by SDK and presentation-layer consumers. */
 export const EMPTY_REPLAY_DOCUMENT = {
     metadata: {},
@@ -21,11 +21,11 @@ export function cloneEmptyReplayDocument() {
     return structuredClone(EMPTY_REPLAY_DOCUMENT);
 }
 /** Implements replay hash for the public runtime surface of this module. */
-export function replayHash(document) {
+export function replayHash(document, version = CURRENT_HISTORY_ITEM_HASH_VERSION) {
     if (Object.keys(document.metadata).length === 0 ||
         Array.isArray(document.metadata.tags)) {
         try {
-            return hashDocument(replayToItemDocument(document));
+            return hashDocumentForVersion(replayToItemDocument(document), version);
         }
         catch {
             // Fall through when another malformed legacy field cannot be canonicalized.
@@ -124,14 +124,20 @@ export function tryApplyReplayPatch(current, patch) {
     }
 }
 /** Deterministically verify a history chain: each entry's before_hash must equal the prior replayed after_hash, the patch must strictly apply, and the recorded after_hash must equal the replayed result. */
-export function verifyHistoryChain(entries) {
+/** Verify a chain and report the explicit or auto-detected item hash epoch. */
+export function verifyHistoryChainWithVersion(entries) {
     let replay = cloneEmptyReplayDocument();
+    let detectedVersion;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        if (replayHash(replay) !== entry.before_hash) {
+        const explicitVersion = entry.item_hash_version;
+        if (explicitVersion !== undefined &&
+            !SUPPORTED_HISTORY_ITEM_HASH_VERSIONS.includes(explicitVersion)) {
             return {
                 ok: false,
-                errors: [`verify_failed:before_hash_mismatch:entry_${index + 1}`],
+                errors: [
+                    `verify_failed:unsupported_item_hash_version:${String(explicitVersion)}:entry_${index + 1}`,
+                ],
             };
         }
         const applied = tryApplyReplayPatch(replay, entry.patch);
@@ -141,15 +147,38 @@ export function verifyHistoryChain(entries) {
                 errors: [`verify_failed:patch_apply_failed:entry_${index + 1}`],
             };
         }
-        replay = applied.document;
-        if (replayHash(replay) !== entry.after_hash) {
+        const candidates = explicitVersion === undefined
+            ? [CURRENT_HISTORY_ITEM_HASH_VERSION, 1]
+            : [explicitVersion];
+        const beforeMatches = candidates.filter((version) => replayHash(replay, version) === entry.before_hash);
+        if (beforeMatches.length === 0) {
+            return {
+                ok: false,
+                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: [`verify_failed:after_hash_mismatch:entry_${index + 1}`],
             };
         }
+        replay = applied.document;
+        detectedVersion = version;
     }
-    return { ok: true, errors: [] };
+    return {
+        ok: true,
+        errors: [],
+        ...(detectedVersion === undefined
+            ? {}
+            : { item_hash_version: detectedVersion }),
+    };
+}
+/** Deterministically verify a history chain while preserving the legacy result shape. */
+export function verifyHistoryChain(entries) {
+    const result = verifyHistoryChainWithVersion(entries);
+    return { ok: result.ok, errors: result.errors };
 }
 function tryApplySingleOp(document, op) {
     try {
@@ -192,6 +221,11 @@ export function lenientApplyReplayPatch(current, patch) {
 }
 /** 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) {
+    const unsupportedIndex = entries.findIndex((entry) => entry.item_hash_version !== undefined &&
+        !SUPPORTED_HISTORY_ITEM_HASH_VERSIONS.includes(entry.item_hash_version));
+    if (unsupportedIndex >= 0) {
+        throw new TypeError(`unsupported_item_hash_version:${String(entries[unsupportedIndex]?.item_hash_version)}:entry_${unsupportedIndex + 1}`);
+    }
     let replay = cloneEmptyReplayDocument();
     const rewritten = [];
     const details = [];
@@ -201,7 +235,7 @@ export function reanchorHistoryEntries(entries) {
     let skippedOps = 0;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        const beforeHash = replayHash(replay);
+        const beforeHash = replayHash(replay, CURRENT_HISTORY_ITEM_HASH_VERSION);
         const strict = tryApplyReplayPatch(replay, entry.patch);
         let next;
         let outPatch;
@@ -223,7 +257,7 @@ export function reanchorHistoryEntries(entries) {
             skippedOps += entrySkipped;
             entriesPatchRepaired += 1;
         }
-        const afterHash = replayHash(next);
+        const afterHash = replayHash(next, CURRENT_HISTORY_ITEM_HASH_VERSION);
         const rehashed = beforeHash !== entry.before_hash || afterHash !== entry.after_hash;
         if (rehashed) {
             entriesRehashed += 1;
@@ -233,6 +267,7 @@ export function reanchorHistoryEntries(entries) {
             patch: outPatch,
             before_hash: beforeHash,
             after_hash: afterHash,
+            item_hash_version: CURRENT_HISTORY_ITEM_HASH_VERSION,
         });
         details.push({
             index: index + 1,
@@ -261,4 +296,4 @@ export function historyEntriesToRaw(entries) {
     return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
 }
 //# sourceMappingURL=replay.js.map
-//# debugId=c8668470-7e57-5dee-8e41-298e7c697b77
+//# debugId=a1283470-00c7-5e91-8676-e1c1a667537f

package/dist/core/output/output.d.ts

@@ -24,6 +24,8 @@ export interface OutputOptions {
     outputFormat?: "toon" | "json";
     /** Caller-carried cross-call budget and served-item state. */
     outputSession?: string;
+    /** Include machine-readable row location and row-encoding metadata. */
+    outputRowContract?: boolean;
     /** Fallback output format used when callers do not provide an override. */
     defaultOutputFormat?: "toon" | "json";
     /** Value that configures or reports command for this contract. */

package/dist/core/output/output.js

@@ -4,7 +4,7 @@
  * 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]="b52d2756-f640-5f53-981f-05fa23fa1718")}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]="5aaf8b90-5b95-5102-9ea4-b877c696d593")}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";
@@ -12,6 +12,7 @@ import { projectMutationResult } from "./mutation-projection.js";
 import { attachReadOutputContracts } from "../../sdk/context-intent-contracts.js";
 import { attachOutputTokenAccounting } from "../../sdk/output-token-accounting.js";
 import { 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));
 const NATIVE_OUTPUT_MARKER = "__pm_native_output";
 let streamErrorHandlersInstalled = false;
@@ -114,6 +115,44 @@ function renderScalar(value) {
         return "null";
     return JSON.stringify(value);
 }
+function isToonPrimitive(value) {
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+function tabularObjectArray(value) {
+    if (value.length === 0 || !value.every(isPlainObject))
+        return false;
+    const keys = Object.keys(value[0]);
+    return (keys.length > 0 &&
+        value.every((entry) => Object.keys(entry).length === keys.length &&
+            keys.every((key) => Object.hasOwn(entry, key) && isToonPrimitive(entry[key]))));
+}
+function indentToon(encoded, depth) {
+    const indent = "  ".repeat(depth);
+    return encoded
+        .split("\n")
+        .map((line) => `${indent}${line}`)
+        .join("\n");
+}
+/** Render one object field while preserving nested and tabular TOON structure. */
+function renderToonObjectEntry(key, entry, depth) {
+    const indent = "  ".repeat(depth);
+    if (!isPlainObject(entry) && !Array.isArray(entry)) {
+        return `${indent}${key}: ${renderScalar(entry)}`;
+    }
+    if (Array.isArray(entry) && entry.length === 0) {
+        return `${indent}${key}: []`;
+    }
+    if (Array.isArray(entry) && tabularObjectArray(entry)) {
+        return indentToon(encodeToon({ [key]: entry }), depth);
+    }
+    if (isPlainObject(entry) && Object.keys(entry).length === 0) {
+        return `${indent}${key}: {}`;
+    }
+    return `${indent}${key}:\n${renderToonValue(entry, depth + 1)}`;
+}
 function compactToonValue(value) {
     if (value === null || value === undefined) {
         return undefined;
@@ -147,6 +186,9 @@ function renderToonValue(value, depth) {
     if (Array.isArray(value)) {
         if (value.length === 0)
             return "[]";
+        if (tabularObjectArray(value)) {
+            return indentToon(encodeToon(value), depth);
+        }
         return value
             .map((entry) => {
             if (!isPlainObject(entry) && !Array.isArray(entry)) {
@@ -167,18 +209,7 @@ function renderToonValue(value, depth) {
         if (entries.length === 0)
             return "{}";
         return entries
-            .map(([key, entry]) => {
-            if (!isPlainObject(entry) && !Array.isArray(entry)) {
-                return `${indent}${key}: ${renderScalar(entry)}`;
-            }
-            if (Array.isArray(entry) && entry.length === 0) {
-                return `${indent}${key}: []`;
-            }
-            if (isPlainObject(entry) && Object.keys(entry).length === 0) {
-                return `${indent}${key}: {}`;
-            }
-            return `${indent}${key}:\n${renderToonValue(entry, depth + 1)}`;
-        })
+            .map(([key, entry]) => renderToonObjectEntry(key, entry, depth))
             .join("\n");
     }
     return `${indent}${renderScalar(value)}`;
@@ -335,6 +366,7 @@ function formatEffectiveOutput(effectiveResult, nativeOutput, options) {
             ["outputBudget", options.outputBudget],
             ["outputFormat", options.outputFormat],
             ["outputSession", options.outputSession],
+            ["outputRowContract", options.outputRowContract],
         ].filter((entry) => entry[1] !== undefined)),
     };
     const format = resolveReadOutputEncoding(command ?? "", commandOptions) ??
@@ -424,4 +456,4 @@ export const outputTestOnly = {
     renderToonValue,
 };
 //# sourceMappingURL=output.js.map
-//# debugId=b52d2756-f640-5f53-981f-05fa23fa1718
+//# debugId=5aaf8b90-5b95-5102-9ea4-b877c696d593

package/dist/core/session/session-state.d.ts

@@ -9,11 +9,58 @@
 export interface SessionState {
     /** Value that configures or reports focused item for this contract. */
     focused_item?: string;
+    /** Privacy-safe semantic work context partitioned by agent invocation. */
+    semantic_attribution?: Record<string, AgentSemanticAttribution>;
+}
+/** Bounded inferred work context consumed by mutation provenance. */
+export interface AgentSemanticAttribution {
+    /** Controlled role inferred from the current work lifecycle. */
+    role: "implementer" | "planner" | "release-operator";
+    /** Stable item or workset identity, never prompt text. */
+    topic: string;
+    /** Confidence attached to the inferred observation. */
+    confidence: "high" | "medium";
+    /** Versioned inference rule understood by history consumers. */
+    rule_version: "v2";
+    /** Bounded item and lineage references supporting the inference. */
+    evidence: string[];
+    /** Claimed items currently contributing to the workset. */
+    active_item_ids: string[];
+    /** Explicitly focused item when focus takes precedence over claims. */
+    focused_item_id?: string;
 }
 /** Implements get session state path for the public runtime surface of this module. */
 export declare function getSessionStatePath(pmRoot: string): string;
 /** Implements read session state for the public runtime surface of this module. */
 export declare function readSessionState(pmRoot: string): Promise<SessionState>;
+/** Derive a non-secret state key from a claim principal. */
+export declare function semanticAttributionKey(principal: string): string;
+/** Record a successful claim as incremental semantic session evidence. */
+export declare function recordClaimedWorkAttribution(params: {
+    pmRoot: string;
+    principal: string;
+    itemId: string;
+    lineageIds?: readonly string[];
+}): Promise<void>;
+/** Remove a released item from incremental semantic session evidence. */
+export declare function releaseClaimedWorkAttribution(params: {
+    pmRoot: string;
+    principal: string;
+    itemId: string;
+}): Promise<void>;
+/** Set or clear focus as the highest-confidence semantic topic. */
+export declare function recordFocusedWorkAttribution(params: {
+    pmRoot: string;
+    principal: string;
+    itemId?: string;
+    lineageIds?: readonly string[];
+}): Promise<void>;
+/** Read one privacy-bounded inferred attribution without making mutations fail. */
+export declare function readAgentSemanticAttributionSync(params: {
+    cwd: string;
+    env: Readonly<Record<string, string | undefined>>;
+    key: string | undefined;
+}): AgentSemanticAttribution | undefined;
 /** Implements get focused item for the public runtime surface of this module. */
 export declare function getFocusedItem(pmRoot: string): Promise<string | undefined>;
 /** Implements set focused item for the public runtime surface of this module. */