@software-dlc/cli 0.157.2

package/dist/local/workspace-store.js

@@ -0,0 +1,831 @@
+import { randomUUID } from 'node:crypto';
+import { isAbsolute, join, resolve } from 'node:path';
+import { openLocalWorkspaceStoreDatabase } from './workspace-store-database.js';
+import { LocalWorkspaceHistoryStore } from './workspace-history-store.js';
+import { LocalPortableCommitStore } from './portable-commit-store.js';
+import { parsePortableCommit } from './portable-commit.js';
+import { LocalRemoteTrackingStore } from './workspace-remote-fetch.js';
+import { LocalRemotePushJournalStore } from './workspace-remote-push.js';
+import { LocalRemoteTopicJournalStore } from './workspace-remote-topic-journal.js';
+import { LocalRemotePullRequestJournalStore } from './workspace-remote-pull-request-journal.js';
+import { LocalDecisionStore } from './workspace-decision-store.js';
+import { LocalPickStore } from './workspace-pick-store.js';
+import { LocalBuiltContentStore } from './workspace-built-content.js';
+import { LocalVocabularyAdmissionStore } from './workspace-admission.js';
+import { LocalOrgStore } from './local-org-store.js';
+import { requireMutableLocalBranchRef } from './git-ref-authority.js';
+import { assertTaskScopeSubset, local_workspace_task_scope_schema } from './workspace-scope.js';
+function requireValue(value, label) {
+    const normalized_value = value.trim();
+    if (normalized_value.length === 0) {
+        throw new Error(`${label} must not be empty.`);
+    }
+    return normalized_value;
+}
+function requireAbsolutePath(path, label) {
+    if (!isAbsolute(path)) {
+        throw new Error(`${label} must be an absolute path.`);
+    }
+    return resolve(path);
+}
+function assertPersistedRefAuthority(database) {
+    const rows = database
+        .prepare(`
+        select ref_name from local_workspace_ref
+        union
+        select attached_ref as ref_name from local_workspace
+        where attached_ref is not null
+      `)
+        .all();
+    for (const row of rows) {
+        requireMutableLocalBranchRef(row.ref_name, 'Persisted workspace ref');
+    }
+    const associations = database
+        .prepare('select local_ref, git_ref from local_branch_association')
+        .all();
+    for (const association of associations) {
+        requireMutableLocalBranchRef(association.local_ref, 'Persisted local SDLC branch ref');
+        requireMutableLocalBranchRef(association.git_ref, 'Persisted associated Git branch ref');
+    }
+}
+function backfillLocalBranchAssociations(database) {
+    const now = new Date().toISOString();
+    database
+        .prepare(`
+        insert into local_branch_association (
+          local_ref, git_ref, upstream_remote_name, upstream_source_ref,
+          upstream_tracking_ref, base_portable_commit_id, created_at, updated_at
+        )
+        select ref_name, ref_name, null, null, null, null, ?, ?
+        from local_workspace_ref
+        where not exists (
+          select 1 from local_branch_association
+          where local_branch_association.local_ref = local_workspace_ref.ref_name
+        )
+        and not exists (
+          select 1 from local_branch_association
+          where local_branch_association.git_ref = local_workspace_ref.ref_name
+        )
+      `)
+        .run(now, now);
+}
+export class LocalWorkspaceStore {
+    state_dir;
+    database_path;
+    repository;
+    history;
+    portable_commits;
+    remote_tracking;
+    remote_push;
+    remote_topic;
+    remote_pull_request;
+    decisions;
+    picks;
+    built_content;
+    admissions;
+    org;
+    database;
+    constructor(input) {
+        this.state_dir = input.state_dir;
+        this.database_path = join(input.state_dir, 'repository.sqlite');
+        this.database = input.database;
+        this.repository = input.repository;
+        this.history = new LocalWorkspaceHistoryStore(input.database);
+        this.portable_commits = new LocalPortableCommitStore(input.database, this.history);
+        this.remote_tracking = new LocalRemoteTrackingStore(input.database, this.portable_commits);
+        this.remote_push = new LocalRemotePushJournalStore(input.database);
+        this.remote_topic = new LocalRemoteTopicJournalStore(input.database);
+        this.remote_pull_request = new LocalRemotePullRequestJournalStore(input.database);
+        this.picks = new LocalPickStore(input.database);
+        this.built_content = new LocalBuiltContentStore(input.database);
+        this.admissions = new LocalVocabularyAdmissionStore(input.database);
+        this.org = new LocalOrgStore(input.database);
+        this.decisions = new LocalDecisionStore(input.database, {
+            picks: this.picks,
+            isAncestor: (ancestor_id, descendant_id) => this.history.isAncestor(ancestor_id, descendant_id)
+        });
+    }
+    static async open(input) {
+        const state_dir = requireAbsolutePath(input.state_dir, 'State directory');
+        const git_common_dir = requireAbsolutePath(input.git_common_dir, 'Git common directory');
+        const database = await openLocalWorkspaceStoreDatabase(state_dir);
+        const proposed_repository = {
+            repository_id: randomUUID(),
+            git_common_dir,
+            schema_version: 1,
+            created_at: new Date().toISOString()
+        };
+        database
+            .prepare(`
+          insert into local_repository (
+            singleton, repository_id, git_common_dir, schema_version,
+            created_at
+          ) values (1, ?, ?, ?, ?)
+          on conflict(singleton) do nothing
+        `)
+            .run(proposed_repository.repository_id, proposed_repository.git_common_dir, proposed_repository.schema_version, proposed_repository.created_at);
+        const repository = database
+            .prepare('select * from local_repository where singleton = 1')
+            .get();
+        if (input.expected_repository_id &&
+            repository.repository_id !== input.expected_repository_id) {
+            database.close();
+            throw new Error('Logical graph repository identity does not match.');
+        }
+        if (repository.git_common_dir !== git_common_dir &&
+            !input.expected_repository_id) {
+            database.close();
+            throw new Error('Local workspace store belongs to another Git repository; cross-repository access requires its exact graph repository id.');
+        }
+        backfillLocalBranchAssociations(database);
+        try {
+            assertPersistedRefAuthority(database);
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+        try {
+            return new LocalWorkspaceStore({ state_dir, database, repository });
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+    }
+    close() {
+        this.database.close();
+    }
+    checkpoint() {
+        this.database.exec('pragma wal_checkpoint(TRUNCATE)');
+    }
+    runTransaction(operation) {
+        this.database.exec('begin immediate');
+        try {
+            const result = operation();
+            this.database.exec('commit');
+            return result;
+        }
+        catch (error) {
+            this.database.exec('rollback');
+            throw error;
+        }
+    }
+    getSourceRepositoryBinding(git_common_dir) {
+        const path = requireAbsolutePath(git_common_dir, 'Git common directory');
+        return (this.database
+            .prepare('select * from local_source_repository_binding where git_common_dir = ?')
+            .get(path) ?? null);
+    }
+    /** A binding of the source association in this graph, from any repository. */
+    getSourceAssociationBinding(source_repository_association_id) {
+        return (this.database
+            .prepare(`select * from local_source_repository_binding
+           where repository_id = ? and source_repository_association_id = ?
+           limit 1`)
+            .get(this.repository.repository_id, source_repository_association_id) ?? null);
+    }
+    bindSourceRepository(input) {
+        const git_common_dir = requireAbsolutePath(input.git_common_dir, 'Git common directory');
+        const association_id = requireValue(input.source_repository_association_id, 'Source repository association id');
+        const remote_name = requireValue(input.remote_name, 'Git remote name');
+        const remote_url = requireValue(input.remote_url, 'Git remote URL');
+        const remote_identity = requireValue(input.remote_identity, 'Git remote identity');
+        return this.runTransaction(() => {
+            const existing = this.getSourceRepositoryBinding(git_common_dir);
+            if (existing) {
+                if (existing.source_repository_association_id !== association_id ||
+                    existing.remote_name !== remote_name ||
+                    existing.remote_identity !== remote_identity) {
+                    throw new Error('Current Git repository already has a different source-association binding.');
+                }
+                return existing;
+            }
+            const association_binding = this.getSourceAssociationBinding(association_id);
+            if (association_binding &&
+                association_binding.remote_identity !== remote_identity) {
+                throw new Error('Source association is already bound to a different Git repository identity.');
+            }
+            const now = new Date().toISOString();
+            this.database
+                .prepare(`insert into local_source_repository_binding (
+            git_common_dir, repository_id, source_repository_association_id,
+            remote_name, remote_url, remote_identity, created_at, updated_at
+          ) values (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(git_common_dir, this.repository.repository_id, association_id, remote_name, remote_url, remote_identity, now, now);
+            return this.getSourceRepositoryBinding(git_common_dir);
+        });
+    }
+    /**
+     * Moves a repository's binding from `expected_remote_name` to another
+     * remote, keeping its association. Returns null, changing nothing, when the
+     * binding is gone or moved, or another repository binds the association
+     * under a different identity.
+     */
+    rebindSourceRepositoryRemote(input) {
+        const git_common_dir = requireAbsolutePath(input.git_common_dir, 'Git common directory');
+        const remote_name = requireValue(input.remote_name, 'Git remote name');
+        const remote_url = requireValue(input.remote_url, 'Git remote URL');
+        const remote_identity = requireValue(input.remote_identity, 'Git remote identity');
+        return this.runTransaction(() => {
+            const existing = this.getSourceRepositoryBinding(git_common_dir);
+            if (!existing || existing.remote_name !== input.expected_remote_name) {
+                return null;
+            }
+            const held = this.database
+                .prepare(`select 1 from local_source_repository_binding
+           where repository_id = ? and source_repository_association_id = ?
+             and git_common_dir <> ? and remote_identity <> ?
+           limit 1`)
+                .get(this.repository.repository_id, existing.source_repository_association_id, git_common_dir, remote_identity);
+            if (held)
+                return null;
+            this.database
+                .prepare(`update local_source_repository_binding
+           set remote_name = ?, remote_url = ?, remote_identity = ?,
+             moved_from_remote_identity = ?, updated_at = ?
+           where git_common_dir = ?`)
+                .run(remote_name, remote_url, remote_identity, existing.remote_identity, new Date().toISOString(), git_common_dir);
+            return this.getSourceRepositoryBinding(git_common_dir);
+        });
+    }
+    unbindSourceRepository(input) {
+        const git_common_dir = requireAbsolutePath(input.git_common_dir, 'Git common directory');
+        return this.runTransaction(() => {
+            const binding = this.getSourceRepositoryBinding(git_common_dir);
+            if (!binding)
+                throw new Error('Source repository binding was not found.');
+            if (binding.source_repository_association_id !==
+                input.expected_source_repository_association_id) {
+                throw new Error('Source repository binding identity changed.');
+            }
+            const row = this.database
+                .prepare(`select count(*) as count from local_workspace
+           where git_common_dir = ? and status = 'active'`)
+                .get(git_common_dir);
+            if (row.count > 0) {
+                return { removed: false, binding, active_workspace_count: row.count };
+            }
+            this.database
+                .prepare(`delete from local_source_repository_binding
+           where git_common_dir = ? and source_repository_association_id = ?`)
+                .run(git_common_dir, input.expected_source_repository_association_id);
+            return { removed: true, binding, active_workspace_count: 0 };
+        });
+    }
+    getWorkspaceCommitSourceContext(commit_id) {
+        const row = this.database
+            .prepare('select * from local_workspace_commit_source_context where commit_id = ?')
+            .get(commit_id);
+        if (!row)
+            return null;
+        const parsed = JSON.parse(row.evidence_scope_json);
+        return {
+            commit_id: row.commit_id,
+            source_repository_association_id: row.source_repository_association_id,
+            remote_identity: row.remote_identity,
+            git_ref: row.git_ref,
+            git_head: row.git_head,
+            evidence_scope: parsed,
+            created_at: row.created_at
+        };
+    }
+    getWorkspace(workspace_id) {
+        return (this.database
+            .prepare('select * from local_workspace where id = ?')
+            .get(workspace_id) ?? null);
+    }
+    getWorkspaceByGitWorktreePath(git_worktree_path) {
+        const normalized_path = requireAbsolutePath(git_worktree_path, 'Git worktree path');
+        return (this.database
+            .prepare('select * from local_workspace where git_worktree_path = ?')
+            .get(normalized_path) ?? null);
+    }
+    listWorkspaces() {
+        return this.database
+            .prepare('select * from local_workspace order by created_at asc, id asc')
+            .all();
+    }
+    listChildWorkspaces(source_workspace_id) {
+        return this.database
+            .prepare(`
+          select * from local_workspace
+          where source_workspace_id = ?
+          order by created_at asc, id asc
+        `)
+            .all(source_workspace_id);
+    }
+    listRetainedGraphRootHashes() {
+        const direct_roots = this.database
+            .prepare(`
+          select root_hash from local_workspace_commit
+          union select base_root_hash from local_integration_attempt
+          union select coordinator_root_hash from local_integration_attempt
+          union select child_root_hash from local_integration_attempt
+          union select candidate_root_hash from local_resolution_attempt
+            where candidate_root_hash is not null
+          union select base_root_hash from local_reconciliation_attempt
+          union select child_root_hash from local_reconciliation_attempt
+          union select source_root_hash from local_reconciliation_attempt
+          union select candidate_root_hash
+            from local_reconciliation_resolution_attempt
+            where candidate_root_hash is not null
+          union select root_hash from local_governance_graph
+        `)
+            .all();
+        const retained_commit_or_root_ids = this.database
+            .prepare(`
+          select fork_sdlc_commit_id as id from local_workspace
+          union select head_sdlc_commit_id from local_workspace
+          union select head_commit_id from local_workspace_ref
+        `)
+            .all();
+        const local_commit_roots = new Map(this.database
+            .prepare('select id, root_hash from local_workspace_commit')
+            .all().map((commit) => [commit.id, commit.root_hash]));
+        const portable_commits = this.database
+            .prepare('select commit_json from portable_commit order by id')
+            .all().map((row) => parsePortableCommit(JSON.parse(row.commit_json)));
+        const portable_commit_roots = new Map(portable_commits.map((commit) => [commit.id, commit.graph_root]));
+        const retained_workspace_roots = retained_commit_or_root_ids.map(({ id }) => local_commit_roots.get(id) ?? portable_commit_roots.get(id) ?? id);
+        return [
+            ...direct_roots.map((row) => row.root_hash),
+            ...portable_commits.map((commit) => commit.graph_root),
+            ...retained_workspace_roots
+        ]
+            .filter((root_hash) => /^sha256:[0-9a-f]{64}$/.test(root_hash))
+            .filter((root_hash, index, values) => values.indexOf(root_hash) === index)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    getWorkspaceTaskScope(workspace_id) {
+        const row = this.database
+            .prepare('select scope_json from local_workspace_task_scope where workspace_id = ?')
+            .get(workspace_id);
+        if (!row)
+            return null;
+        return local_workspace_task_scope_schema.parse(JSON.parse(row.scope_json));
+    }
+    /** Records that the next projection commit deletes this entity on purpose. */
+    recordWorkspaceDeletion(input) {
+        this.requireActiveWorkspace(input.workspace_id);
+        this.database
+            .prepare(`
+          insert into local_workspace_deletion_intent (
+            workspace_id, entity_kind, entity_id, recorded_at
+          ) values (?, ?, ?, ?)
+          on conflict (workspace_id, entity_kind, entity_id) do nothing
+        `)
+            .run(input.workspace_id, input.entity_kind, input.entity_id, new Date().toISOString());
+    }
+    listWorkspaceDeletions(workspace_id) {
+        return this.database
+            .prepare(`
+          select entity_kind, entity_id from local_workspace_deletion_intent
+          where workspace_id = ?
+          order by entity_kind asc, entity_id asc
+        `)
+            .all(workspace_id);
+    }
+    clearWorkspaceDeletions(workspace_id) {
+        this.database
+            .prepare('delete from local_workspace_deletion_intent where workspace_id = ?')
+            .run(workspace_id);
+    }
+    getRef(ref_name) {
+        const local_ref = requireMutableLocalBranchRef(ref_name, 'Workspace ref lookup');
+        return (this.database
+            .prepare('select * from local_workspace_ref where ref_name = ?')
+            .get(local_ref) ?? null);
+    }
+    getBranchAssociation(local_ref) {
+        const ref = requireMutableLocalBranchRef(local_ref, 'Local SDLC branch ref');
+        return (this.database
+            .prepare('select * from local_branch_association where local_ref = ?')
+            .get(ref) ?? null);
+    }
+    getBranchAssociationByGitRef(git_ref) {
+        const ref = requireMutableLocalBranchRef(git_ref, 'Associated Git branch ref');
+        return (this.database
+            .prepare('select * from local_branch_association where git_ref = ?')
+            .get(ref) ?? null);
+    }
+    listBranchAssociations() {
+        return this.database
+            .prepare('select * from local_branch_association order by local_ref')
+            .all();
+    }
+    createBranchFromTrackingRef(input) {
+        const local_ref = requireMutableLocalBranchRef(input.local_ref, 'Local SDLC branch ref');
+        const git_ref = requireMutableLocalBranchRef(input.git_ref, 'Associated Git branch ref');
+        return this.runTransaction(() => {
+            const workspace = this.requireActiveWorkspace(input.actor_workspace_id);
+            if (workspace.actor_kind !== 'human') {
+                throw new Error('Local branch creation is owned by the active human workspace.');
+            }
+            if (workspace.head_sdlc_commit_id !==
+                input.expected_workspace_head_commit_id) {
+                throw new Error('Workspace head is stale.');
+            }
+            const active_child = this.database
+                .prepare(`select id from local_workspace where source_workspace_id = ? and status = 'active' limit 1`)
+                .get(workspace.id);
+            if (active_child)
+                throw new Error('Close active child workspaces before changing branches.');
+            if (this.getRef(local_ref))
+                throw new Error(`Local SDLC branch ${local_ref} already exists.`);
+            const existing_git = this.getBranchAssociationByGitRef(git_ref);
+            if (existing_git)
+                throw new Error(`Git branch ${git_ref} is already associated with ${existing_git.local_ref}.`);
+            const tracking = this.database
+                .prepare(`select * from remote_tracking_ref where remote_name = ? and source_ref = ? and tracking_ref = ?`)
+                .get(input.remote_name, input.source_ref, input.tracking_ref);
+            if (!tracking ||
+                tracking.commit_id !== input.expected_tracking_commit_id) {
+                throw new Error('Remote-tracking ref is missing or stale. Fetch it again.');
+            }
+            const portable = this.portable_commits.getCommit(input.expected_tracking_commit_id);
+            if (!portable)
+                throw new Error('Remote-tracking commit is unavailable locally.');
+            const now = new Date().toISOString();
+            this.database
+                .prepare(`insert into local_workspace_ref (ref_name, head_commit_id, created_at, updated_at) values (?, ?, ?, ?)`)
+                .run(local_ref, portable.id, now, now);
+            this.database
+                .prepare(`insert into local_branch_association (
+          local_ref, git_ref, upstream_remote_name, upstream_source_ref,
+          upstream_tracking_ref, base_portable_commit_id, created_at, updated_at
+        ) values (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(local_ref, git_ref, input.remote_name, input.source_ref, input.tracking_ref, portable.id, now, now);
+            this.database
+                .prepare(`update local_workspace set fork_git_commit_id = ?, fork_sdlc_commit_id = ?,
+          head_sdlc_commit_id = ?, attached_ref = ?, updated_at = ? where id = ?`)
+                .run(requireValue(input.git_head_commit_id, 'Git head commit id'), portable.id, portable.id, local_ref, now, workspace.id);
+            const association = this.getBranchAssociation(local_ref);
+            if (!association)
+                throw new Error('Local branch association was not persisted.');
+            return {
+                workspace: this.requireActiveWorkspace(workspace.id),
+                association
+            };
+        });
+    }
+    selectBranchForWorkspace(input) {
+        const local_ref = requireMutableLocalBranchRef(input.local_ref, 'Local SDLC branch ref');
+        const git_ref = requireMutableLocalBranchRef(input.git_ref, 'Associated Git branch ref');
+        return this.runTransaction(() => {
+            const workspace = this.requireActiveWorkspace(input.actor_workspace_id);
+            if (workspace.actor_kind !== 'human') {
+                throw new Error('Local branch selection is owned by the active human workspace.');
+            }
+            if (workspace.head_sdlc_commit_id !==
+                input.expected_workspace_head_commit_id) {
+                throw new Error('Workspace head is stale.');
+            }
+            const active_child = this.database
+                .prepare(`select id from local_workspace where source_workspace_id = ? and status = 'active' limit 1`)
+                .get(workspace.id);
+            if (active_child)
+                throw new Error('Close active child workspaces before changing branches.');
+            const association = this.getBranchAssociation(local_ref);
+            if (!association)
+                throw new Error(`Local SDLC branch ${local_ref} does not exist.`);
+            if (association.git_ref !== git_ref) {
+                throw new Error(`Git branch ${git_ref} is not associated with ${local_ref}.`);
+            }
+            const ref = this.getRef(local_ref);
+            if (!ref)
+                throw new Error(`Local SDLC branch ${local_ref} is missing.`);
+            const attached_elsewhere = this.database
+                .prepare(`select id from local_workspace
+         where attached_ref = ? and status = 'active' and id <> ? limit 1`)
+                .get(local_ref, workspace.id);
+            if (attached_elsewhere) {
+                throw new Error(`Local SDLC branch ${local_ref} is already attached to another active workspace.`);
+            }
+            const now = new Date().toISOString();
+            this.database
+                .prepare(`update local_workspace set fork_git_commit_id = ?, fork_sdlc_commit_id = ?,
+          head_sdlc_commit_id = ?, attached_ref = ?, updated_at = ? where id = ?`)
+                .run(requireValue(input.git_head_commit_id, 'Git head commit id'), ref.head_commit_id, ref.head_commit_id, local_ref, now, workspace.id);
+            return {
+                workspace: this.requireActiveWorkspace(workspace.id),
+                association
+            };
+        });
+    }
+    registerForegroundWorkspace(input) {
+        const git_worktree_path = requireAbsolutePath(input.git_worktree_path, 'Git worktree path');
+        const git_dir = requireAbsolutePath(input.git_dir, 'Git directory');
+        const git_head_commit_id = requireValue(input.git_head_commit_id, 'Git head commit id');
+        const sdlc_head_commit_id = requireValue(input.sdlc_head_commit_id, 'SDLC head commit id');
+        const attached_ref = input.attached_ref
+            ? requireMutableLocalBranchRef(input.attached_ref, 'Attached workspace ref')
+            : null;
+        return this.runTransaction(() => {
+            const now = new Date().toISOString();
+            if (attached_ref) {
+                const existing_ref = this.getRef(attached_ref);
+                if (existing_ref &&
+                    existing_ref.head_commit_id !== sdlc_head_commit_id) {
+                    throw new Error('Attached ref head does not match the workspace SDLC head.');
+                }
+                if (!existing_ref) {
+                    this.database
+                        .prepare(`
+                insert into local_workspace_ref (
+                  ref_name, head_commit_id, created_at, updated_at
+                ) values (?, ?, ?, ?)
+              `)
+                        .run(attached_ref, sdlc_head_commit_id, now, now);
+                }
+                const existing_association = this.getBranchAssociation(attached_ref);
+                if (!existing_association) {
+                    this.database
+                        .prepare(`insert into local_branch_association (
+              local_ref, git_ref, upstream_remote_name, upstream_source_ref,
+              upstream_tracking_ref, base_portable_commit_id, created_at, updated_at
+            ) values (?, ?, null, null, null, null, ?, ?)`)
+                        .run(attached_ref, attached_ref, now, now);
+                }
+            }
+            const workspace = {
+                id: randomUUID(),
+                repository_id: this.repository.repository_id,
+                source_workspace_id: null,
+                actor_kind: input.actor_kind,
+                git_worktree_path,
+                git_dir,
+                git_common_dir: requireAbsolutePath(input.git_common_dir ?? this.repository.git_common_dir, 'Git common directory'),
+                fork_git_commit_id: git_head_commit_id,
+                fork_sdlc_commit_id: sdlc_head_commit_id,
+                head_sdlc_commit_id: sdlc_head_commit_id,
+                attached_ref,
+                status: 'active',
+                created_at: now,
+                updated_at: now
+            };
+            this.insertWorkspace(workspace);
+            return workspace;
+        });
+    }
+    forkWorkspace(input) {
+        return this.runTransaction(() => {
+            const source_workspace = this.requireActiveWorkspace(input.actor_workspace_id);
+            if (source_workspace.head_sdlc_commit_id !==
+                input.expected_source_sdlc_head_commit_id) {
+                throw new Error('Source workspace head is stale.');
+            }
+            const task_scope = local_workspace_task_scope_schema.parse(input.task_scope);
+            assertTaskScopeSubset({
+                parent_scope: this.getWorkspaceTaskScope(source_workspace.id),
+                child_scope: task_scope
+            });
+            const now = new Date().toISOString();
+            const workspace = {
+                id: randomUUID(),
+                repository_id: this.repository.repository_id,
+                source_workspace_id: source_workspace.id,
+                actor_kind: input.actor_kind ?? 'ai',
+                git_worktree_path: requireAbsolutePath(input.git_worktree_path, 'Git worktree path'),
+                git_dir: requireAbsolutePath(input.git_dir, 'Git directory'),
+                git_common_dir: requireAbsolutePath(input.git_common_dir ?? this.repository.git_common_dir, 'Git common directory'),
+                fork_git_commit_id: requireValue(input.git_head_commit_id, 'Git head commit id'),
+                fork_sdlc_commit_id: source_workspace.head_sdlc_commit_id,
+                head_sdlc_commit_id: source_workspace.head_sdlc_commit_id,
+                attached_ref: null,
+                status: 'active',
+                created_at: now,
+                updated_at: now
+            };
+            this.insertWorkspace(workspace);
+            this.database
+                .prepare(`
+            insert into local_workspace_task_scope (
+              workspace_id, scope_json, created_at
+            ) values (?, ?, ?)
+          `)
+                .run(workspace.id, JSON.stringify(task_scope), now);
+            return workspace;
+        });
+    }
+    /**
+     * Reopens a Decision (graph-variants.md, Reopen) and, with `revive`, rebinds
+     * a closed candidate to a new active workspace in the same transaction.
+     * `closed` stays terminal: the new workspace is a sibling plan of the
+     * coordinator that starts at the closed candidate's last head and keeps its
+     * fork commit and task scope, so it integrates the same changes. This is the
+     * only way to fork from a closed workspace; forkWorkspace still refuses.
+     */
+    reopenDecision(input) {
+        return this.runTransaction(() => {
+            let revived = null;
+            if (input.revive) {
+                const closed = this.getWorkspace(input.revive.workspace_id);
+                if (!closed ||
+                    closed.status !== 'closed' ||
+                    !closed.source_workspace_id) {
+                    throw new Error(`Workspace ${input.revive.workspace_id} is not a closed plan workspace.`);
+                }
+                const coordinator = this.requireActiveWorkspace(closed.source_workspace_id);
+                const now = new Date().toISOString();
+                revived = {
+                    id: input.revive.id ?? randomUUID(),
+                    repository_id: this.repository.repository_id,
+                    source_workspace_id: coordinator.id,
+                    actor_kind: input.revive.actor_kind ?? closed.actor_kind,
+                    git_worktree_path: requireAbsolutePath(input.revive.git_worktree_path, 'Git worktree path'),
+                    git_dir: requireAbsolutePath(input.revive.git_dir, 'Git directory'),
+                    git_common_dir: requireAbsolutePath(input.revive.git_common_dir ?? this.repository.git_common_dir, 'Git common directory'),
+                    fork_git_commit_id: requireValue(input.revive.git_head_commit_id, 'Git head commit id'),
+                    fork_sdlc_commit_id: closed.fork_sdlc_commit_id,
+                    head_sdlc_commit_id: closed.head_sdlc_commit_id,
+                    attached_ref: null,
+                    status: 'active',
+                    created_at: now,
+                    updated_at: now
+                };
+                this.insertWorkspace(revived);
+                const task_scope = this.getWorkspaceTaskScope(closed.id);
+                if (task_scope) {
+                    this.database
+                        .prepare(`insert into local_workspace_task_scope (
+                 workspace_id, scope_json, created_at
+               ) values (?, ?, ?)`)
+                        .run(revived.id, JSON.stringify(task_scope), now);
+                }
+            }
+            const decision = this.decisions.applyReopen({
+                decision_id: input.decision_id,
+                reason: input.reason,
+                revived: revived
+                    ? {
+                        from_workspace_id: input.revive.workspace_id,
+                        workspace_id: revived.id
+                    }
+                    : null
+            });
+            return { decision, workspace: revived };
+        });
+    }
+    advanceWorkspaceHead(input) {
+        if (input.actor_workspace_id !== input.workspace_id) {
+            throw new Error('A workspace may advance only its own head outside explicit Handoff.');
+        }
+        return this.runTransaction(() => {
+            const workspace = this.requireActiveWorkspace(input.workspace_id);
+            if (workspace.head_sdlc_commit_id !== input.expected_head_commit_id) {
+                return {
+                    status: 'stale',
+                    current_head_commit_id: workspace.head_sdlc_commit_id
+                };
+            }
+            const next_head_commit_id = requireValue(input.next_head_commit_id, 'Next head commit id');
+            const now = new Date().toISOString();
+            if (workspace.attached_ref) {
+                const current_ref = this.getRef(workspace.attached_ref);
+                if (!current_ref ||
+                    current_ref.head_commit_id !== workspace.head_sdlc_commit_id) {
+                    throw new Error('Attached ref and workspace head disagree; refusing to advance.');
+                }
+                this.database
+                    .prepare(`
+              update local_workspace_ref
+              set head_commit_id = ?, updated_at = ?
+              where ref_name = ? and head_commit_id = ?
+            `)
+                    .run(next_head_commit_id, now, workspace.attached_ref, workspace.head_sdlc_commit_id);
+            }
+            this.database
+                .prepare(`
+            update local_workspace
+            set head_sdlc_commit_id = ?, updated_at = ?
+            where id = ? and head_sdlc_commit_id = ?
+          `)
+                .run(next_head_commit_id, now, workspace.id, workspace.head_sdlc_commit_id);
+            return {
+                status: 'advanced',
+                workspace: this.requireActiveWorkspace(workspace.id)
+            };
+        });
+    }
+    /**
+     * Replaces a child workspace's task scope. The new scope must stay within
+     * its source's scope and keep every active child's scope within itself;
+     * the caller checks that it still covers the workspace's own changes.
+     */
+    replaceWorkspaceTaskScope(input) {
+        return this.runTransaction(() => {
+            const actor = this.requireActiveWorkspace(input.actor_workspace_id);
+            const workspace = this.requireActiveWorkspace(input.workspace_id);
+            if (actor.id !== workspace.id &&
+                workspace.source_workspace_id !== actor.id) {
+                throw new Error('Only a workspace or its direct source may change its task scope.');
+            }
+            if (!workspace.source_workspace_id) {
+                throw new Error('A root workspace has no task scope.');
+            }
+            if (workspace.head_sdlc_commit_id !== input.expected_head_commit_id) {
+                throw new Error('Workspace head is stale.');
+            }
+            const task_scope = local_workspace_task_scope_schema.parse(input.task_scope);
+            assertTaskScopeSubset({
+                parent_scope: this.getWorkspaceTaskScope(workspace.source_workspace_id),
+                child_scope: task_scope
+            });
+            for (const child of this.listChildWorkspaces(workspace.id)) {
+                const child_scope = this.getWorkspaceTaskScope(child.id);
+                if (child.status !== 'active' || !child_scope)
+                    continue;
+                assertTaskScopeSubset({ parent_scope: task_scope, child_scope });
+            }
+            const previous_task_scope = this.getWorkspaceTaskScope(workspace.id);
+            this.database
+                .prepare(`
+            insert into local_workspace_task_scope (
+              workspace_id, scope_json, created_at
+            ) values (?, ?, ?)
+            on conflict (workspace_id) do update set
+              scope_json = excluded.scope_json
+          `)
+                .run(workspace.id, JSON.stringify(task_scope), new Date().toISOString());
+            return { previous_task_scope, task_scope };
+        });
+    }
+    closeWorkspace(input) {
+        return this.runTransaction(() => {
+            const actor = this.requireActiveWorkspace(input.actor_workspace_id);
+            const workspace = this.requireActiveWorkspace(input.workspace_id);
+            if (actor.id !== workspace.id &&
+                workspace.source_workspace_id !== actor.id) {
+                throw new Error('Only a workspace or its direct source may close the workspace.');
+            }
+            if (workspace.head_sdlc_commit_id !== input.expected_head_commit_id) {
+                throw new Error('Workspace head is stale.');
+            }
+            const active_child = this.database
+                .prepare(`
+            select id from local_workspace
+            where source_workspace_id = ? and status = 'active'
+            limit 1
+          `)
+                .get(workspace.id);
+            if (active_child) {
+                throw new Error('Close active child workspaces first.');
+            }
+            const now = new Date().toISOString();
+            this.database
+                .prepare(`
+            update local_workspace set status = 'closed', updated_at = ?
+            where id = ? and status = 'active' and head_sdlc_commit_id = ?
+          `)
+                .run(now, workspace.id, input.expected_head_commit_id);
+            const closed = this.getWorkspace(workspace.id);
+            if (!closed || closed.status !== 'closed') {
+                throw new Error('Workspace close did not complete.');
+            }
+            return closed;
+        });
+    }
+    removeClosedWorkspaceRegistration(input) {
+        this.runTransaction(() => {
+            const workspace = this.getWorkspace(input.workspace_id);
+            if (!workspace ||
+                workspace.status !== 'closed' ||
+                workspace.source_workspace_id !== input.source_workspace_id ||
+                workspace.git_worktree_path !==
+                    requireAbsolutePath(input.git_worktree_path, 'Git worktree path')) {
+                throw new Error('Closed workspace registration does not match attachment rollback.');
+            }
+            this.database
+                .prepare('delete from local_workspace_task_scope where workspace_id = ?')
+                .run(workspace.id);
+            const removed = this.database
+                .prepare(`delete from local_workspace
+           where id = ? and status = 'closed' and source_workspace_id = ?`)
+                .run(workspace.id, input.source_workspace_id);
+            if (removed.changes !== 1) {
+                throw new Error('Closed workspace registration was not removed.');
+            }
+        });
+    }
+    requireActiveWorkspace(workspace_id) {
+        const workspace = this.getWorkspace(workspace_id);
+        if (!workspace || workspace.status !== 'active') {
+            throw new Error('Active local workspace was not found.');
+        }
+        return workspace;
+    }
+    insertWorkspace(workspace) {
+        this.database
+            .prepare(`
+          insert into local_workspace (
+            id, repository_id, source_workspace_id, actor_kind,
+            git_worktree_path, git_dir, git_common_dir, fork_git_commit_id,
+            fork_sdlc_commit_id, head_sdlc_commit_id, attached_ref, status,
+            created_at, updated_at
+          ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+            .run(workspace.id, workspace.repository_id, workspace.source_workspace_id, workspace.actor_kind, workspace.git_worktree_path, workspace.git_dir, workspace.git_common_dir, workspace.fork_git_commit_id, workspace.fork_sdlc_commit_id, workspace.head_sdlc_commit_id, workspace.attached_ref, workspace.status, workspace.created_at, workspace.updated_at);
+    }
+}
+//# sourceMappingURL=workspace-store.js.map