@wowok/agent-mcp 3.4.3 → 3.4.4

package/dist/composition/emit-phases.d.ts

@@ -1,234 +0,0 @@
-import type { SupplyChainEmission, SupplyChainPromise } from "./supply-chain-emit.js";
-import type { DerivedParam, JsonValue, PlanStep, RuntimeWriteStep } from "./plan.js";
-import type { GuardFillReviewMode, ResolvedGuard } from "./guard-fill.js";
-import type { AllocatorRowData, CompilableTemplate, CompileBlocker, GuardSpec } from "./compile.js";
-export declare function normalizeCurrency(raw: string): string | undefined;
-export declare function emitIdentityPhase({ template, base }: {
-    template: CompilableTemplate;
-    base: string;
-}): {
-    steps: PlanStep[];
-    needsArbitration: boolean;
-};
-export declare function emitRewardClaimEarly({ reviewMode, guardSpecs, resolvedGuards, rewardMark, }: {
-    reviewMode: GuardFillReviewMode;
-    guardSpecs: GuardSpec[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    rewardMark: string;
-}): {
-    steps: PlanStep[];
-};
-export declare function emitExperiencePoolEarly({ experienceClaimKey, guardSpecs, resolvedGuards, poolMark, }: {
-    experienceClaimKey?: string;
-    guardSpecs: GuardSpec[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    poolMark: string;
-}): {
-    steps: PlanStep[];
-};
-export declare function checkDaysUnitSlots({ resolvedGuards, }: {
-    resolvedGuards: Map<string, ResolvedGuard>;
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function checkWindowTruncation({ resolvedGuards, }: {
-    resolvedGuards: Map<string, ResolvedGuard>;
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function emitServiceDraft({ template, base, inputs, }: {
-    template: CompilableTemplate;
-    base: string;
-    inputs: Record<string, JsonValue>;
-}): {
-    steps: PlanStep[];
-    currency: string;
-    blockers: CompileBlocker[];
-};
-export declare function emitEvidenceRepository({ needsRepository, base, inputs, guardSpecs, resolvedGuards, }: {
-    needsRepository: boolean;
-    base: string;
-    inputs: Record<string, JsonValue>;
-    guardSpecs: GuardSpec[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-}): {
-    steps: PlanStep[];
-    repoBoundPolicies: Record<string, unknown>[];
-    repoBoundStepIds: string[];
-    runtimeWrites: RuntimeWriteStep[];
-    blockers: CompileBlocker[];
-};
-export declare function emitReviewRepositoryEarly({ reviewMode, base, inputs, }: {
-    reviewMode: GuardFillReviewMode;
-    base: string;
-    inputs: Record<string, JsonValue>;
-}): {
-    steps: PlanStep[];
-    runtimeWrites: RuntimeWriteStep[];
-};
-export declare function rewritePlanRefs({ base, resolvedGuards, }: {
-    base: string;
-    resolvedGuards: Map<string, ResolvedGuard>;
-}): void;
-export declare function dropEmptyVecGuards({ resolvedGuards, guardSpecs, steps, }: {
-    resolvedGuards: Map<string, ResolvedGuard>;
-    guardSpecs: GuardSpec[];
-    steps: PlanStep[];
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function emitArbitrationHoist({ needsArbitration, template, base, currency, }: {
-    needsArbitration: boolean;
-    template: CompilableTemplate;
-    base: string;
-    currency: string;
-}): {
-    steps: PlanStep[];
-};
-export declare function emitGuardWave({ resolvedGuards, specByKey, slot254Injected, repoBoundPolicies, repoBoundStepIds, }: {
-    resolvedGuards: Map<string, ResolvedGuard>;
-    specByKey: Map<string, GuardSpec>;
-    slot254Injected: Set<string>;
-    repoBoundPolicies: Record<string, unknown>[];
-    repoBoundStepIds: string[];
-}): {
-    steps: PlanStep[];
-};
-export declare function emitMachine({ template, base, shape, resolvedGuards, specByKey, injectedOrderHolderKeys, merchantIndex, }: {
-    template: CompilableTemplate;
-    base: string;
-    shape: CompilableTemplate["machine_shape"];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    specByKey: Map<string, GuardSpec>;
-    injectedOrderHolderKeys: Map<string, string>;
-    merchantIndex: number;
-}): {
-    steps: PlanStep[];
-    blockers: CompileBlocker[];
-};
-export declare function emitServiceConfigure({ guardSpecs, needsRepository, }: {
-    guardSpecs: GuardSpec[];
-    needsRepository: boolean;
-}): {
-    steps: PlanStep[];
-};
-export declare function emitAllocators({ template, base, inputs, rowsWithAttachments, resolvedGuards, specByKey, }: {
-    template: CompilableTemplate;
-    base: string;
-    inputs: Record<string, JsonValue>;
-    rowsWithAttachments: AllocatorRowData[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    specByKey: Map<string, GuardSpec>;
-}): {
-    rows: AllocatorRowData[];
-    rowGroups: {
-        key?: string;
-        rows: AllocatorRowData[];
-    }[];
-    allocatorRows: Record<string, unknown>[];
-    externalMarks: Set<string>;
-    blockers: CompileBlocker[];
-};
-export declare function checkAllocatorRails({ rowGroups, resolvedGuards, shape, recoverTwinRails, declares, }: {
-    rowGroups: {
-        key?: string;
-        rows: AllocatorRowData[];
-    }[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    shape: CompilableTemplate["machine_shape"];
-    recoverTwinRails: ReadonlySet<string>;
-    declares: ReadonlyMap<string, string>;
-}): {
-    blockers: CompileBlocker[];
-    disclosures: string[];
-};
-export declare function emitServiceAllocators({ template, inputs, allocatorRows, }: {
-    template: CompilableTemplate;
-    inputs: Record<string, JsonValue>;
-    allocatorRows: Record<string, unknown>[];
-}): {
-    steps: PlanStep[];
-};
-export declare function checkEmittedStepShapes({ steps }: {
-    steps: PlanStep[];
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function checkFundRailReachability({ steps, resolvedGuards, }: {
-    steps: PlanStep[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function checkWindowTopology({ template }: {
-    template: CompilableTemplate;
-}): {
-    warnings: string[];
-};
-export declare function emitSales({ inputs }: {
-    inputs: Record<string, JsonValue>;
-}): {
-    steps: PlanStep[];
-    blockers: CompileBlocker[];
-};
-export declare function emitReviewComponent({ template, inputs, reviewMode, experienceClaimKey, shape, guardSpecs, resolvedGuards, specByKey, }: {
-    template: CompilableTemplate;
-    inputs: Record<string, JsonValue>;
-    reviewMode: GuardFillReviewMode;
-    experienceClaimKey?: string;
-    shape: CompilableTemplate["machine_shape"];
-    guardSpecs: GuardSpec[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    specByKey: Map<string, GuardSpec>;
-}): {
-    steps: PlanStep[];
-    fundingSteps: PlanStep[];
-    blockers: CompileBlocker[];
-};
-export declare function emitArbitrationBindings({ template, inputs, needsArbitration, shape, guardSpecs, specByKey, }: {
-    template: CompilableTemplate;
-    inputs: Record<string, JsonValue>;
-    needsArbitration: boolean;
-    shape: CompilableTemplate["machine_shape"];
-    guardSpecs: GuardSpec[];
-    specByKey: Map<string, GuardSpec>;
-}): {
-    steps: PlanStep[];
-    fundingSteps: PlanStep[];
-    blockers: CompileBlocker[];
-    disclosures: string[];
-};
-export declare function emitServicePublish(): {
-    steps: PlanStep[];
-};
-export declare function computeMoneyRailKeys({ rowsWithAttachments, guardSpecs, }: {
-    rowsWithAttachments: AllocatorRowData[];
-    guardSpecs: GuardSpec[];
-}): {
-    allocatorBoundKeys: Set<string>;
-    moneyRailKeys: Set<string>;
-};
-export declare function checkForeignServicePins({ resolvedGuards, edgeBoundKeys, moneyRailKeys, }: {
-    resolvedGuards: Map<string, ResolvedGuard>;
-    edgeBoundKeys: Set<string>;
-    moneyRailKeys: Set<string>;
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function auditRepoIntegrityAndCallerLegs({ steps, resolvedGuards, moneyRailKeys, recoverTwinRails, }: {
-    steps: PlanStep[];
-    resolvedGuards: Map<string, ResolvedGuard>;
-    moneyRailKeys: Set<string>;
-    recoverTwinRails: Set<string>;
-}): {
-    blockers: CompileBlocker[];
-};
-export declare function emitSupplyChain({ supplyChain, steps, derivedParams, }: {
-    supplyChain: SupplyChainPromise[] | undefined;
-    steps: PlanStep[];
-    derivedParams: DerivedParam[];
-}): {
-    supplyChainEmissions: SupplyChainEmission[];
-    fulfillmentAxis: string | undefined;
-    blockers: CompileBlocker[];
-};

package/dist/composition/generate.d.ts

@@ -1,40 +0,0 @@
-import { type CapabilityId, type CapabilityEvidenceReport } from "../extensions/capability.js";
-import type { SupplyChainEmission, SupplyChainPromise } from "./supply-chain-emit.js";
-import type { JsonValue, Plan } from "./plan.js";
-import type { PlanAuditResult } from "./audit.js";
-export interface CompositionGenerationInput {
-    intent: string;
-    selections?: CapabilityId[];
-    supplyChain?: SupplyChainPromise[];
-    inputs?: Record<string, JsonValue>;
-    nameBase?: string;
-    preferredChain?: string;
-    buildTimeMs?: number;
-}
-export interface GeneratedAdoption {
-    id: CapabilityId;
-    via: "selection" | "intent_signal";
-    evidence?: CapabilityEvidenceReport;
-}
-export interface GeneratedBlocker {
-    code: string;
-    detail: string;
-}
-export interface CompositionGeneration {
-    plan?: Plan;
-    feasibility: "ready" | "infeasible";
-    chain?: string;
-    carrier?: string;
-    adopted: GeneratedAdoption[];
-    blockers: GeneratedBlocker[];
-    audit?: PlanAuditResult;
-    templates_version: number;
-    supplyChain?: SupplyChainEmission[];
-}
-export interface PilotChainPreset {
-    chain: string;
-    carrier: string;
-    signals: CapabilityId[];
-}
-export declare const PILOT_CHAINS: PilotChainPreset[];
-export declare function generateCompositionPlan(input: CompositionGenerationInput): CompositionGeneration;

package/dist/composition/guard-fill.d.ts

@@ -1,52 +0,0 @@
-import type { JsonValue } from "./plan.js";
-import type { CompilableTemplate, CompileBlocker, GuardResolution, GuardSpec } from "./compile.js";
-import type { ConditionalSelection } from "./input-normalize.js";
-export declare function normalizeInlineGuardTable(table: unknown[], base: string): unknown[];
-export interface ResolvedGuard {
-    stepId: string;
-    description: string;
-    table: unknown[];
-    root: unknown;
-}
-export declare function normalizeGuardRowNames(table: unknown[], description: unknown, maxDescriptionContentBytes: number): {
-    table: unknown[];
-    description: unknown;
-};
-export type GuardFillReviewMode = NonNullable<CompilableTemplate["review_mode"]> | "none";
-export type GuardBindingCensus = Set<string>;
-export interface GuardMountCensus {
-    edgeKeys: ReadonlySet<string>;
-    railKeys: ReadonlySet<string>;
-    policyKeys: ReadonlySet<string>;
-    buyMounted: boolean;
-}
-export declare function guardMountCensus(template: CompilableTemplate, inputs: Record<string, JsonValue>, precomputed?: Pick<ConditionalSelection, "selectorDroppedKeys" | "shape" | "rows">): GuardMountCensus;
-export interface GuardFillInputs {
-    template: CompilableTemplate;
-    base: string;
-    inputs: Record<string, JsonValue>;
-    guardResolutions: Record<string, GuardResolution>;
-    selector: Omit<ConditionalSelection, "blockers">;
-}
-export interface GuardFillDerived {
-    reviewMode: GuardFillReviewMode;
-    rewardMark: string;
-    needsRepository: boolean;
-    experienceClaimKey?: string;
-}
-export interface GuardFillResult {
-    guardSpecs: GuardSpec[];
-    resolutions: Record<string, GuardResolution>;
-    resolvedGuards: Map<string, ResolvedGuard>;
-    unresolved: GuardSpec[];
-    omitKeys: Set<string>;
-    recoverTwinRails: Set<string>;
-    declareReasons: Map<string, string>;
-    specByKey: Map<string, GuardSpec>;
-    slot254Injected: Set<string>;
-    injectedOrderHolderKeys: Map<string, string>;
-    edgeBoundKeys: GuardBindingCensus;
-    derived: GuardFillDerived;
-    blockers: CompileBlocker[];
-}
-export declare function fillGuards(deps: GuardFillInputs): GuardFillResult;

package/dist/composition/inflight.d.ts

@@ -1,86 +0,0 @@
-export interface InFlightRecord {
-    marker_id: string;
-    op: string;
-    service?: string;
-    allocation?: string;
-    buyer?: string;
-    items_count?: number;
-    total_pay?: string;
-    item_names?: string[];
-    params_hash: string;
-    started_at: number;
-    digests: string[];
-    status: "in_flight";
-}
-export declare function isDeterministicOutcomeMessage(msg: string): boolean;
-export declare function beginInFlight(op: string, data: unknown, env?: {
-    account?: string;
-    network?: string;
-    dry_run?: boolean;
-}, submission?: unknown, startedAtMs?: number): string;
-export declare function parkUnknownOutcomeMarker(op: string, data: unknown, env?: {
-    account?: string;
-    dry_run?: boolean;
-}, submission?: unknown): void;
-interface IdempotencyKeyRecord {
-    op: string;
-    status: "pending" | "unknown";
-    first_seen: number;
-    sender?: string;
-    verify_events_since?: string;
-    digests: string[];
-}
-export declare function idempotencyKeyGate(key: string, op: string, dryRun?: boolean): IdempotencyKeyRecord | undefined;
-export declare function idempotencyKeyObserveUnknown(key: string, op: string, kit?: {
-    sender?: string;
-    verify_events_since?: string;
-    digests?: string[];
-}): void;
-export declare function idempotencyKeyClear(key: string): void;
-export declare function markerOpFor(op: string, data: unknown): string;
-export declare function recordInFlightOutcome(markerId: string, result: unknown): void;
-export interface LandedTombstone {
-    op: string;
-    digest: string;
-    at: number;
-}
-export declare function recentLandedTombstone(): LandedTombstone | undefined;
-export declare function clearInFlightMarkers(): number;
-export interface ReturnedDigest {
-    digest: string;
-    op: string;
-    at: number;
-}
-export declare function noteReturnedDigest(digest: string, op: string): void;
-export declare function priorReturnOfDigest(digest: string | undefined): ReturnedDigest | undefined;
-export declare function attachInFlightDigest(op: string, paramsHash: string | undefined, digest: string): void;
-export declare function inFlightParamsHash(data: unknown, submission?: unknown, account?: unknown): string;
-export declare function describeLastInFlight(op: string, paramsHash?: string): string | undefined;
-export declare function lastInFlightMarker(op: string, paramsHash?: string): InFlightRecord | undefined;
-export declare function consumeInFlightMarker(op: string, paramsHash: string): number;
-export declare function pendingInFlightResend(op: string, data: unknown, submission?: unknown, env?: {
-    account?: string;
-    dry_run?: boolean;
-}): string | undefined;
-export interface OrderLandedEvent {
-    order?: string;
-    progress?: string | null;
-    service?: string;
-    sender?: string;
-    time?: string | number;
-    digest?: string;
-    amount?: string | number | null;
-}
-export declare function matchOrderLandedEvent(marker: InFlightRecord, ev: OrderLandedEvent): string | undefined;
-export interface RecentOrderCandidate {
-    order: string;
-    owner?: string | null;
-    time?: string | number;
-    amount?: string | number | null;
-    items?: unknown;
-}
-export declare function matchRecentOrder(marker: InFlightRecord, cand: RecentOrderCandidate): string | undefined;
-export declare function listInFlightMarkers(): InFlightRecord[];
-export declare function recentReturnedDigests(limit?: number): ReturnedDigest[];
-export declare function recentLandedTombstones(): LandedTombstone[];
-export {};

package/dist/composition/input-normalize.d.ts

@@ -1,15 +0,0 @@
-import type { JsonValue, DerivedParam } from "./plan.js";
-import type { AllocatorRowData, CompilableTemplate, CompileBlocker } from "./compile.js";
-export declare function normalizeCompileInputs(template: CompilableTemplate, inputs: Record<string, JsonValue>, buildTimeMs?: number): {
-    inputs: Record<string, JsonValue>;
-    derivedParams: DerivedParam[];
-    blockers: CompileBlocker[];
-};
-export interface ConditionalSelection {
-    dropKeys: Set<string>;
-    selectorDroppedKeys: Set<string>;
-    shape: CompilableTemplate["machine_shape"];
-    rows: AllocatorRowData[];
-    blockers: CompileBlocker[];
-}
-export declare function applyConditionalSelectors(template: CompilableTemplate, inputs: Record<string, JsonValue>): ConditionalSelection;

package/dist/composition/materialize.d.ts

@@ -1,78 +0,0 @@
-import { type CreateStep, type LateQuery, type Plan, type StepId } from "./plan.js";
-import { type PlanAuditResult } from "./audit.js";
-export interface ExecOutcome {
-    outcome: "executed" | "failed" | "pending_input";
-    digest?: string;
-    created: {
-        object?: string;
-        type_raw?: string;
-    }[];
-    error?: string;
-}
-export type Executor = (operationType: string, data: Record<string, unknown>, env?: unknown) => Promise<ExecOutcome>;
-export type LateResolver = (q: LateQuery) => string;
-export type ObjectReader = (address: string, kind: string, env?: unknown) => Promise<unknown>;
-export interface MaterializeIO {
-    execute: Executor;
-    resolveLate?: LateResolver;
-    read?: ObjectReader;
-    env?: unknown;
-    envSignerRef?: string;
-    envByAccount?: Record<string, unknown>;
-    timeoutMs?: number;
-}
-export declare function handlerExecutor(env?: unknown): Executor;
-export declare function truncateProseUtf8(value: string, maxBytes: number): string;
-export declare function adaptConfigureParams(method: string, params: unknown): unknown;
-export declare function adaptCreateData(step: CreateStep, resolved: Record<string, unknown>): Record<string, unknown>;
-export declare function preflightPlan(plan: Plan): {
-    plan: Plan;
-    audit: PlanAuditResult;
-};
-export interface BindAuditOffense {
-    step: StepId;
-    slot: string;
-    kind: "intra_plan_bare_name" | "undeclared_external";
-    value: string;
-}
-export declare function bindAuditPlan(plan: Plan): BindAuditOffense[];
-export interface BindRecoveryEntry {
-    step: string;
-    kind?: string;
-    object?: string;
-    address?: string;
-    funded?: string;
-    retrieval?: string;
-}
-export declare function bindRecoveryList(plan: Plan, executed?: Record<string, string>): BindRecoveryEntry[];
-export declare function bindAuditReport(offenses: BindAuditOffense[], recovery: BindRecoveryEntry[]): string;
-export type StepStatus = "executed" | "failed" | "blocked";
-export interface StepResult {
-    stepId: string;
-    status: StepStatus;
-    digest?: string;
-    address?: string;
-    error?: string;
-}
-export interface MaterializeResult {
-    steps: StepResult[];
-    outputs: Record<string, string>;
-    completed: boolean;
-    budgetExhausted: boolean;
-    preflight: PlanAuditResult;
-    readback: ReadbackReport;
-}
-export declare function materializePlan(plan: Plan, io: MaterializeIO, resume?: {
-    completedSteps?: string[];
-    outputs?: Record<string, string>;
-}): Promise<MaterializeResult>;
-export interface ReadbackCheck {
-    name: string;
-    ok: boolean;
-    detail?: string;
-}
-export interface ReadbackReport {
-    ok: boolean;
-    checks: ReadbackCheck[];
-}
-export declare function conservationCheck(plan: Plan): ReadbackCheck[];

package/dist/composition/mode-gates.d.ts

@@ -1,35 +0,0 @@
-import type { JsonValue } from "./plan.js";
-import type { AllocatorRowData, CompilableTemplate, CompileBlocker, GuardSpec } from "./compile.js";
-type AfterSalesMode = NonNullable<CompilableTemplate["after_sales_mode"]>;
-type AcceptanceMode = NonNullable<CompilableTemplate["acceptance_mode"]>;
-type InstallmentMode = NonNullable<CompilableTemplate["installment_mode"]>;
-type AffiliateMode = NonNullable<CompilableTemplate["affiliate_mode"]>;
-type CrowdfundingMode = NonNullable<CompilableTemplate["crowdfunding_mode"]>;
-type LogisticsMode = NonNullable<CompilableTemplate["logistics_mode"]>;
-export interface ModeGateContext {
-    shape: CompilableTemplate["machine_shape"];
-    rows: AllocatorRowData[];
-    guardSpecs: GuardSpec[];
-    buildNotes: string[];
-    feeParams: CompilableTemplate["fee_params"];
-    arbitrationMode: CompilableTemplate["arbitration_mode"];
-    inputs: Record<string, JsonValue>;
-    buildTimeMs?: number;
-}
-export interface ModeGateAxes {
-    afterSalesMode: AfterSalesMode;
-    acceptanceMode: AcceptanceMode;
-    installmentMode: InstallmentMode;
-    affiliateMode: AffiliateMode;
-    crowdfundingMode: CrowdfundingMode;
-    logisticsMode: LogisticsMode;
-}
-export declare function emitModeGates(axes: ModeGateAxes, ctx: ModeGateContext): {
-    blockers: CompileBlocker[];
-    disclosures: string[];
-};
-export declare function deriveCapabilityModes({ template, inputs }: {
-    template: CompilableTemplate;
-    inputs: Record<string, JsonValue>;
-}): ModeGateAxes;
-export {};

package/dist/composition/param-disclosure.d.ts

@@ -1,61 +0,0 @@
-import { type ParamRow } from "../knowledge/param-tiers.js";
-import { type ParamSchemaRow } from "../knowledge/param-schema.js";
-import { type IndustryTemplate } from "../knowledge/template-loader.js";
-export type ParamStatus = "live" | "inert" | "not-flippable";
-export interface DisclosedParam extends ParamRow {
-    status: ParamStatus;
-    effect: string[];
-    landing: {
-        surface: string;
-        site: string;
-    }[];
-    editable: boolean;
-    paired_with?: string;
-    blocked_by?: string;
-}
-export declare function discloseParams(t: IndustryTemplate): DisclosedParam[];
-export interface DisclosureSummary {
-    total: number;
-    knobs: number;
-    editable: number;
-    inertKnobs: string[];
-    benchmark: number;
-    hidden: number;
-    liveKnobs: string[];
-}
-export declare function disclosureSummary(t: IndustryTemplate): DisclosureSummary;
-export type ParamPlaneRow = ParamSchemaRow & {
-    status: ParamStatus;
-    effect: string[];
-    landing: {
-        surface: string;
-        site: string;
-    }[];
-    landing_line: string;
-    editable: boolean;
-    inert_reason?: {
-        code: InertCode;
-        detail: string;
-    };
-    blocked_by?: string;
-    pair_note?: string;
-};
-export type InertCode = "external_object" | "no_consumer" | "prose_only" | "seat_not_built" | "not_settable" | "hidden";
-export declare function inertReason(r: {
-    key: string;
-    status: ParamStatus;
-    disclosure: string;
-    landing: readonly {
-        surface: string;
-        site: string;
-    }[];
-    blocked_by?: string;
-}): {
-    code: InertCode;
-    detail: string;
-} | undefined;
-export declare function landingLine(landing: readonly {
-    surface: string;
-    site: string;
-}[]): string;
-export declare function paramPlane(t: IndustryTemplate): ParamPlaneRow[];

package/dist/composition/plan-retry-ledger.d.ts

@@ -1,37 +0,0 @@
-export interface PlanStepOutcomeLike {
-    stepId: string;
-    status: string;
-    digest?: string;
-    error?: string;
-}
-export interface RepeatedFailure {
-    step_id: string;
-    consecutive_rounds: number;
-    error: string;
-}
-export interface LockedStep {
-    stepId: string;
-    count: number;
-    lastError: string;
-}
-export declare function planLedgerKey(plan: unknown): string;
-export declare function recordPlanRound(planKey: string, steps: readonly PlanStepOutcomeLike[]): void;
-export declare function repeatedPlanFailures(planKey: string): RepeatedFailure[];
-export declare function lockedFreshStep(planKey: string, planStepIds: readonly string[], adopted: ReadonlySet<string>): LockedStep | undefined;
-export declare function clearPlanStep(planKey: string, stepId: string): void;
-export interface PlanReceipt {
-    plan_key: string;
-    recorded_at: number;
-    completed: boolean;
-    steps: {
-        stepId: string;
-        status: string;
-        digest?: string;
-        address?: string;
-        error?: string;
-    }[];
-    outputs: Record<string, string>;
-    late_mark_bindings?: Record<string, string>;
-}
-export declare function writePlanReceipt(planKey: string, receipt: Omit<PlanReceipt, "plan_key" | "recorded_at">): void;
-export declare function readPlanReceipt(planKey: string): PlanReceipt | undefined;