@unbrained/pm-cli 2026.10.13 → 2026.10.15

package/dist/sdk/merge/receipts.d.ts

@@ -1,211 +1,211 @@
 import type { Stats } from "node:fs";
-import { type ItemMergeConflictDecision, type ItemScalarConflictResolution, type MergePreferredSide } from "./three-way.js";
+import { type ItemMergeConflictDecision,type ItemScalarConflictResolution,type MergePreferredSide } from "./three-way.js";
 import type { MergeReceiptOperation } from "./receipt-operation.js";
 import { DURABLE_VALUE_POLICY } from "./receipt-schema.js";
 export { isSafeReceiptId } from "./receipt-schema.js";
 /** One clone-local merge receipt with recoverable branch values. */
 export interface MergeDecisionReceipt {
 /** Receipt schema version. */
-version: 1;
+version:1;
 /** Opaque receipt identity referenced from public history. */
-id: string;
+id:string;
 /** Repository-relative item path supplied by Git as `%P`. */
-item_path: string;
+item_path:string;
 /** Item id derived from the merged document path. */
-item_id: string;
+item_id:string;
 /** Side requested by the caller; stable-value decisions can retain either side. */
-requested_preference?: MergePreferredSide;
+requested_preference?:MergePreferredSide;
 /** Whether requested preference participates in item scalar selection. */
-requested_preference_applied?: boolean;
+requested_preference_applied?:boolean;
 /** Legacy schema-v1 key accepted while reading older clone-local receipts. */
-preferred?: MergePreferredSide;
+preferred?:MergePreferredSide;
 /** Scalar-conflict selection contract used by the item driver. */
-conflict_resolution: ItemScalarConflictResolution;
+conflict_resolution:ItemScalarConflictResolution;
 /** Fields selected cleanly from the other branch. */
-fields_from_theirs: string[];
+fields_from_theirs:string[];
 /** Collections combined from both branches. */
-union_fields: string[];
+union_fields:string[];
 /** SHA-256 hashes of the merged values for every field represented by this receipt. Absent on legacy receipts, which cannot prove drift attribution. */
-merged_field_hashes?: Record<string, string>;
+merged_field_hashes?:Record<string,string>;
 /** Full recoverable scalar decisions, retained only in the clone. */
-decisions: ItemMergeConflictDecision[];
+decisions:ItemMergeConflictDecision[];
 /** Immutable original Git coordinates captured while the driver runs during a merge or rebase. */
-operation?: MergeReceiptOperation;
+operation?:MergeReceiptOperation;
 /** Explicit audited disposition when the original Git state was restored instead of merging. */
-settlement?: "original_git_state_restored";
+settlement?:"original_git_state_restored";
 /** Whether a reconciliation history event settled this receipt. */
-state: "pending" | "reconciled";
+state:"pending" | "reconciled";
 /** Receipt creation timestamp. */
-created_at: string;
+created_at:string;
 /** Reconciliation timestamp, when consumed. */
-reconciled_at?: string;
+reconciled_at?:string;
 /** Whether decision values are recoverable locally or represented by hashes only. */
-value_availability?: "clone_local" | "hash_only" | "bounded_inline" | "mixed";
+value_availability?:"clone_local" | "hash_only" | "bounded_inline" | "mixed";
 /** Versioned rule governing which durable scalar previews may be committed. */
-value_policy?: typeof DURABLE_VALUE_POLICY;
+value_policy?:typeof DURABLE_VALUE_POLICY;
 /** Runtime-only provenance assigned by the reader; serialized values are ignored. */
-evidence_source?: "clone_local" | "durable";
+evidence_source?:"clone_local" | "durable";
 }
 /** Privacy-safe receipt summary suitable for committed history context. */
 export interface MergeDecisionReceiptSummary {
 /** Opaque clone-local receipt identity. */
-receipt_id: string;
+receipt_id:string;
 /** Item whose merge produced the receipt. */
-item_id: string;
+item_id:string;
 /** Repository-relative item path. */
-item_path: string;
+item_path:string;
 /** Scalar fields that required a preferred-side decision. */
-conflict_fields: string[];
+conflict_fields:string[];
 /** Fields selected cleanly from the other branch. */
-fields_from_theirs: string[];
+fields_from_theirs:string[];
 /** Collections combined from both branches. */
-union_fields: string[];
+union_fields:string[];
 /** Side requested by the caller; decision hashes prove the actual retained values. */
-requested_preference: MergePreferredSide;
+requested_preference:MergePreferredSide;
 /** Whether requested preference participated in item scalar selection. */
-requested_preference_applied: boolean;
+requested_preference_applied:boolean;
 /** Scalar-conflict selection contract used by the item driver. */
-conflict_resolution: ItemScalarConflictResolution;
+conflict_resolution:ItemScalarConflictResolution;
 /** Hashes proving the retained and discarded values without publishing them. */
-decisions: Array<{
-field: string;
-retained_hash: string;
-discarded_hash: string;
+decisions:Array<{
+field:string;
+retained_hash:string;
+discarded_hash:string;
 }>;
 }
 /** Structured result for the explicit clone-local merge report command. */
 export interface MergeReceiptReport {
 /** Whether the report was read successfully. */
-ok: true;
+ok:true;
 /** Number of receipts returned. */
-count: number;
+count:number;
 /** Receipts including recoverable values from the local clone only. */
-receipts: MergeDecisionReceipt[];
+receipts:MergeDecisionReceipt[];
 /** ISO timestamp for the report. */
-generated_at: string;
+generated_at:string;
 }
 /** Loss-aware merge receipt report for integrity gates and diagnostic adapters. */
 export interface MergeReceiptEvidenceReport {
 /** Whether clone-local evidence resolved and every candidate was read and validated successfully. */
-ok: boolean;
+ok:boolean;
 /** Whether clone-local evidence resolved and every discovered JSON candidate was read and validated successfully. */
-complete: boolean;
+complete:boolean;
 /** Number of valid receipts returned. */
-count: number;
+count:number;
 /** Number of candidates rejected by bounded-file, schema, identity, or copy-consistency validation. */
-invalid_evidence_count: number;
+invalid_evidence_count:number;
 /** Bounded privacy-safe identities and reason codes for rejected evidence. */
-invalid_evidence: MergeReceiptInvalidEvidence[];
+invalid_evidence:MergeReceiptInvalidEvidence[];
 /** Whether additional rejected evidence was omitted from the bounded detail list. */
-invalid_evidence_truncated: boolean;
+invalid_evidence_truncated:boolean;
 /** Whether the clone-local Git receipt directory was resolved successfully; always emitted by current implementations and optional for structural compatibility. */
-clone_local_evidence_resolved?: boolean;
+clone_local_evidence_resolved?:boolean;
 /** Receipts including recoverable values from the local clone only. */
-receipts: MergeDecisionReceipt[];
+receipts:MergeDecisionReceipt[];
 /** ISO timestamp for the report. */
-generated_at: string;
+generated_at:string;
 }
 /** Loss-aware receipt inspection result that never exposes malformed file contents. */
 export interface MergeReceiptEvidenceScan {
 /** Valid receipts that passed bounded-file, schema, and identity validation. */
-receipts: MergeDecisionReceipt[];
+receipts:MergeDecisionReceipt[];
 /** Number of JSON receipt candidates that could not be validated safely. */
-invalid_evidence_count: number;
+invalid_evidence_count:number;
 /** Bounded privacy-safe identities and reason codes for rejected evidence. */
-invalid_evidence: MergeReceiptInvalidEvidence[];
+invalid_evidence:MergeReceiptInvalidEvidence[];
 /** Whether additional rejected evidence was omitted from the bounded detail list. */
-invalid_evidence_truncated: boolean;
+invalid_evidence_truncated:boolean;
 /** Whether the clone-local Git receipt directory was resolved successfully; always emitted by current implementations and optional for structural compatibility. */
-clone_local_evidence_resolved?: boolean;
+clone_local_evidence_resolved?:boolean;
 }
 /** Stable privacy-safe classification for one rejected receipt candidate or source. */
 export interface MergeReceiptInvalidEvidence {
 /** Evidence store that produced the rejected candidate. */
-evidence_source: "clone_local" | "durable" | "clone_local_and_durable";
+evidence_source:"clone_local" | "durable" | "clone_local_and_durable";
 /** Stable failure class suitable for remediation routing and graph analytics. */
-reason: "directory_unreadable" | "candidate_not_bounded_regular_file" | "candidate_unreadable" | "candidate_invalid_json" | "schema_or_identity_invalid" | "schema_invalid" | "identity_invalid" | "copy_provenance_mismatch";
+reason:"directory_unreadable" | "candidate_not_bounded_regular_file" | "candidate_unreadable" | "candidate_invalid_json" | "schema_or_identity_invalid" | "schema_invalid" | "identity_invalid" | "copy_provenance_mismatch";
 /** Exact validation boundary when schema or identity evidence is rejected. */
-validation_error?: "required_fields" | "receipt_id" | "item_id" | "item_path" | "filename" | "collections" | "enums" | "timestamps" | "durable_decisions" | "operation";
+validation_error?:"required_fields" | "receipt_id" | "item_id" | "item_path" | "filename" | "collections" | "enums" | "timestamps" | "durable_decisions" | "operation";
 /** Exact schema coordinate, excluding rejected values and user-controlled field names. */
-validation_path?: string;
+validation_path?:string;
 /** Receipt identity when the bounded filename itself is a valid receipt id. */
-receipt_id?: string;
+receipt_id?:string;
 /** SHA-256 locator for an unsafe or malformed candidate filename. */
-candidate_name_hash?: string;
+candidate_name_hash?:string;
 }
 /** Revalidate one receipt and stage its atomic reconciled-state replacement. */
-declare function prepareReceiptSettlement(params: {
-receiptPath: string;
-receiptId: string;
-evidenceSource: "clone_local" | "durable";
-reconciledAt: string;
-settlement?: "original_git_state_restored";
-readReceipt?: (receiptPath: string) => Promise<string | null>;
-}): Promise<{
-path: string;
-content: string;
-fingerprints: string[];
-modern: boolean;
+declare function prepareReceiptSettlement(params:{
+receiptPath:string;
+receiptId:string;
+evidenceSource:"clone_local" | "durable";
+reconciledAt:string;
+settlement?:"original_git_state_restored";
+readReceipt?:(receiptPath:string) => Promise<string | null>;
+}):Promise<{
+path:string;
+content:string;
+fingerprints:string[];
+modern:boolean;
 } | null>;
 /** Convert a raw receipt into privacy-safe history context. */
-export declare function summarizeMergeReceipt(receipt: MergeDecisionReceipt): MergeDecisionReceiptSummary;
+export declare function summarizeMergeReceipt(receipt:MergeDecisionReceipt):MergeDecisionReceiptSummary;
 /** Persist one item-driver outcome in the clone-local Git directory. */
-export declare function writeMergeReceipt(params: {
-cwd: string;
-itemPath: string;
-preferred: MergePreferredSide;
-conflictResolution?: ItemScalarConflictResolution;
-fieldsFromTheirs: string[];
-unionFields: string[];
-mergedFieldHashes?: Record<string, string>;
-decisions: ItemMergeConflictDecision[];
-operation?: MergeReceiptOperation;
-}): Promise<MergeDecisionReceipt | null>;
+export declare function writeMergeReceipt(params:{
+cwd:string;
+itemPath:string;
+preferred:MergePreferredSide;
+conflictResolution?:ItemScalarConflictResolution;
+fieldsFromTheirs:string[];
+unionFields:string[];
+mergedFieldHashes?:Record<string,string>;
+decisions:ItemMergeConflictDecision[];
+operation?:MergeReceiptOperation;
+}):Promise<MergeDecisionReceipt | null>;
 /** Distinguish a missing optional receipt store from an unreadable one. */
-declare function receiptDirectoryFailureMeansAbsent(directory: string, error: unknown, inspectAncestor?: (ancestor: string) => Promise<Pick<Stats, "isDirectory">>): Promise<boolean>;
+declare function receiptDirectoryFailureMeansAbsent(directory:string,error:unknown,inspectAncestor?:(ancestor:string) => Promise<Pick<Stats,"isDirectory">>):Promise<boolean>;
 /** Inspect valid receipts and count invalid evidence without returning untrusted file contents. */
-export declare function inspectMergeReceiptEvidence(cwd: string, options?: {
+export declare function inspectMergeReceiptEvidence(cwd:string,options?:{
 /** Include receipts whose reconciliation state is already settled. */
-includeReconciled?: boolean;
+includeReconciled?:boolean;
 /** Include receipts that contain no discarded scalar values. */
-includeLossless?: boolean;
+includeLossless?:boolean;
 /** Explicit tracker root used to locate durable receipt evidence. */
-pmRoot?: string;
-}): Promise<MergeReceiptEvidenceScan>;
+pmRoot?:string;
+}):Promise<MergeReceiptEvidenceScan>;
 /** Read clone-local receipts with explicit reconciled/lossless classification controls. */
-export declare function listMergeReceipts(cwd: string, options?: {
-includeReconciled?: boolean;
-includeLossless?: boolean;
-pmRoot?: string;
-}): Promise<MergeDecisionReceipt[]>;
+export declare function listMergeReceipts(cwd:string,options?:{
+includeReconciled?:boolean;
+includeLossless?:boolean;
+pmRoot?:string;
+}):Promise<MergeDecisionReceipt[]>;
 /** Split merge provenance into receipts with discarded values and receipts whose composition was lossless. */
-export declare function partitionMergeReceipts(receipts: MergeDecisionReceipt[]): {
+export declare function partitionMergeReceipts(receipts:MergeDecisionReceipt[]):{
 /** Receipts that require an explicit decision because at least one competing scalar value was discarded. */
-pendingDecisions: MergeDecisionReceipt[];
+pendingDecisions:MergeDecisionReceipt[];
 /** Receipts that record provenance without a discarded competing scalar value. */
-lossless: MergeDecisionReceipt[];
+lossless:MergeDecisionReceipt[];
 };
 /** Mark a receipt as represented by a committed merge history event. */
-export declare function markMergeReceiptReconciled(cwd: string, receipt: MergeDecisionReceipt, options?: {
-requireExisting?: boolean;
-settlement?: "original_git_state_restored";
-}): Promise<void>;
+export declare function markMergeReceiptReconciled(cwd:string,receipt:MergeDecisionReceipt,options?:{
+requireExisting?:boolean;
+settlement?:"original_git_state_restored";
+}):Promise<void>;
 /** Report pending or historical clone-local merge decisions. */
-export declare function runMergeReceiptReport(options: {
+export declare function runMergeReceiptReport(options:{
 /** Include receipts already represented by merge history events. */
-includeReconciled?: boolean;
+includeReconciled?:boolean;
 /** Repository directory to inspect; defaults to the process working directory. */
-cwd?: string;
-}): Promise<MergeReceiptReport>;
+cwd?:string;
+}):Promise<MergeReceiptReport>;
 /** Inspect every receipt candidate and retain completeness diagnostics without exposing rejected file contents. */
-export declare function runMergeReceiptEvidenceReport(options: {
+export declare function runMergeReceiptEvidenceReport(options:{
 /** Include receipts already represented by merge history events. */
-includeReconciled?: boolean;
+includeReconciled?:boolean;
 /** Repository directory to inspect; defaults to the process working directory. */
-cwd?: string;
-}): Promise<MergeReceiptEvidenceReport>;
+cwd?:string;
+}):Promise<MergeReceiptEvidenceReport>;
 /** Test-only seams for deterministic receipt-boundary fault coverage. */
-export declare const _testOnlyMergeReceipts: {
-prepareReceiptSettlement: typeof prepareReceiptSettlement;
-receiptDirectoryFailureMeansAbsent: typeof receiptDirectoryFailureMeansAbsent;
+export declare const _testOnlyMergeReceipts:{
+prepareReceiptSettlement:typeof prepareReceiptSettlement;
+receiptDirectoryFailureMeansAbsent:typeof receiptDirectoryFailureMeansAbsent;
 };

package/dist/sdk/merge/reconcile.d.ts

@@ -5,13 +5,13 @@ import { type MergeDecisionReceiptSummary } from "./receipts.js";
 /** Options for the audited post-merge reconciliation workflow. */
 export interface MergeReconcileOptions {
 /** Preview drifted streams without mutating history. */
-dryRun?: boolean;
+dryRun?:boolean;
 /** Attribution recorded on repair audit entries. */
-author?: string;
+author?:string;
 /** Human-readable reason recorded on repair audit entries. */
-message?: string;
+message?:string;
 /** Permit ownership overrides already supported by history repair. */
-force?: boolean;
+force?:boolean;
 }
 /** Structured post-merge reconciliation and verification result. */
 export interface MergeReconcileResult {
@@ -20,33 +20,33 @@ export interface MergeReconcileResult {
      * merge-critical validation. Dry-run previews therefore fail closed while
      * drift or pending merge decisions still require an apply pass.
      */
-ok: boolean;
+ok:boolean;
 /** Whether this invocation only previewed repairs. */
-dry_run: boolean;
+dry_run:boolean;
 /** Bulk history repair preview or apply result. */
-repair: HistoryRepairAllResult;
+repair:HistoryRepairAllResult;
 /** Clone-local merge receipts represented by merge history events. */
-receipts: {
-pending_before: number;
-reconciled: number;
+receipts:{
+pending_before:number;
+reconciled:number;
 /** Receipts proven to restore their original Git state; these do not represent applied merges. */
-abandoned: number;
-summaries: MergeDecisionReceiptSummary[];
+abandoned:number;
+summaries:MergeDecisionReceiptSummary[];
 /** Missing durable references discovered before this reconciliation. */
-missing_history_references_before: number;
+missing_history_references_before:number;
 /** Pre-durable references eligible for explicit audited disposition. */
-legacy_disposition_eligible: number;
+legacy_disposition_eligible:number;
 /** Eligible references dispositioned by this apply pass. */
-legacy_disposition_recorded: number;
+legacy_disposition_recorded:number;
 /** Missing durable references still blocking health after this pass. */
-missing_history_references_after: number;
+missing_history_references_after:number;
 };
 /** Post-operation history-drift and storage-integrity validation. */
-validation: ValidateResult;
+validation:ValidateResult;
 /** Stable next-step guidance for Git hooks and interactive agents. */
-guidance: string[];
+guidance:string[];
 /** ISO timestamp copied from the validation pass. */
-generated_at: string;
+generated_at:string;
 }
 /**
  * Preview or apply post-merge history reconciliation and immediately validate
@@ -54,4 +54,4 @@ generated_at: string;
  * callers opt into this command after Git finishes; installing merge drivers
  * does not silently install or mutate repository hooks.
  */
-export declare function runMergeReconcile(options: MergeReconcileOptions, global: GlobalOptions): Promise<MergeReconcileResult>;
+export declare function runMergeReconcile(options:MergeReconcileOptions,global:GlobalOptions):Promise<MergeReconcileResult>;

package/dist/sdk/merge/three-way.d.ts

@@ -6,33 +6,33 @@ export type ItemScalarConflictResolution = "preferred_side" | "stable_value_orde
 /** Explains the exact evidence used to select one conflicting item scalar. */
 export type ItemScalarResolutionBasis = "requested_preference" | "document_updated_at" | "stable_value_tiebreak";
 /** JSON-stable marker used when a conflict decision refers to an absent scalar. */
-export declare const ITEM_SCALAR_MISSING_VALUE: Readonly<{
-readonly pm_item_scalar_missing: true;
+export declare const ITEM_SCALAR_MISSING_VALUE:Readonly<{
+readonly pm_item_scalar_missing:true;
 }>;
 /** Return whether receipt evidence represents an absent item scalar. */
-export declare function isItemScalarMissingValue(value: unknown): value is typeof ITEM_SCALAR_MISSING_VALUE;
+export declare function isItemScalarMissingValue(value:unknown):value is typeof ITEM_SCALAR_MISSING_VALUE;
 /** Encode an absent scalar so every decision property survives JSON serialization. */
-export declare function encodeItemScalarDecisionValue(value: unknown): unknown;
+export declare function encodeItemScalarDecisionValue(value:unknown):unknown;
 /** Hash scalars in disjoint present/missing domains for collision-free evidence. */
-export declare function hashItemScalarDecisionValue(value: unknown): string;
+export declare function hashItemScalarDecisionValue(value:unknown):string;
 /** Restricts the strategy labels reported by the history stream merge. */
 export type HistoryMergeStrategy = "identical" | "fast_forward_ours" | "fast_forward_theirs" | "union_reanchor";
 /** Documents the history stream merge result payload exchanged by command, SDK, and package integrations. */
 export interface HistoryMergeResult {
 /** Merged JSONL content ready to be written as the resolved history stream. */
-merged: string;
+merged:string;
 /** Strategy the merge used: identical inputs, one-sided fast-forward, or a deterministic union with a re-anchored hash chain. */
-strategy: HistoryMergeStrategy;
+strategy:HistoryMergeStrategy;
 /** Number of entries shared by both sides before their streams diverged. */
-common_entries: number;
+common_entries:number;
 /** Number of divergent entries contributed by the ours side. */
-entries_from_ours: number;
+entries_from_ours:number;
 /** Number of divergent entries contributed by the theirs side. */
-entries_from_theirs: number;
+entries_from_theirs:number;
 /** Total entries in the merged stream. */
-entries_total: number;
+entries_total:number;
 /** Whether the merged chain required hash re-anchoring (true for every union merge). */
-reanchored: boolean;
+reanchored:boolean;
 }
 /**
  * Deterministically merge two diverged versions of one append-only history
@@ -47,23 +47,23 @@ reanchored: boolean;
  * deterministic ordering, the merge fails closed instead of publishing a
  * hash-valid stream that omitted a branch effect.
  */
-export declare function mergeHistoryStreams(baseRaw: string, oursRaw: string, theirsRaw: string): HistoryMergeResult;
+export declare function mergeHistoryStreams(baseRaw:string,oursRaw:string,theirsRaw:string):HistoryMergeResult;
 /** Documents the relationship event stream merge result payload exchanged by command, SDK, and package integrations. */
 export interface RelationshipStreamMergeResult {
 /** Merged JSONL content with consecutively renumbered `sequence` values, ready to be written as the resolved event store. */
-merged: string;
+merged:string;
 /** Strategy the merge used: identical inputs, one-sided fast-forward, or a deterministic union with renumbered sequences. */
-strategy: HistoryMergeStrategy;
+strategy:HistoryMergeStrategy;
 /** Number of events shared by both sides before their streams diverged. */
-common_entries: number;
+common_entries:number;
 /** Number of divergent events contributed by the ours side. */
-entries_from_ours: number;
+entries_from_ours:number;
 /** Number of divergent events contributed by the theirs side. */
-entries_from_theirs: number;
+entries_from_theirs:number;
 /** Total events in the merged stream. */
-entries_total: number;
+entries_total:number;
 /** Whether merged events required sequence renumbering (true for every union merge). */
-reanchored: boolean;
+reanchored:boolean;
 }
 /**
  * Deterministically merge two diverged versions of one append-only
@@ -74,7 +74,7 @@ reanchored: boolean;
  * ours-first on ties), and renumbers every merged sequence consecutively so
  * the resulting stream loads again. No side's events are ever discarded.
  */
-export declare function mergeRelationshipEventStreams(baseRaw: string, oursRaw: string, theirsRaw: string): RelationshipStreamMergeResult;
+export declare function mergeRelationshipEventStreams(baseRaw:string,oursRaw:string,theirsRaw:string):RelationshipStreamMergeResult;
 /**
  * Item metadata collections merged by element-identity set semantics instead
  * of whole-field three-way comparison: concurrent commutative appends from two
@@ -85,46 +85,46 @@ export declare function mergeRelationshipEventStreams(baseRaw: string, oursRaw:
  * steps carry cross-element ordering invariants that set-union would corrupt,
  * so they stay under scalar three-way semantics with explicit conflicts.
  */
-export declare const ITEM_UNION_COLLECTION_FIELDS: readonly ["tags", "dependencies", "comments", "notes", "learnings", "files", "tests", "test_runs", "docs", "reminders", "events"];
+export declare const ITEM_UNION_COLLECTION_FIELDS:readonly ["tags","dependencies","comments","notes","learnings","files","tests","test_runs","docs","reminders","events"];
 /** Item metadata fields resolved by deterministic latest-timestamp-wins instead of three-way conflict, so disjoint-field edits never conflict on the shared freshness scalar every mutation rewrites. */
-export declare const ITEM_LATEST_TIMESTAMP_FIELDS: readonly ["updated_at"];
+export declare const ITEM_LATEST_TIMESTAMP_FIELDS:readonly ["updated_at"];
 /** Documents one recoverable scalar decision made during an item merge. */
 export interface ItemMergeConflictDecision {
 /** Metadata field name, or `body`. */
-field: string;
+field:string;
 /** Common-ancestor value. */
-base: unknown;
+base:unknown;
 /** Current-branch value. */
-ours: unknown;
+ours:unknown;
 /** Other-branch value. */
-theirs: unknown;
+theirs:unknown;
 /** Value retained in the merged item. */
-retained: unknown;
+retained:unknown;
 /** Value not retained in the merged item. */
-discarded: unknown;
+discarded:unknown;
 /** Branch coordinate whose value was retained. */
-retained_side?: MergePreferredSide;
+retained_side?:MergePreferredSide;
 /** Evidence class that selected the retained value. */
-resolution_basis?: ItemScalarResolutionBasis;
+resolution_basis?:ItemScalarResolutionBasis;
 }
 /** Documents the item document merge result payload exchanged by command, SDK, and package integrations. */
 export interface ItemDocumentMergeResult {
 /** Serialized merged item document (always parseable; count headers recomputed by canonical serialization). */
-merged: string;
+merged:string;
 /** Metadata fields (plus `body`) where both sides changed to different values; resolved toward the preferred side. */
-conflict_fields: string[];
+conflict_fields:string[];
 /** Fields taken from the theirs side by clean three-way resolution. */
-fields_from_theirs: string[];
+fields_from_theirs:string[];
 /** Collection fields that merged by element-identity union. */
-union_fields: string[];
+union_fields:string[];
 /** Scalar conflict decisions; callers choose a privacy-appropriate persistence boundary. */
-conflict_decisions: ItemMergeConflictDecision[];
+conflict_decisions:ItemMergeConflictDecision[];
 /** Side requested by the caller; stable-value decisions can retain either side. */
-requested_preference: MergePreferredSide;
+requested_preference:MergePreferredSide;
 /** Whether the requested side participates in item scalar selection under the declared policy. */
-requested_preference_applied: boolean;
+requested_preference_applied:boolean;
 /** Scalar-conflict selection contract used for this merge. */
-conflict_resolution: ItemScalarConflictResolution;
+conflict_resolution:ItemScalarConflictResolution;
 }
 /**
  * Field-aware three-way merge of one tracker item document. Commutative
@@ -138,22 +138,22 @@ conflict_resolution: ItemScalarConflictResolution;
  * recomputed, so the hand-resolution corruption class (stale `notes[N]`
  * headers) cannot be produced by this merge.
  */
-export declare function mergeItemDocuments(baseRaw: string, oursRaw: string, theirsRaw: string, options?: ItemDocumentFormatOptions & {
+export declare function mergeItemDocuments(baseRaw:string,oursRaw:string,theirsRaw:string,options?:ItemDocumentFormatOptions & {
 /** Side that wins unresolvable conflicts (default "ours"). */
-preferred?: MergePreferredSide;
+preferred?:MergePreferredSide;
 /** Direction-independent scalar selection used by the Git driver. */
-conflictResolution?: ItemScalarConflictResolution;
-}): ItemDocumentMergeResult;
+conflictResolution?:ItemScalarConflictResolution;
+}):ItemDocumentMergeResult;
 /** Documents the JSON document merge result payload exchanged by command, SDK, and package integrations. */
 export interface JsonDocumentMergeResult {
 /** Serialized merged JSON document (two-space indent, trailing newline — the tracker's canonical config style). */
-merged: string;
+merged:string;
 /** Dotted key paths where both sides changed to different values; resolved toward the preferred side. */
-conflict_paths: string[];
+conflict_paths:string[];
 /** Dotted key paths taken from the theirs side by clean three-way resolution. */
-paths_from_theirs: string[];
+paths_from_theirs:string[];
 /** Which side unresolvable conflicts were resolved toward. */
-preferred: MergePreferredSide;
+preferred:MergePreferredSide;
 }
 /**
  * Key-level three-way merge for the tracker's JSON configuration artifacts.
@@ -163,7 +163,7 @@ preferred: MergePreferredSide;
  * always valid JSON, so merged configuration cannot regress into the
  * silent-defaults fallback that raw conflict markers cause.
  */
-export declare function mergeJsonDocuments(baseRaw: string, oursRaw: string, theirsRaw: string, options?: {
+export declare function mergeJsonDocuments(baseRaw:string,oursRaw:string,theirsRaw:string,options?:{
 /** Side that wins unresolvable conflicts (default "ours"). */
-preferred?: MergePreferredSide;
-}): JsonDocumentMergeResult;
+preferred?:MergePreferredSide;
+}):JsonDocumentMergeResult;