dsh-kingdom 0.8.0 → 2.0.0

package/lib/types/core/governed.d.ts

@@ -1,4 +1,7 @@
-import { KingdomStore, type AffinityRow, type LeaseRow, type CapabilityDecisionRow, type DispatchRecordRow, type ExecutionRow, StaleStateError } from './db.js';
+import { KingdomStore, type AffinityRow, type LeaseRow, type CapabilityDecisionRow, type DispatchRecordRow, type ExecutionRow, type EventRow, StaleStateError } from './db.js';
+import { type BudgetAdmissionHandle } from './budget.js';
+import { type WorkspaceAdmissionHandle } from './workspace-admission.js';
+import { type CollaborationReadiness } from './collaboration.js';
 /** 完整 Runtime Session identity（M3-S1 冻结：(runtime_type, runtime_instance_ref, session_ref)）。 */
 export interface SessionIdentity {
     runtimeType: string;
@@ -13,6 +16,109 @@ export declare class GovernedApiError extends Error {
 export declare class SchemaV4NotMigratedError extends GovernedApiError {
     constructor();
 }
+export type RunnerContextPhase = 'OPEN' | 'ACQUIRED' | 'BOUND' | 'TERMINAL' | 'RECOVERING' | 'RECOVERY_TERMINAL' | 'RELEASED' | 'INVALID';
+export type RunnerContextErrorCode = 'RELATION_MISSING' | 'RELATION_MISMATCH' | 'INVALID_HANDLE' | 'INVALID_VERSION' | 'STALE_VERSION' | 'INVALID_ORDER' | 'RECOVERING' | 'RELEASED';
+export declare class RunnerContextError extends GovernedApiError {
+    readonly code: RunnerContextErrorCode;
+    constructor(code: RunnerContextErrorCode, message: string);
+}
+/** Opaque, module-minted identity.  The constructor rejects arbitrary keys. */
+export declare class RunnerContextHandle {
+    #private;
+    /** @internal The module-private secret is the only accepted constructor key. */
+    constructor(key: symbol);
+}
+/** Opaque monotonic token.  The public sequence is diagnostic only. */
+export declare class RunnerContextVersion {
+    #private;
+    /** @internal The module-private secret is the only accepted constructor key. */
+    constructor(key: symbol, sequence: number);
+    /**
+     * This value is intentionally only a diagnostic projection. The product
+     * never reads it to mint the next token; the authoritative sequence lives in
+     * the module-private WeakMap record below.
+     */
+    get sequence(): number;
+}
+export interface RunnerContextView {
+    readonly phase: RunnerContextPhase;
+    readonly kingdomId: string;
+    readonly taskId: string;
+    readonly attemptNo: number;
+    readonly executionId: string;
+    readonly leaseId: string;
+    readonly dispatchId: string;
+    readonly workerBindingId: string;
+    readonly sessionRef: string;
+    readonly dispatchState: string;
+    readonly executionState: string;
+    readonly leaseState: string;
+    readonly version: RunnerContextVersion;
+}
+export interface RunnerContextActionContext {
+    readonly handle: RunnerContextHandle;
+    readonly version: RunnerContextVersion;
+    readonly view: RunnerContextView;
+    readonly runtimeDispatchRef?: string;
+}
+export interface RunnerContextMutationResult<T> {
+    readonly value: T;
+    readonly view: RunnerContextView;
+}
+/**
+ * Product-side canonical Runner context.  It is intentionally not a DB handle
+ * and exposes only bounded identifiers/state views to a Runner.
+ */
+export declare class RunnerContextPort {
+    /** @internal The module-private secret is the only accepted constructor key. */
+    constructor(key: symbol);
+    get handle(): RunnerContextHandle;
+    get initialVersion(): RunnerContextVersion;
+    /** Product-internal phase probe used by the child broker lifecycle. */
+    get currentPhase(): RunnerContextPhase;
+    private state;
+    private consume;
+    private advance;
+    read(handle: RunnerContextHandle, version: RunnerContextVersion): RunnerContextView;
+    /**
+     * Non-mutating Product-child snapshot.  A broker read may observe the
+     * bounded view without consuming the version that the Product uses for its
+     * next receipt/correlation/terminal/settlement mutation.
+     */
+    brokerSnapshot(): RunnerContextView;
+    acquire(handle: RunnerContextHandle, version: RunnerContextVersion): RunnerContextView;
+    private mutate;
+    bindRuntimeReceipt<T>(handle: RunnerContextHandle, version: RunnerContextVersion, runtimeDispatchRef: string, action: (context: RunnerContextActionContext) => T): RunnerContextMutationResult<T>;
+    /**
+     * RECEIVED → CORRELATED plus Execution STARTING → RUNNING under the same
+     * opaque port/version.  The dispatch service supplies the Core write as the
+     * in-port action; callers cannot correlate by using the legacy standalone
+     * function outside this seam.
+     */
+    correlateRuntimeExecution<T>(handle: RunnerContextHandle, version: RunnerContextVersion, runtimeExecutionRef: string, action: (context: RunnerContextActionContext) => T): RunnerContextMutationResult<T>;
+    observeTerminal<T>(handle: RunnerContextHandle, version: RunnerContextVersion, action: (context: RunnerContextActionContext) => T): RunnerContextMutationResult<T>;
+    /** Observation timeout retains this original capability; the factory still rejects RECOVERING. */
+    deferRecovery(handle: RunnerContextHandle, version: RunnerContextVersion): RunnerContextMutationResult<ReturnType<typeof markGovernedDispatchRecovering>>;
+    /** Only the original deferred port can consume late evidence; no recovered factory or new Runner. */
+    checkRecovery(handle: RunnerContextHandle, version: RunnerContextVersion): RunnerContextView;
+    recoverTerminal(handle: RunnerContextHandle, version: RunnerContextVersion, input: TerminalEvidenceInput & {
+        runtimeExecutionRef: string;
+    }): RunnerContextMutationResult<{
+        dispatch: DispatchRecordRow;
+        execution: ExecutionRow;
+        lease: LeaseRow;
+    }>;
+    settleRecovery<T>(handle: RunnerContextHandle, version: RunnerContextVersion, action: (context: RunnerContextActionContext) => T): RunnerContextMutationResult<T>;
+    settle<T>(handle: RunnerContextHandle, version: RunnerContextVersion, action: (context: RunnerContextActionContext) => T): RunnerContextMutationResult<T>;
+}
+/**
+ * Mint a Runner context only after the DB has committed a canonical Dispatch
+ * relation.  The factory never accepts caller-supplied Task/Lease/Session IDs
+ * as authority; it derives all relation fields from the exact Dispatch row.
+ */
+export declare function createRunnerContextPort(store: KingdomStore, input: string | {
+    readonly dispatchId: string;
+}): RunnerContextPort;
 /** 期望旧态与当前库态不一致（CAS 失败）。 */
 export declare class StaleLeaseError extends StaleStateError {
 }
@@ -118,6 +224,37 @@ export interface CreateDispatchIntentInput {
  * 调用方在本函数返回（事务已提交）**之后**才允许调用 RuntimeAdapter.dispatch()。
  */
 export declare function createDispatchIntent(store: KingdomStore, input: CreateDispatchIntentInput): DispatchRecordRow;
+export interface PrepareGovernedDispatchInput {
+    kingdomId: string;
+    taskId: string;
+    attemptNo: number;
+    workerBindingId: string;
+    leaseId: string;
+    capabilityDecisionId: string;
+    session: SessionIdentity;
+    requestSnapshot: string;
+    inputRefJson: string;
+    payloadHash: string;
+    executionId?: string;
+    dispatchId?: string;
+    preparedAt?: string;
+    detail?: string | null;
+    budgetAdmission?: BudgetAdmissionHandle;
+    workspaceAdmission?: WorkspaceAdmissionHandle;
+    collaboration?: CollaborationReadiness | null;
+}
+export interface PreparedGovernedDispatchRows {
+    execution: ExecutionRow;
+    decision: CapabilityDecisionRow;
+    intent: DispatchRecordRow;
+    lease: LeaseRow;
+}
+/**
+ * TX-3 COMMIT POINT：在一个真实事务内同时准备 Execution、Decision binding、
+ * Dispatch Intent 与 EXECUTING Lease。这里仅调用无事务的 Store primitive，
+ * 不能嵌套现有 create/advance public helper。
+ */
+export declare function prepareGovernedDispatch(store: KingdomStore, input: PrepareGovernedDispatchInput): PreparedGovernedDispatchRows;
 export interface ReceiptInput {
     runtimeDispatchRef: string;
     receiptJson: string;
@@ -156,6 +293,50 @@ export declare function advanceDispatchState(store: KingdomStore, dispatchId: st
     receiptAt?: string | null;
     terminalAt?: string | null;
 }): DispatchRecordRow;
+export type GovernedRecoveryReasonCode = 'RECONCILE_UNKNOWN' | 'RECONCILE_UNTRUSTED' | 'DISPATCH_EXCEPTION' | 'TERMINAL_POLL_EXHAUSTED';
+export interface GovernedRecoveryRows {
+    dispatch: DispatchRecordRow;
+    lease: LeaseRow;
+    execution: ExecutionRow;
+}
+/** Bounded, non-runtime-specific reasons for a post-TX-4 integrity incident. */
+export type TerminalIntegrityReasonCode = 'TRUST_FENCE_MISSING' | 'TRUST_FENCE_EXPECTATION_MISMATCH' | 'TRUST_FENCE_CHECK_FAILED' | 'TRUST_FENCE_RELEASE_FAILED';
+export type TerminalIntegrityPhase = 'settlement' | 'release';
+export interface DispatchTerminalIntegrityIncidentInput {
+    dispatchId: string;
+    reasonCode: TerminalIntegrityReasonCode;
+    phase: TerminalIntegrityPhase;
+}
+export interface DispatchTerminalIntegrityIncidentRows {
+    dispatch: DispatchRecordRow;
+    lease: LeaseRow;
+    execution: ExecutionRow;
+    incident: EventRow;
+    incidentCreated: boolean;
+    /** RELEASED is deliberately not rolled back; it requires escalation. */
+    escalated: boolean;
+}
+/**
+ * TX-4 post-terminal integrity seam.
+ *
+ * This is intentionally separate from markGovernedDispatchRecovering:
+ * Dispatch and Execution are already terminal and must remain terminal.  The
+ * exact Dispatch/Task/attempt relation is re-read inside one IMMEDIATE
+ * transaction, then only a still-recoverable Lease is moved to RECOVERING and
+ * one bounded incident event is appended.  Replays are a zero-event readback.
+ */
+export declare function recordDispatchTerminalIntegrityIncident(store: KingdomStore, input: DispatchTerminalIntegrityIncidentInput): DispatchTerminalIntegrityIncidentRows;
+/**
+ * Atomically move one governed Dispatch, its Lease, and its Execution into
+ * RECOVERING. This is shared by reconciliation and terminal-poll timeout.
+ *
+ * All related rows are re-read and validated before the first write. The
+ * low-level CAS updates and recovery events share one transaction; the
+ * independently transactional mark* helpers below must not be nested here.
+ * Repeating the call after all three rows are RECOVERING is a zero-event,
+ * zero-write idempotent readback.
+ */
+export declare function markGovernedDispatchRecovering(store: KingdomStore, dispatchId: string, reasonCode: GovernedRecoveryReasonCode): GovernedRecoveryRows;
 /** Lease 进 RECOVERING（RECOVERING 不改 Task 治理状态；仅重建证据）。 */
 export declare function markLeaseRecovering(store: KingdomStore, leaseId: string): LeaseRow;
 /** Dispatch 进 RECOVERING（Intent 已存在但证据链断裂；禁盲目重发）。 */

package/lib/types/core/kingdom.d.ts

@@ -1,4 +1,5 @@
 import { KingdomStore } from './db.js';
+import { type OwnerEventSource } from './owner-control.js';
 export interface InitResult {
     action: 'initialized' | 'attached';
     kingdomId: string;
@@ -38,3 +39,5 @@ export declare class KingdomManager {
     rescan(): InitResult;
     close(): void;
 }
+/** Synchronous fact writer shared by direct init and the Owner receipt transaction. */
+export declare function initializeKingdomFacts(store: KingdomStore, kingdomName: string, ownerName: string, source?: OwnerEventSource): InitResult;

package/lib/types/core/owner-binding-intent.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Pure natural-language -> Owner binding intent Draft.
+ *
+ * This module deliberately has no KingdomStore, filesystem, event, runtime, or
+ * capability dependency.  A caller may provide an exact target_session_ref,
+ * but that value is only a target reference; it never becomes Owner authority.
+ */
+export declare const DIRECT_SLASH_CONFIRM_REQUIRED: "DIRECT_SLASH_CONFIRM_REQUIRED";
+export type IntentRoleType = 'CHANCELLOR' | 'SUPERVISOR' | 'WORKER';
+export type ParsedRoleType = IntentRoleType | 'OWNER';
+export type TargetSessionClassification = 'ACTIVE' | 'FOREIGN' | 'EXPIRED' | 'ABORTED' | 'MULTIPLE' | 'ABSENT' | 'UNKNOWN';
+/** @deprecated Use TargetSessionClassification for the explicit seam. */
+export type TargetSessionState = TargetSessionClassification | 'MISSING';
+export type RejectedOwnerBindingOperation = 'kingdom_bind_role' | 'kingdom_bind_session' | 'role.bind' | 'role.session';
+export interface StructuredOwnerBindingRejection {
+    code: string;
+    operation: RejectedOwnerBindingOperation;
+    request?: {
+        role_type?: string | null;
+        role_name?: string | null;
+        session_id?: string | null;
+        binding_id?: string | null;
+        territory_id?: string | null;
+    };
+    context?: OwnerBindingIntentContext;
+}
+export interface OwnerBindingStepPolicy {
+    failure: 'STOP_NO_AGENT_RETRY_OR_COMPENSATION';
+}
+export interface RoleBindDraftStep {
+    step_id: 'ROLE_BIND';
+    kind: 'role.bind';
+    args: RoleBindDraftOperation['args'];
+    canonical_direct_slash: string;
+    canonical_direct_slash_template: null;
+    depends_on: readonly [];
+    confirmation: typeof DIRECT_SLASH_CONFIRM_REQUIRED;
+    policy: OwnerBindingStepPolicy;
+}
+export interface RoleSessionDraftStep {
+    step_id: 'ROLE_SESSION';
+    kind: 'role.session';
+    args: RoleSessionDraftOperation['args'];
+    canonical_direct_slash: string;
+    canonical_direct_slash_template: null;
+    depends_on: readonly [];
+    confirmation: typeof DIRECT_SLASH_CONFIRM_REQUIRED;
+    policy: OwnerBindingStepPolicy;
+}
+export interface TerritorySupervisorDraftStep {
+    step_id: 'TERRITORY_SUPERVISOR';
+    kind: 'territory.supervisor';
+    args: {
+        territory_id: string;
+        supervisor_binding_id_ref: string;
+    };
+    canonical_direct_slash: string | null;
+    canonical_direct_slash_template: string | null;
+    depends_on: readonly string[];
+    confirmation: typeof DIRECT_SLASH_CONFIRM_REQUIRED;
+    policy: OwnerBindingStepPolicy;
+}
+export type CanonicalDraftStep = RoleBindDraftStep | RoleSessionDraftStep | TerritorySupervisorDraftStep;
+export interface TargetSessionCandidate {
+    session_ref: string;
+    status?: TargetSessionState;
+    kingdom_id?: string | null;
+}
+export interface BindingSnapshot {
+    binding_id: string;
+    role_type: string;
+    role_name?: string | null;
+    session_id?: string | null;
+    status?: 'ACTIVE' | 'RETIRED' | 'DELETED' | 'EXPIRED' | string;
+    kingdom_id?: string | null;
+}
+export interface TerritorySnapshot {
+    territory_id: string;
+    name: string;
+    aliases?: readonly string[];
+    status?: 'ACTIVE' | 'DELETED' | 'EXPIRED' | string;
+    kingdom_id?: string | null;
+    supervisor_binding_id?: string | null;
+}
+/**
+ * The only session input accepted for “当前会话/这个会话/该会话” is the
+ * exact target_session_ref supplied by the invocation context.  The optional
+ * resolution fields let an adapter report foreign, expired, or multi-match
+ * context without making this pure module inspect a runtime or database.
+ */
+export interface OwnerBindingIntentContext {
+    target_session_ref?: string | null;
+    /**
+     * Trusted adapter proof seam. ACTIVE is valid only after the adapter proves
+     * current initiator + agents.get/session.get object identity + matching ids
+     * + running + non-aborted signal; absent or failed proof never becomes ACTIVE.
+     */
+    target_session_classification?: TargetSessionClassification;
+    /**
+     * Legacy compatibility hint only. It is intentionally not an authority or
+     * liveness proof; callers must migrate to target_session_classification.
+     */
+    target_session_state?: TargetSessionState;
+    target_session_matches?: readonly string[];
+    target_session_candidates?: readonly TargetSessionCandidate[];
+    kingdom_id?: string | null;
+    role_bindings?: readonly BindingSnapshot[];
+    territories?: readonly TerritorySnapshot[];
+}
+export interface OwnerBindingIntentInput {
+    text: string;
+    context?: OwnerBindingIntentContext;
+}
+export type IntentAmbiguityCode = 'UNSUPPORTED_INPUT' | 'REJECTION_UNSUPPORTED' | 'OWNER_ROLE_DIRECT_ONLY' | 'SESSION_MISSING' | 'SESSION_FOREIGN' | 'SESSION_EXPIRED' | 'SESSION_MULTIPLE' | 'SESSION_UNRESOLVED' | 'ROLE_MULTIPLE' | 'ROLE_FOREIGN' | 'ROLE_BINDING_UNSAFE' | 'TERRITORY_REQUIRED' | 'TERRITORY_NOT_FOUND' | 'TERRITORY_FOREIGN' | 'TERRITORY_UNAVAILABLE' | 'TERRITORY_MULTIPLE' | 'TERRITORY_UNRESOLVED';
+export interface DraftAmbiguity {
+    code: IntentAmbiguityCode;
+    question: string;
+}
+export interface DraftIntent {
+    role_type: ParsedRoleType | null;
+    role_alias: string | null;
+    target: 'CALL_CONTEXT_TARGET_SESSION' | null;
+    target_session_ref: string | null;
+    territory: {
+        territory_id: string;
+        name: string;
+    } | null;
+}
+export interface RoleBindDraftOperation {
+    kind: 'role.bind';
+    args: {
+        role_type: IntentRoleType;
+        role_name: string;
+        session_id: string;
+    };
+}
+export interface RoleSessionDraftOperation {
+    kind: 'role.session';
+    args: {
+        binding_id: string;
+        session_id: string;
+    };
+}
+export type DraftOperation = RoleBindDraftOperation | RoleSessionDraftOperation;
+export interface OwnerBindingIntentDraft {
+    kind: 'OWNER_BINDING_INTENT_DRAFT';
+    status: 'DRAFT_READY' | 'AMBIGUOUS';
+    /** Natural language never supplies an Owner principal or capability. */
+    authority_source: 'NONE';
+    owner_authority: false;
+    write_effect: 'ZERO_WRITE';
+    normalized_input: string;
+    intent: DraftIntent;
+    operation: DraftOperation | null;
+    steps: readonly CanonicalDraftStep[];
+    /** Alias kept for integrations that name the collection explicitly. */
+    canonical_steps: readonly CanonicalDraftStep[];
+    policy: OwnerBindingStepPolicy;
+    canonical_direct_slash: string | null;
+    confirmation: typeof DIRECT_SLASH_CONFIRM_REQUIRED | null;
+    ambiguity: DraftAmbiguity | null;
+}
+/** Pure materializer for the second direct Slash once role.bind returned its ID. */
+export declare function canonicalTerritorySupervisorSlash(territoryId: string, supervisorBindingId: string): string | null;
+/** Parse one bounded natural-language intent without performing any write. */
+export declare function draftOwnerBindingIntent(input: OwnerBindingIntentInput): OwnerBindingIntentDraft;
+/**
+ * Convert a structured OWNER_CONTROL_REQUIRED rejection into the same pure
+ * Draft contract.  The rejection is data, not authority; target session still
+ * comes only from the explicitly classified invocation context.
+ */
+export declare function draftOwnerBindingIntentFromRejectedWrite(input: StructuredOwnerBindingRejection): OwnerBindingIntentDraft;
+/** Compatibility-friendly name for callers that prefer a parse verb. */
+export declare const parseOwnerBindingIntent: typeof draftOwnerBindingIntent;
+/** Stable, JSON-safe rendering for UI/Agent echo and deterministic tests. */
+export declare function serializeOwnerBindingIntentDraft(draft: OwnerBindingIntentDraft): string;

package/lib/types/core/owner-control.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Trusted-local Owner Control Plane.
+ *
+ * The capability below is deliberately opaque to runtime callers.  Only the
+ * canonical direct `/kingdom` command handler may mint one; Agent Tools,
+ * GUI/HTTP handlers, arguments, and DSH session attribution never receive a
+ * path to construct or forward it.
+ */
+import type { KingdomStore, RoleBindingRow } from './db.js';
+import type { AdminAuth } from './binding.js';
+declare const OWNER_CONTROL_MARKER: unique symbol;
+export interface OwnerEventSource {
+    source_channel: 'LOCAL_DIRECT_SLASH' | 'LOCAL_OWNER_GUI';
+    authorization_source?: 'LOCAL_DIRECT_SLASH';
+    decision_id?: string;
+    operation_id?: string;
+}
+export interface OwnerOperationMatch {
+    operation: string;
+    input: unknown;
+}
+/** Stable JSON for exact, immutable operation matching. Undefined follows JSON semantics. */
+export declare function ownerInputHash(input: unknown): string;
+export interface OwnerControlCapability {
+    readonly [OWNER_CONTROL_MARKER]: true;
+}
+/** Mint a capability for the direct local Slash handler only. */
+export declare function issueOwnerControlCapability(): OwnerControlCapability;
+export declare function isOwnerControlCapability(value: unknown): value is OwnerControlCapability;
+/** Internal controller seam; requires the original direct capability, never HTTP data. */
+export declare function issueOwnerOperationCapability(authority: OwnerControlCapability, store: KingdomStore, kingdomId: string, match: OwnerOperationMatch, source: OwnerEventSource): OwnerControlCapability;
+export declare function revokeOwnerOperationCapability(capability: OwnerControlCapability): void;
+export interface OwnerControlCheck {
+    ok: true;
+    owner: RoleBindingRow | null;
+    ownerId: string;
+    sourceChannel: 'LOCAL_DIRECT_SLASH' | 'LOCAL_OWNER_GUI';
+    eventSource: OwnerEventSource;
+}
+export interface OwnerControlFailure {
+    ok: false;
+    message: string;
+}
+/**
+ * The single Core gate for Owner-only writes.  It intentionally ignores
+ * OWNER.session_id and all caller/session fields; the only authority input is
+ * the opaque capability minted by the direct Slash adapter.
+ */
+export declare function requireOwnerControl(store: KingdomStore, kingdomId: string, capability: unknown, match?: OwnerOperationMatch): OwnerControlCheck | OwnerControlFailure;
+/** Convert the direct capability into the shared Core admin input. */
+export declare function ownerControlAuth(capability: OwnerControlCapability): AdminAuth;
+export declare function ownerEventPayload(operation: string, fields?: Record<string, unknown>, source?: OwnerEventSource): Record<string, unknown>;
+export {};

package/lib/types/core/owner-window.d.ts

@@ -0,0 +1,226 @@
+import type { KingdomStore } from './db.js';
+import { type ExecutionProfileV1 } from './binding.js';
+import { type OwnerControlCapability } from './owner-control.js';
+import { type BudgetPolicyParameters } from './budget.js';
+import { type PlanAdoptionParameters, type CollaborationPlanView } from './collaboration.js';
+export declare const OWNER_MUTATION_ACTIONS: readonly ["init", "territory.create", "territory.update", "territory.supervisor", "role.bind", "role.session", "ceiling", "execution-profile", "budget.policy", "plan.adopt"];
+export type OwnerMutationAction = typeof OWNER_MUTATION_ACTIONS[number];
+export type OwnerManagedRole = 'CHANCELLOR' | 'SUPERVISOR' | 'WORKER';
+export interface OwnerDecisionScope {
+    kingdomWide: boolean;
+    territoryIds: string[];
+    bindingIds: string[];
+    roleTypes: OwnerManagedRole[];
+    targetSessionIds: string[];
+    workspaceRoots: string[];
+}
+export interface OwnerDecisionInput {
+    kingdomId: string | null;
+    actions: OwnerMutationAction[];
+    scope: OwnerDecisionScope;
+    ttlMs: number;
+}
+declare const OWNER_DECISION_HANDLE: unique symbol;
+export interface OwnerDecisionHandle {
+    readonly [OWNER_DECISION_HANDLE]: true;
+}
+export interface OwnerDecisionView {
+    decisionId: string;
+    kingdomId: string | null;
+    ownerId: string | null;
+    actions: OwnerMutationAction[];
+    scope: OwnerDecisionScope;
+    createdAt: string;
+    expiresAt: string;
+    state: 'ACTIVE' | 'EXPIRED' | 'REVOKED' | 'CONSUMED';
+}
+export interface OwnerValidationFailure {
+    ok: false;
+    code: string;
+    message: string;
+}
+export type OwnerValidationResult = {
+    ok: true;
+} | OwnerValidationFailure;
+export interface OwnerSessionValidationInput {
+    kingdomId: string;
+    roleType: 'CHANCELLOR' | 'SUPERVISOR';
+    bindingId: string | null;
+    sessionId: string;
+    signal: AbortSignal;
+}
+export interface OwnerProfileValidationInput {
+    kingdomId: string;
+    bindingId: string;
+    roleType: OwnerManagedRole;
+    profile: Readonly<ExecutionProfileV1> | null;
+    signal: AbortSignal;
+}
+export interface OwnerRuntimeSessionChoice {
+    id: string;
+    label: string;
+}
+export interface OwnerDecisionControllerOptions {
+    now?: () => number;
+    validationTimeoutMs?: number;
+    validateTargetSession: (input: OwnerSessionValidationInput) => Promise<OwnerValidationResult>;
+    validateExecutionProfile: (input: OwnerProfileValidationInput) => Promise<OwnerValidationResult>;
+    listTargetSessions: (input: {
+        sessionIds: readonly string[];
+        signal: AbortSignal;
+    }) => Promise<readonly OwnerRuntimeSessionChoice[]>;
+}
+export interface OwnerOperationCatalog {
+    plans?: CollaborationPlanView[];
+    territories: {
+        id: string;
+        name: string;
+    }[];
+    bindings: {
+        id: string;
+        roleType: string;
+        roleName: string;
+    }[];
+    runtimeSessions: OwnerRuntimeSessionChoice[];
+    workspaceRoots: string[];
+}
+export type OwnerOperationInput = {
+    action: 'init';
+    parameters: {
+        kingdom_name: string;
+        owner_name: string;
+    };
+} | {
+    action: 'territory.create';
+    parameters: {
+        name: string;
+        workspace_path: string;
+        summary?: string | null;
+    };
+} | {
+    action: 'territory.update';
+    parameters: {
+        territory_id: string;
+        name?: string;
+        summary?: string | null;
+    };
+} | {
+    action: 'territory.supervisor';
+    parameters: {
+        territory_id: string;
+        supervisor_binding_id: string;
+    };
+} | {
+    action: 'role.bind';
+    parameters: {
+        role_type: OwnerManagedRole;
+        role_name: string;
+        session_id?: string | null;
+    };
+} | {
+    action: 'role.session';
+    parameters: {
+        binding_id: string;
+        session_id: string;
+    };
+} | {
+    action: 'ceiling';
+    parameters: {
+        ceiling: Record<string, boolean>;
+    };
+} | {
+    action: 'execution-profile';
+    parameters: {
+        binding_id: string;
+        profile: ExecutionProfileV1 | null;
+    };
+} | {
+    action: 'budget.policy';
+    parameters: BudgetPolicyParameters;
+} | {
+    action: 'plan.adopt';
+    parameters: PlanAdoptionParameters;
+};
+export interface OwnerOperationPreview {
+    prepareId: string;
+    operationId: string;
+    decisionId: string;
+    action: OwnerMutationAction;
+    summary: string;
+    changes: {
+        label: string;
+        before: string | null;
+        after: string | null;
+    }[];
+    affected: {
+        territoryIds: string[];
+        bindingIds: string[];
+    };
+    createdAt: string;
+    expiresAt: string;
+}
+export interface OwnerOperationReceipt {
+    type: 'KingdomOwnerOperationReceipt/v1';
+    operationId: string;
+    prepareId: string;
+    decisionId: string;
+    kingdomId: string;
+    ownerId: string;
+    action: OwnerMutationAction;
+    inputHash: string;
+    status: 'APPLIED';
+    target: {
+        type: 'kingdom' | 'territory' | 'binding' | 'collaboration-plan';
+        id: string;
+    };
+    receiptSeq: number;
+    appliedAt: string;
+    message: string;
+}
+export declare class OwnerOperationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** Trusted-local decision registry. Public IDs and JSON views never confer authority. */
+export declare class OwnerDecisionController {
+    private readonly store;
+    private readonly options;
+    private readonly decisions;
+    private readonly now;
+    private readonly timeout;
+    private disposed;
+    constructor(store: KingdomStore, options: OwnerDecisionControllerOptions);
+    activate(capability: OwnerControlCapability, input: OwnerDecisionInput): {
+        handle: OwnerDecisionHandle;
+        decision: OwnerDecisionView;
+    };
+    inspect(handle: OwnerDecisionHandle): OwnerDecisionView | null;
+    catalog(handle: OwnerDecisionHandle): Promise<OwnerOperationCatalog>;
+    prepare(handle: OwnerDecisionHandle, raw: OwnerOperationInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<OwnerOperationPreview>;
+    commit(handle: OwnerDecisionHandle, input: {
+        prepareId: string;
+        operationId: string;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<OwnerOperationReceipt>;
+    receipt(handle: OwnerDecisionHandle, operationId: string): OwnerOperationReceipt | null;
+    revoke(handle: OwnerDecisionHandle): OwnerDecisionView;
+    dispose(): void;
+    private expire;
+    private invalidate;
+    private active;
+    private assertActive;
+    private observe;
+    private validate;
+    private context;
+    private guardUnsettled;
+    private changes;
+    private apply;
+    /** Synchronous closed dispatcher: no callback or transport receives an administration capability. */
+    private mutate;
+    private event;
+    private receiptEventId;
+}
+export {};