@software-dlc/cli 0.157.2

package/dist/local/workspace-runtime.d.ts

@@ -0,0 +1,690 @@
+import type { CodeToGraphValidationWarning, NodeOrigin } from '@software-dlc/graph/types';
+import { materializeGraphProjection } from './projection.js';
+import { type EvidenceSignResult, type SourceReferenceSpec } from './workspace-evidence.js';
+import { type SourceEntry } from './workspace-sources.js';
+import { type EvidenceStatusResult } from './workspace-evidence-status.js';
+import { type GitWorktreeContext } from './git.js';
+import { LocalWorkspaceGraphStore } from './workspace-graph-store.js';
+import type { LocalIntegrationQueueEntry, LocalIntegrationRunResult, LocalHandoffApplyRunResult, LocalHandoffPrepareRunResult, LocalHandoffRuntimeInspection, LocalReconciliationResult, LocalWorkspaceCommit } from './workspace-history-types.js';
+import { type BlastRadiusResult } from './blast-radius.js';
+import { type FindResult, type ShowResult } from './graph-read.js';
+import { type SkippedFolderMember } from './folder-members.js';
+import { type VariantsReport } from './variants.js';
+import { type LocalWorkspaceOverlapResult } from './workspace-overlap.js';
+import { type LocalBuiltView, type LocalGate } from './workspace-built-content.js';
+import { type LocalClaimList, type LocalClaimView } from './workspace-claim-views.js';
+import { type ClaimStatus, type ClaimStatusEnvironment, type ClaimStatusResult, type ClaimStatusView } from './workspace-claim-status.js';
+import { type LocalConflictResolutionBudget, type LocalConflictResolver } from './workspace-resolution.js';
+import { LocalWorkspaceStore, type LocalWorkspace, type LocalWorkspaceActorKind, type LocalSourceRepositoryBinding, type LocalSourceEvidenceScope, type LocalWorkspaceCommitSourceContext } from './workspace-store.js';
+import type { LocalDecision } from './workspace-decision-store.js';
+import { type LocalWorkspacePrunePlan, type LocalWorkspacePruneResult } from './workspace-prune.js';
+import { type LocalWorkspaceAuthorityInspection } from './workspace-authority.js';
+import { type LoadedLocalWorkspaceResolver, type LocalWorkspaceResolverStatus } from './workspace-resolver-provider.js';
+import { type LocalWorkspaceRemoteConfiguration, type LocalWorkspaceRemoteDiscovery, type LocalWorkspaceRemoteStatus } from './workspace-remote-provider.js';
+import { type LocalRemoteFetchResult, type LocalRemoteTrackingRef } from './workspace-remote-fetch.js';
+import { type LocalBranchCreationResult, type LocalBranchSelectionResult, type LocalBranchStatus } from './workspace-branch-runtime.js';
+import { type LocalWorkspacePickResult } from './workspace-pick-runtime.js';
+import type { LocalPickEntity } from './workspace-pick.js';
+import { type LocalUpstreamIntegrationResult, type LocalUpstreamRevertResult } from './workspace-upstream-runtime.js';
+import type { LocalUpstreamIntegrationStatus } from './workspace-upstream-inspection.js';
+export type { LocalBranchCreationResult, LocalBranchSelectionResult, LocalBranchStatus } from './workspace-branch-runtime.js';
+export type { LocalUpstreamIntegrationResult, LocalUpstreamRevertResult } from './workspace-upstream-runtime.js';
+export type { LocalUpstreamIntegrationStatus } from './workspace-upstream-inspection.js';
+import { type LocalRemotePushJournal, type LocalRemotePushResult } from './workspace-remote-push.js';
+import { type LocalRemoteTopicJournal, type LocalRemoteTopicResult } from './workspace-remote-topic.js';
+import { type LocalRemotePullRequestJournal, type LocalRemotePullRequestResult } from './workspace-remote-pull-request.js';
+import { type LocalPortableHistoryConversionResult, type LocalPortableHistoryPlan } from './workspace-portable-authoring.js';
+import { type LocalWorkspaceTaskScope } from './workspace-scope.js';
+import { type LocalDocumentEmbedIssue } from './document-embeds.js';
+import { type LocalWorkspaceStorageMode, type LocalWorkspaceTopology } from './workspace-topology.js';
+export type LocalWorkspaceProjectionStatus = {
+    version: 1;
+    workspace: LocalWorkspace;
+    projection_dir: string;
+    control_dir: string;
+    head_root_hash: string;
+    projection_root_hash: string;
+    projection_dirty: boolean;
+    task_scope: LocalWorkspaceTaskScope | null;
+    /**
+     * The workspace this one forked from, and whether its head holds commits
+     * this one lacks (sdlc integrate reconcile --source brings them in).
+     */
+    source?: {
+        workspace_id: string;
+        head_revision: string;
+        behind: boolean;
+    };
+};
+export type LocalWorkspaceProjectionRecoveryResult = {
+    version: 1;
+    status: 'unchanged' | 'recovered';
+    workspace: LocalWorkspace;
+    head_root_hash: string;
+    previous_projection_root_hash: string | null;
+    discarded_unreadable_projection: boolean;
+};
+export type LocalWorkspaceCommitResult = {
+    version: 1;
+    status: 'unchanged';
+    workspace: LocalWorkspace;
+    root_hash: string;
+} | {
+    version: 1;
+    status: 'committed';
+    /**
+     * Read first: validation passed (a failure commits nothing and throws),
+     * with every warning below and those about the graph's shape (iss-424).
+     */
+    validation: {
+        status: 'passed' | 'passed_with_warnings';
+        warnings: string[];
+    };
+    workspace: LocalWorkspace;
+    commit: LocalWorkspaceCommit;
+    source_context: LocalWorkspaceCommitSourceContext | null;
+    /** Document embeds this commit leaves pointing at missing entities. */
+    document_embed_warnings?: LocalDocumentEmbedIssue[];
+    /** Libraries this commit adds or changes that read as built here. */
+    library_origin_warnings?: CodeToGraphValidationWarning[];
+};
+export type LocalMultiRepositoryContext = {
+    version: 1;
+    graph_repository: {
+        repository_id: string;
+        state_dir: string;
+    };
+    source_repository: {
+        binding: LocalSourceRepositoryBinding | null;
+        git_ref: string | null;
+        git_head: string;
+        git_worktree_path: string;
+    };
+    graph_workspace: {
+        workspace_id: string;
+        source_workspace_id: string | null;
+        sdlc_branch: string | null;
+        fork_revision: string;
+        head_revision: string;
+        projection_dir: string;
+    };
+    topology: {
+        topology_path: string;
+        storage_mode: LocalWorkspaceStorageMode;
+    };
+};
+/** What sdlc workspace attach --all-members did for each member of the folder. */
+export type LocalFolderAttachResult = {
+    version: 1;
+    folder: string;
+    source_workspace_id: string;
+    head_revision: string;
+    attached: Array<{
+        name: string;
+        path: string;
+        workspace_id: string;
+        projection_dir: string;
+        nodes: number;
+        edges: number;
+    }>;
+    skipped: SkippedFolderMember[];
+    /** Attached members whose head lacks the coordinator's head. */
+    behind: Array<{
+        name: string;
+        path: string;
+        workspace_id: string;
+        head_revision: string;
+        /** Run in the member's checkout to bring in the coordinator's commits. */
+        catch_up: string;
+    }>;
+    /** Attached members whose fork binding moved to upstream (realignForkBinding). */
+    rebound: Array<{
+        name: string;
+        path: string;
+        from: string;
+        to: string;
+    }>;
+};
+export declare class LocalWorkspaceRuntime {
+    readonly git: GitWorktreeContext;
+    readonly state_dir: string;
+    readonly store: LocalWorkspaceStore;
+    readonly graphs: LocalWorkspaceGraphStore;
+    topology: LocalWorkspaceTopology | null;
+    private readonly runtime_lease;
+    private closed;
+    private readonly resolver_store;
+    private readonly remote_store;
+    private readonly remote_fetcher;
+    private readonly remote_pusher;
+    private readonly remote_topic_publisher;
+    private readonly remote_pull_request_creator;
+    private readonly portable_authoring;
+    private readonly commits;
+    private readonly authority;
+    private readonly handoff_runtime;
+    private readonly pruner;
+    private readonly branch_runtime;
+    private readonly integration_runtime;
+    private readonly pick_runtime;
+    private readonly upstream_runtime;
+    private readonly environment_runtime;
+    private readonly materialize_projection;
+    private constructor();
+    static open(input?: {
+        cwd?: string;
+        state_dir?: string;
+        graph_repository_id?: string;
+        materialize_projection?: typeof materializeGraphProjection;
+    }): Promise<LocalWorkspaceRuntime>;
+    close(): void;
+    initializeCurrentWorkspace(input?: {
+        actor_kind?: LocalWorkspaceActorKind;
+        source_repository_association_id?: string;
+        source_remote_name?: string;
+        storage_mode?: LocalWorkspaceStorageMode;
+    }): Promise<LocalWorkspaceProjectionStatus>;
+    private registerProjectionAsWorkspace;
+    private persistCurrentTopology;
+    private bindCurrentSourceRepository;
+    /**
+     * The remote a new binding takes when none is named: the one the
+     * association is bound to from another clone, when this repository has a
+     * remote of that identity; else the remote its references are named from
+     * (namingRemote), else origin. A binding the repository already has keeps
+     * its own remote (bindCurrentSourceRepository).
+     */
+    private defaultSourceRemote;
+    /**
+     * A binding made before init and attach bound the naming remote (2026-10-28)
+     * may name a fork's origin while its references name upstream: this moves
+     * it to upstream, with the topology of every attached checkout of the
+     * repository, so a workspace commit's remote identity names the repository
+     * its references name. Only origin gives way, only to upstream, as in
+     * repositoryNames, and only for a binding made before that rule, so a
+     * remote chosen since is kept. Only the binding row moves: a checkout's
+     * topology still naming origin matches it as moved, and opening the
+     * checkout rewrites it. Returns the identities it moved between, or null.
+     */
+    private realignForkBinding;
+    attachCurrentSourceWorkspace(input: {
+        source_workspace_id: string;
+        expected_source_sdlc_head_commit_id: string;
+        source_repository_association_id: string;
+        source_remote_name?: string;
+        actor_kind?: LocalWorkspaceActorKind;
+        storage_mode?: LocalWorkspaceStorageMode;
+        task_scope: LocalWorkspaceTaskScope;
+        /** Materialize the whole graph rather than only the task scope. */
+        full_projection?: boolean;
+    }): Promise<LocalWorkspaceProjectionStatus>;
+    /**
+     * Attaches every other repository of the folder whose home this workspace's
+     * checkout belongs to (run in its plan coordinator), each from this
+     * workspace's head with its whole-repository scope (repositoryTaskScope).
+     * A member that cannot attach now (already attached, no node cites it yet,
+     * or attach refuses) is skipped with its reason, so a rerun picks it up.
+     */
+    attachFolderMembers(input?: {
+        actor_kind?: LocalWorkspaceActorKind;
+        storage_mode?: LocalWorkspaceStorageMode;
+        full_projection?: boolean;
+    }): Promise<LocalFolderAttachResult>;
+    getMultiRepositoryContext(): Promise<LocalMultiRepositoryContext>;
+    detachCurrentSourceWorkspace(): Promise<{
+        version: 1;
+        status: 'detached';
+        workspace: LocalWorkspace;
+        topology_path: string;
+        projection_dir: string;
+        projection_preserved: true;
+        source_binding_removed: boolean;
+    }>;
+    createChildWorkspace(input: {
+        actor_workspace_id: string;
+        target_path: string;
+        actor_kind?: LocalWorkspaceActorKind;
+        task_scope: LocalWorkspaceTaskScope;
+    }): Promise<LocalWorkspaceProjectionStatus>;
+    listWorkspaces(): LocalWorkspace[];
+    /**
+     * Replaces a child workspace's declared task scope, for example when a plan
+     * grows. The new scope must still cover the workspace's own changes, which
+     * are measured from its merge base with its source.
+     */
+    replaceTaskScope(input: {
+        actor_workspace_id: string;
+        workspace_id: string;
+        task_scope: LocalWorkspaceTaskScope;
+    }): Promise<{
+        version: 1;
+        workspace_id: string;
+        previous_task_scope: LocalWorkspaceTaskScope | null;
+        task_scope: LocalWorkspaceTaskScope;
+    }>;
+    /**
+     * Removes one entity file from the current workspace's projection and, when
+     * the head has that entity, records the deletion for the next commit, like
+     * hosted `sdlc rm`. The commit still enforces the task scope.
+     */
+    removeEntity(input: {
+        actor_workspace_id: string;
+        relative_path: string;
+    }): Promise<{
+        version: 1;
+        workspace_id: string;
+        relative_path: string;
+        deletion_recorded: boolean;
+    }>;
+    /**
+     * Runs a `sdlc workspace doc` command against the current workspace's
+     * projection, under the same authority check and operation lock as `rm`
+     * and `commit`, so it never edits a projection another operation is using.
+     */
+    withDocumentProjection<T>(input: {
+        actor_workspace_id: string;
+        operation: string;
+        run: (projection_dir: string) => Promise<T>;
+    }): Promise<T>;
+    /**
+     * Writes a workspace commit's graph as a canonical portable graph file, the
+     * format `sdlc save --graph-file` reads. Defaults to the workspace head.
+     */
+    exportWorkspaceGraph(input: {
+        workspace_id: string;
+        output_path: string;
+        commit_id?: string;
+        /** `built` reads each pending claim at its built content. */
+        view?: LocalClaimView;
+    }): Promise<{
+        version: 1;
+        view: LocalClaimView;
+        workspace_id: string;
+        /** The commit read: for the built view, the head the view is taken of. */
+        commit_id: string;
+        /** The root of the written graph: for the built view, not the commit's. */
+        root_hash: string;
+        output_path: string;
+        marked_for_removal?: LocalBuiltView['marked_for_removal'];
+        left_out_orphans?: LocalBuiltView['left_out_orphans'];
+        validation?: LocalBuiltView['validation'];
+    }>;
+    /** The workspace's pending claims: merged under a gate and not landed. */
+    listPendingClaims(input: {
+        workspace_id: string;
+    }): LocalClaimList;
+    /**
+     * Each node's claim status in a view (`sdlc workspace status`), read from a
+     * coordinator's committed head and its pending claims. A plan workspace (one
+     * with no active plans under it) reads its coordinator, whose head is what
+     * the plans merged into. Source
+     * references are checked against `commit` in this checkout's repository.
+     * Read-only.
+     */
+    workspaceClaimStatus(input: {
+        workspace_id: string;
+        view?: ClaimStatusView;
+        commit?: string;
+        environments?: ClaimStatusEnvironment[];
+        cites_code?: string[];
+        nodes?: string[];
+        status?: ClaimStatus;
+        stale_only?: boolean;
+        behind_only?: boolean;
+    }): Promise<ClaimStatusResult & {
+        asked_workspace_id?: string;
+    }>;
+    /**
+     * The workspace a claim read answers from: a coordinator has active plans
+     * under it and reads itself; a plan reads the coordinator it merges into.
+     */
+    private claimReadWorkspace;
+    /**
+     * `sdlc variants`: each Variant Set in the committed graph with its gap and
+     * its sync entities' claim status (docs/specs/graph-variants.md, P3a), and
+     * with an environment, its members' forms by claim status. It reads the
+     * graph claim status reads, so a plan reads its coordinator. Read-only.
+     */
+    workspaceVariants(input: {
+        workspace_id: string;
+        /** The code the sync entities' references are checked against; main by default. */
+        commit?: string;
+        environments?: ClaimStatusEnvironment[];
+    }): Promise<VariantsReport & {
+        workspace_id: string;
+        asked_workspace_id?: string;
+    }>;
+    /**
+     * Claim freshness of the nodes and edges with evidence in the current
+     * workspace's projection (`sdlc workspace evidence status`): what sign
+     * writes, uncommitted edits included. Read-only.
+     */
+    workspaceEvidenceStatus(input: {
+        actor_workspace_id: string;
+        nodes?: string[];
+        edges?: string[];
+        behind_only?: boolean;
+    }): Promise<EvidenceStatusResult>;
+    /**
+     * `sdlc workspace evidence sign`: pins the selected entities' references to
+     * their current object hash in the projection, after verifying each code
+     * reference it signs at `commit` (default HEAD). Writes nothing when any
+     * does not hold. `changed` selects every node and edge the plan changed
+     * since its merge base with the coordinator. A signed entity outside a
+     * plan's task scope widens the scope to its meta. Commits nothing.
+     * `repository` is the Git repository whose code the references are
+     * verified in (default this workspace's own), so a graph that cites
+     * another repository signs that repository's references against its code.
+     */
+    signEvidence(input: {
+        actor_workspace_id: string;
+        nodes?: string[];
+        edges?: string[];
+        references?: string[];
+        changed?: boolean;
+        commit?: string;
+        repository?: string;
+        now?: Date;
+    }): Promise<EvidenceSignResult>;
+    /** signEvidence's work, for a caller already holding the workspace operation lock. */
+    private signEvidenceLocked;
+    /**
+     * `sdlc workspace evidence record`: writes each node's source references
+     * (already verified at `commit` by the caller) into the current workspace's
+     * projection, as sources.py record does, each replacing a reference of the
+     * same identity under any name the repository goes by. With `sign`, signs
+     * exactly those references under the same lock, and restores the node
+     * files when the sign fails or is refused, so nothing is left recorded
+     * unsigned. Refuses, before writing anything, a node with no file in the
+     * projection or holding legacy source_evidence. A node whose references
+     * would pass 100 is left out and returned under over_limit with the count
+     * it would have (sources.py record). Commits nothing.
+     */
+    recordSourceReferences(input: {
+        actor_workspace_id: string;
+        nodes: Record<string, SourceReferenceSpec[]>;
+        /** A full commit of `repository`, resolved by the caller. */
+        commit: string;
+        /** The Git repository whose code the references cite. */
+        repository: string;
+        sign?: boolean;
+        now?: Date;
+    }): Promise<{
+        workspace_id: string;
+        repository: string;
+        recorded: string[];
+        over_limit: Record<string, number>;
+        signed?: EvidenceSignResult;
+    }>;
+    /**
+     * The source references of a workspace's graph as built (`sdlc workspace
+     * evidence lookup|check|coverage`): its projection as it stands, so
+     * references just recorded count before a commit, with each pending claim
+     * at its built content, as sources.py index reads it with
+     * owners.built_claims. Only nodes with a pending claim come from the built
+     * view: one left out there as an orphan, under a parent never built, still
+     * names its files.
+     */
+    workspaceSourceIndex(input: {
+        workspace_id: string;
+    }): Promise<{
+        workspace_id: string;
+        entries: SourceEntry[];
+        nodes: number;
+    }>;
+    /**
+     * What changed repository files reach in a workspace's committed head graph
+     * (`sdlc workspace blast-radius`). Read-only: it answers from the head, so
+     * uncommitted edits never change the answer. The planned view composes the
+     * projection only to say when it differs (`projection_dirty` and a warning);
+     * the built view, read by readiness on every landing, skips that compose.
+     */
+    workspaceBlastRadius(input: {
+        workspace_id: string;
+        files: string[];
+        /** `built` reads each pending claim at its built content. */
+        view?: LocalClaimView;
+    }): Promise<BlastRadiusResult>;
+    /** `sdlc workspace find`: nodes ranked by the words they match (graph-read.ts). */
+    workspaceFind(input: {
+        workspace_id: string;
+        terms: string[];
+        types?: string[];
+        origin?: NodeOrigin;
+        limit?: number;
+        view?: LocalClaimView;
+    }): Promise<FindResult>;
+    /** `sdlc workspace show`: nodes and edges read compactly with their relations (graph-read.ts). */
+    workspaceShow(input: {
+        workspace_id: string;
+        ids: string[];
+        budget?: number | null;
+        view?: LocalClaimView;
+    }): Promise<ShowResult>;
+    /**
+     * The graph a read command answers from: the committed head, or the built
+     * view, as blast radius reads it, with what blast radius reports beside it.
+     */
+    private readGraphForView;
+    /** Whether a workspace's projection differs from its committed head graph, with the warning blast radius gives. */
+    private projectionDirty;
+    /**
+     * Compares the committed plans of a coordinator's active child workspaces
+     * pairwise. Read-only: it never locks, commits, or moves a workspace.
+     */
+    compareChildWorkspacePlans(input: {
+        coordinator_workspace_id: string;
+    }): Promise<LocalWorkspaceOverlapResult>;
+    inspectAuthority(): LocalWorkspaceAuthorityInspection;
+    resolverStatus(): Promise<LocalWorkspaceResolverStatus>;
+    configureResolver(input: {
+        actor_workspace_id: string;
+        configuration: unknown;
+    }): Promise<LocalWorkspaceResolverStatus>;
+    configureResolverFromFile(input: {
+        actor_workspace_id: string;
+        path: string;
+    }): Promise<LocalWorkspaceResolverStatus>;
+    clearResolver(input: {
+        actor_workspace_id: string;
+    }): Promise<LocalWorkspaceResolverStatus>;
+    loadResolver(input: {
+        actor_workspace_id: string;
+        allow_network_resolver: boolean;
+    }): Promise<LoadedLocalWorkspaceResolver>;
+    listRemotes(): Promise<LocalWorkspaceRemoteStatus[]>;
+    inspectRemote(name: string): Promise<LocalWorkspaceRemoteStatus>;
+    setRemote(input: {
+        actor_workspace_id: string;
+        remote: LocalWorkspaceRemoteConfiguration;
+    }): Promise<LocalWorkspaceRemoteStatus>;
+    removeRemote(input: {
+        actor_workspace_id: string;
+        name: string;
+    }): Promise<{
+        version: 1;
+        removed: boolean;
+    }>;
+    discoverRemote(input: {
+        actor_workspace_id: string;
+        name: string;
+        fetch_impl?: typeof fetch;
+        timeout_ms?: number;
+    }): Promise<LocalWorkspaceRemoteDiscovery>;
+    listRemoteTrackingRefs(name?: string): LocalRemoteTrackingRef[];
+    listLocalBranches(): LocalBranchStatus[];
+    createLocalBranchFromTrackingRef(input: {
+        actor_workspace_id: string;
+        local_ref: string;
+        remote_name: string;
+        source_ref: string;
+    }): Promise<LocalBranchCreationResult>;
+    selectLocalBranch(input: {
+        actor_workspace_id: string;
+    }): Promise<LocalBranchSelectionResult>;
+    integrateBranchUpstream(input: {
+        actor_workspace_id: string;
+        conflict_resolver?: LocalConflictResolver;
+        resolution_budget?: LocalConflictResolutionBudget;
+        allow_network_resolver?: boolean;
+    }): Promise<LocalUpstreamIntegrationResult>;
+    listBranchIntegrationAttempts(local_ref?: string): import("./workspace-history-types.js").LocalBranchIntegrationAttempt[];
+    listBranchIntegrationResolutionAttempts(attempt_id: string): import("./workspace-history-types.js").LocalBranchIntegrationResolutionAttempt[];
+    listBranchIntegrationRevertAttempts(local_ref?: string): import("./workspace-history-types.js").LocalBranchIntegrationRevertAttempt[];
+    inspectBranchUpstream(input: {
+        actor_workspace_id: string;
+    }): Promise<LocalUpstreamIntegrationStatus>;
+    revertBranchUpstream(input: {
+        actor_workspace_id: string;
+        branch_integration_attempt_id: string;
+        message?: string;
+    }): Promise<LocalUpstreamRevertResult>;
+    fetchRemote(input: {
+        actor_workspace_id: string;
+        name: string;
+        source_ref: string;
+        fetch_impl?: typeof fetch;
+        timeout_ms?: number;
+    }): Promise<LocalRemoteFetchResult>;
+    listRemotePushJournals(name?: string): LocalRemotePushJournal[];
+    listRemoteTopicJournals(name?: string): LocalRemoteTopicJournal[];
+    listRemotePullRequestJournals(name?: string): LocalRemotePullRequestJournal[];
+    planPortableHistory(input: {
+        actor_workspace_id: string;
+        local_commit_id?: string;
+    }): Promise<LocalPortableHistoryPlan>;
+    convertPortableHistory(input: {
+        actor_workspace_id: string;
+        local_commit_id?: string;
+        identity_file?: unknown;
+        base_remote_name?: string;
+        base_source_ref?: string;
+    }): Promise<LocalPortableHistoryConversionResult>;
+    pushRemote(input: {
+        actor_workspace_id: string;
+        name: string;
+        destination_ref: string;
+        new_commit_id?: string;
+        fetch_impl?: typeof fetch;
+        timeout_ms?: number;
+    }): Promise<LocalRemotePushResult>;
+    publishRemoteTopic(input: {
+        actor_workspace_id: string;
+        name: string;
+        topic_ref: string;
+        target_ref: string;
+        new_commit_id?: string;
+        fetch_impl?: typeof fetch;
+        timeout_ms?: number;
+    }): Promise<LocalRemoteTopicResult>;
+    createRemotePullRequest(input: {
+        actor_workspace_id: string;
+        name: string;
+        source_ref: string;
+        target_ref: string;
+        title: string;
+        description?: string | null;
+        fetch_impl?: typeof fetch;
+        timeout_ms?: number;
+    }): Promise<LocalRemotePullRequestResult>;
+    getWorkspaceStatus(workspace_id: string): Promise<LocalWorkspaceProjectionStatus>;
+    commitCurrentProjection(input: {
+        actor_workspace_id: string;
+        message: string;
+        evidence_scope?: LocalSourceEvidenceScope;
+    }): Promise<LocalWorkspaceCommitResult>;
+    enqueueChildCommit(input: {
+        actor_workspace_id: string;
+        child_workspace_id: string;
+        child_commit_id?: string;
+        gate?: LocalGate;
+    }): Promise<LocalIntegrationQueueEntry>;
+    readBuiltView(input: {
+        coordinator_workspace_id: string;
+    }): Promise<LocalBuiltView>;
+    integrateNext(input: {
+        actor_workspace_id: string;
+        max_retries?: number;
+        conflict_resolver?: LocalConflictResolver;
+        resolution_budget?: LocalConflictResolutionBudget;
+        allow_network_resolver?: boolean;
+    }): Promise<LocalIntegrationRunResult>;
+    reconcileSource(input: {
+        actor_workspace_id: string;
+        source_workspace_id: string;
+        max_retries?: number;
+        conflict_resolver?: LocalConflictResolver;
+        resolution_budget?: LocalConflictResolutionBudget;
+        allow_network_resolver?: boolean;
+    }): Promise<LocalReconciliationResult>;
+    prepareHandoff(input: {
+        actor_workspace_id: string;
+        source_workspace_id: string;
+        max_retries?: number;
+        conflict_resolver?: LocalConflictResolver;
+        resolution_budget?: LocalConflictResolutionBudget;
+        allow_network_resolver?: boolean;
+    }): Promise<LocalHandoffPrepareRunResult>;
+    listHandoffs(actor_workspace_id: string): Promise<LocalHandoffRuntimeInspection[]>;
+    inspectHandoff(input: {
+        actor_workspace_id: string;
+        handoff_id: string;
+    }): Promise<LocalHandoffRuntimeInspection>;
+    applyHandoff(input: {
+        actor_workspace_id: string;
+        handoff_id: string;
+    }): Promise<LocalHandoffApplyRunResult>;
+    /**
+     * `sdlc workspace decision reopen`: reopens the Decision and, with
+     * `revive_workspace_id`, checks out a new plan workspace at `target_path`
+     * that starts at that closed candidate's last head and takes its place.
+     */
+    reopenDecision(input: {
+        decision_id: string;
+        reason: string;
+        revive_workspace_id?: string;
+        target_path?: string;
+    }): Promise<{
+        version: 1;
+        decision: LocalDecision;
+        workspace: LocalWorkspaceProjectionStatus | null;
+    }>;
+    /**
+     * `sdlc workspace pick`: copies chosen entities from another workspace's
+     * commit into the acting workspace as one commit with a receipt.
+     */
+    pickEntities(input: {
+        actor_workspace_id: string;
+        source_workspace_id: string;
+        source_commit_id?: string;
+        selection: LocalPickEntity[];
+        with_dependencies?: boolean;
+        dry_run?: boolean;
+        message?: string;
+    }): Promise<LocalWorkspacePickResult>;
+    /** The current workspace, authorized to run `sdlc workspace decision`. */
+    decisionActor(): Promise<LocalWorkspace>;
+    closeWorkspace(input: {
+        actor_workspace_id: string;
+        workspace_id: string;
+    }): Promise<LocalWorkspace>;
+    planPrune(input?: {
+        min_age_hours?: number;
+    }): Promise<LocalWorkspacePrunePlan>;
+    applyPrune(input: {
+        expected_plan_hash: string;
+        min_age_hours?: number;
+    }): Promise<LocalWorkspacePruneResult>;
+    recoverCurrentProjection(input: {
+        actor_workspace_id: string;
+        expected_head_commit_id: string;
+        expected_projection_root_hash?: string;
+        discard_unreadable_projection?: boolean;
+    }): Promise<LocalWorkspaceProjectionRecoveryResult>;
+    private requireWorkspace;
+    private currentActiveWorkspace;
+    private commitRoot;
+    private readCommitGraph;
+    private assertProjectionClean;
+}
+//# sourceMappingURL=workspace-runtime.d.ts.map