@codetreker/daynight 0.21.9 → 0.21.13

package/dist/commands/worker/store.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import Database from "better-sqlite3";
 import { canonicalId } from "../../api/parse.js";
 import { normalizeServerUrl } from "../../config/server.js";
+import { parseHerdrExecutionLabel } from "./herdr/agents.js";
 const integer = (value, name, minimum = 0) => {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)
         throw new Error(`${name} must be a safe integer of at least ${minimum}.`);
@@ -61,6 +62,10 @@ const parseConfiguration = (value) => {
     return { agent: oneOf(data.agent, ["copilot", "codex"], "Agent"), model: nullable(data.model, (entry) => text(entry, "Model")),
         args: data.args.map((entry) => text(entry, "Agent argument", true)), recoveryLimit: integer(data.recoveryLimit, "Recovery limit") };
 };
+const parseClaimAttempt = (value) => {
+    const data = record(value, ["taskId", "claimId", "worktreeId", "workerId", "userId", "expectedVersion", "configuration"], "Claim attempt");
+    return { taskId: id(data.taskId, "Attempt task ID"), claimId: id(data.claimId, "Attempt claim ID"), worktreeId: id(data.worktreeId, "Attempt worktree ID"), workerId: id(data.workerId, "Attempt worker ID"), userId: id(data.userId, "Attempt user ID"), expectedVersion: version(data.expectedVersion), configuration: parseConfiguration(data.configuration) };
+};
 const parseWorktree = (value) => {
     const data = record(value, ["repositoryPath", "commonDirectory", "worktreePath", "branch"], "Worktree binding");
     return { repositoryPath: absolutePath(data.repositoryPath, "Repository path"), commonDirectory: absolutePath(data.commonDirectory, "Git common directory"), worktreePath: absolutePath(data.worktreePath, "Worktree path"), branch: text(data.branch, "Worktree branch") };
@@ -77,20 +82,100 @@ const parseResources = (value) => {
     const data = record(value, ["worktree", "herdr", "nativeSession"], "Execution resources");
     return { worktree: nullable(data.worktree, parseWorktree), herdr: nullable(data.herdr, parseHerdr), nativeSession: nullable(data.nativeSession, parseNative) };
 };
+const parseTaskBinding = (value) => {
+    const data = record(value, ["session", "workspaceId", "paneId", "terminalId"], "Local Herdr binding");
+    return { session: text(data.session, "Herdr session"), workspaceId: text(data.workspaceId, "Herdr workspace ID"), paneId: text(data.paneId, "Herdr pane ID"), terminalId: text(data.terminalId, "Herdr terminal ID") };
+};
+const parseWorkspaceEvidence = (value) => {
+    const data = record(value, ["binding", "ownerLabel", "environment"], "Herdr workspace evidence");
+    const environment = record(data.environment, ["XDG_CONFIG_HOME", "XDG_STATE_HOME"], "Herdr workspace environment");
+    const config = text(environment.XDG_CONFIG_HOME, "Workspace XDG_CONFIG_HOME", true);
+    const state = text(environment.XDG_STATE_HOME, "Workspace XDG_STATE_HOME", true);
+    if (config.includes("\0") || state.includes("\0"))
+        throw new Error("The workspace environment cannot contain NUL.");
+    return { binding: parseTaskBinding(data.binding), ownerLabel: text(data.ownerLabel, "Workspace owner label"), environment: { XDG_CONFIG_HOME: config, XDG_STATE_HOME: state } };
+};
+const parseLaunchEvidence = (value) => {
+    const data = record(value, ["binding", "ownerLabel", "agent", "argv", "referenceBaseline", "workspaceEvidence"], "Herdr launch evidence");
+    if (!Array.isArray(data.argv) || data.argv.length === 0)
+        throw new Error("Herdr launch arguments must be a nonempty array.");
+    return { binding: parseTaskBinding(data.binding), ownerLabel: text(data.ownerLabel, "Launch owner label"), agent: oneOf(data.agent, ["codex", "copilot"], "Launch agent"), argv: data.argv.map((value) => text(value, "Launch argument", true)), referenceBaseline: oneOf(data.referenceBaseline, ["empty"], "Launch reference baseline"), workspaceEvidence: parseWorkspaceEvidence(data.workspaceEvidence) };
+};
+const processId = (value) => {
+    const result = integer(value, "Herdr process ID", 1);
+    if (result > 2_147_483_647)
+        throw new Error("Herdr process ID exceeds the supported process identifier range.");
+    return result;
+};
+const parseStopObservation = (value) => {
+    const data = record(value, ["binding", "ownerLabel", "agent", "nativeSessionId", "shellPid", "processIds", "nativeProcessIds", "observedAt"], "Herdr stop observation");
+    if (!Array.isArray(data.processIds) || data.processIds.length === 0)
+        throw new Error("The original native process observation must be nonempty.");
+    const shellPid = processId(data.shellPid);
+    const processIds = data.processIds.map(processId);
+    if (new Set(processIds).size !== processIds.length || processIds.includes(shellPid))
+        throw new Error("The original native process observation contains duplicate or shell process IDs.");
+    const nativeProcessIds = nullable(data.nativeProcessIds, (value) => {
+        if (!Array.isArray(value) || value.length === 0)
+            throw new Error("Native process IDs must be a nonempty array.");
+        const native = value.map(processId);
+        if (new Set(native).size !== native.length || native.includes(shellPid) || native.some((entry) => !processIds.includes(entry)))
+            throw new Error("Native process IDs must be unique original process IDs and exclude the task shell.");
+        return native;
+    });
+    return { binding: parseTaskBinding(data.binding), ownerLabel: text(data.ownerLabel, "Stop owner label"), agent: oneOf(data.agent, ["codex", "copilot"], "Stop agent"), nativeSessionId: nullable(data.nativeSessionId, (value) => id(value, "Stopped native session ID")), shellPid, processIds, nativeProcessIds, observedAt: integer(data.observedAt, "Stop observation time") };
+};
+const parseExecutionSummary = (value) => {
+    const data = record(value, ["version", "herdr", "nativeSessionId", "phase", "submission"], "Execution summary mutation");
+    return { version: version(data.version), herdr: nullable(data.herdr, parseHerdr), nativeSessionId: nullable(data.nativeSessionId, (value) => id(value, "Summary native session ID")), phase: oneOf(data.phase, ["preparing", "executing", "verifying", "completing", "waiting", "paused"], "Summary phase"), submission: oneOf(data.submission, ["unknown", "confirmed", "rejected"], "Summary submission") };
+};
+const parseNativeExecution = (value) => {
+    const data = record(value, ["terminalId", "workspaceSubmission", "workspaceEvidence", "launchEvidence", "launchSubmission", "promptSubmission", "stopObservation", "summary"], "Native execution state");
+    const result = { terminalId: nullable(data.terminalId, (value) => text(value, "Herdr terminal ID")), workspaceSubmission: oneOf(data.workspaceSubmission, ["not-submitted", "unknown", "acknowledged"], "Herdr workspace submission"), workspaceEvidence: nullable(data.workspaceEvidence, parseWorkspaceEvidence), launchEvidence: nullable(data.launchEvidence, parseLaunchEvidence), launchSubmission: oneOf(data.launchSubmission, ["never-submitted", "unknown", "acknowledged"], "Native launch submission"), promptSubmission: oneOf(data.promptSubmission, ["not-submitted", "unknown", "submitted"], "Native prompt submission"), stopObservation: nullable(data.stopObservation, parseStopObservation), summary: nullable(data.summary, parseExecutionSummary) };
+    if ((result.launchSubmission === "acknowledged") !== (result.launchEvidence !== null))
+        throw new Error("Acknowledged native launch requires its original launch evidence.");
+    if (result.launchSubmission === "never-submitted" && (result.promptSubmission !== "not-submitted" || result.stopObservation !== null))
+        throw new Error("An unlaunched native execution cannot have submitted input or original native process evidence.");
+    return result;
+};
+const freshNativeExecution = () => ({ terminalId: null, workspaceSubmission: "not-submitted", workspaceEvidence: null, launchEvidence: null, launchSubmission: "never-submitted", promptSubmission: "not-submitted", stopObservation: null, summary: null });
+const unknownNativeExecution = () => ({ ...freshNativeExecution(), workspaceSubmission: "unknown", launchSubmission: "unknown", promptSubmission: "unknown" });
+const withUserScope = (task, userId) => {
+    const owner = id(userId, "Claim user ID");
+    if (task.userId !== null && task.userId !== owner)
+        throw new Error("The original authenticated claim owner cannot be replaced.");
+    if (task.userId === null && (task.cleanup?.kind === "terminal" || task.control !== null))
+        throw new Error("An existing terminal or control intent with unknown authenticated scope cannot acquire an inferred owner.");
+    return { ...task, userId: owner };
+};
+export const isUnstartedPendingSource = (task) => {
+    const native = task.nativeExecution;
+    return task.status === "pending" && task.cleanup === null && task.resources.worktree === null && task.resources.herdr === null && task.resources.nativeSession === null
+        && native !== null && native.terminalId === null && native.workspaceSubmission === "not-submitted" && native.workspaceEvidence === null
+        && native.launchSubmission === "never-submitted" && native.launchEvidence === null && native.promptSubmission === "not-submitted" && native.stopObservation === null && native.summary === null;
+};
+export const isUnstartedPending = (task) => task.control === null && isUnstartedPendingSource(task);
 const parseRecovery = (value) => {
     const data = record(value, ["count", "pauseReason", "retryAuthorized"], "Recovery state");
     return { count: integer(data.count, "Recovery count"), pauseReason: nullable(data.pauseReason, (entry) => text(entry, "Pause reason")), retryAuthorized: bool(data.retryAuthorized, "Recovery retry authorization") };
 };
+const parseCleanupBaseline = (value) => {
+    const data = record(value, ["stateChangeSeq", "completionSeq"], "Cleanup completion baseline");
+    return { stateChangeSeq: integer(data.stateChangeSeq, "Cleanup state-change sequence"), completionSeq: integer(data.completionSeq, "Cleanup completion sequence") };
+};
 const parseCleanup = (value) => {
-    const data = record(value, ["kind", "startedAt", "deadline", "input", "result", "error", "agentStopped", "workspaceClosed", "worktreeDeleted"], "Cleanup state");
+    const data = record(value, ["kind", "startedAt", "deadline", "input", "baseline", "result", "error", "agentStopped", "workspaceClosed", "worktreeDeleted"], "Cleanup state");
     const result = { kind: oneOf(data.kind, ["terminal", "shutdown"], "Cleanup kind"), startedAt: integer(data.startedAt, "Cleanup start"), deadline: integer(data.deadline, "Cleanup deadline"),
         input: oneOf(data.input, ["not-submitted", "unknown", "submitted", "rejected", "unavailable"], "Cleanup input state"),
+        baseline: nullable(data.baseline, parseCleanupBaseline),
         result: nullable(data.result, (entry) => oneOf(entry, ["completed", "timed-out", "failed", "unavailable"], "Cleanup result")), error: nullable(data.error, (entry) => text(entry, "Cleanup error")),
         agentStopped: bool(data.agentStopped, "Agent stopped"), workspaceClosed: bool(data.workspaceClosed, "Workspace closed"), worktreeDeleted: bool(data.worktreeDeleted, "Worktree deleted") };
     if (result.deadline < result.startedAt || result.deadline - result.startedAt > 600_000)
         throw new Error("Cleanup deadline must be within ten minutes of its original start.");
     if ((result.workspaceClosed && !result.agentStopped) || (result.worktreeDeleted && !result.workspaceClosed))
         throw new Error("Cleanup progress is out of order.");
+    if (result.baseline !== null && result.input !== "submitted")
+        throw new Error("A cleanup completion baseline requires confirmed input submission.");
     return result;
 };
 const parseIntent = (value) => {
@@ -120,32 +205,73 @@ const parseControl = (value) => {
     return result;
 };
 const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-const projectColumns = "server_origin AS serverOrigin, project_id AS projectId, repo_url AS repoUrl, local_path AS localPath";
+const validateNativeExecution = (task) => {
+    const state = task.nativeExecution;
+    if (state === null)
+        return task;
+    const binding = task.resources.herdr === null || state.terminalId === null ? null : { ...task.resources.herdr, terminalId: state.terminalId };
+    if (state.terminalId !== null && task.resources.herdr === null)
+        throw new Error("The local terminal requires its core Herdr binding.");
+    if (state.workspaceSubmission === "acknowledged" && binding === null)
+        throw new Error("An acknowledged workspace requires its full original Herdr binding.");
+    const owner = { ...claimKey(task), worktreeId: task.worktreeId };
+    const evidence = (value) => {
+        if (binding === null || !same(value.binding, binding))
+            throw new Error("Native execution evidence differs from its original Herdr binding.");
+        if (!same(parseHerdrExecutionLabel(value.ownerLabel), owner))
+            throw new Error("Native execution evidence belongs to another claim or worktree.");
+    };
+    if (state.workspaceEvidence !== null)
+        evidence(state.workspaceEvidence);
+    if (state.launchEvidence !== null) {
+        evidence(state.launchEvidence);
+        evidence(state.launchEvidence.workspaceEvidence);
+        if (!same(state.workspaceEvidence, state.launchEvidence.workspaceEvidence))
+            throw new Error("The native launch does not preserve its original workspace evidence.");
+        if (task.configuration !== null && state.launchEvidence.agent !== task.configuration.agent)
+            throw new Error("The native launch agent differs from its frozen configuration.");
+        if (state.launchEvidence.argv[0] !== state.launchEvidence.agent)
+            throw new Error("The native launch arguments name another executable.");
+    }
+    if (state.stopObservation !== null) {
+        evidence(state.stopObservation);
+        if (task.configuration !== null && state.stopObservation.agent !== task.configuration.agent)
+            throw new Error("The stopped agent differs from its frozen configuration.");
+        if (state.stopObservation.nativeSessionId !== null && task.resources.nativeSession !== null && state.stopObservation.nativeSessionId !== task.resources.nativeSession.sessionId)
+            throw new Error("The stopped native session differs from the original session.");
+    }
+    return task;
+};
+const projectColumns = "server_origin AS serverOrigin, project_id AS projectId, repo_url AS repoUrl, local_path AS localPath, claim_attempt AS claimAttempt";
+const asProject = (row) => ({ ...row, claimAttempt: row.claimAttempt === null ? null : parseClaimAttempt(JSON.parse(row.claimAttempt)) });
 const taskColumns = `server_origin AS serverOrigin, project_id AS projectId, task_id AS taskId, claim_id AS claimId,
-  worker_id AS workerId, worktree_id AS worktreeId, status, repo_url AS repoUrl, repository_path AS repositoryPath,
-  configuration, resources, recovery, cleanup, control, created_at AS createdAt, updated_at AS updatedAt`;
-const asTask = (row) => ({ ...row,
+  worker_id AS workerId, worktree_id AS worktreeId, user_id AS userId, status, repo_url AS repoUrl, repository_path AS repositoryPath,
+  configuration, resources, native_execution AS nativeExecution, recovery, cleanup, control, created_at AS createdAt, updated_at AS updatedAt`;
+const asTask = (row) => validateNativeExecution({ ...row,
+    userId: row.userId === null ? null : id(row.userId, "Claim user ID"),
     configuration: row.configuration === null ? null : parseConfiguration(JSON.parse(row.configuration)),
+    nativeExecution: row.nativeExecution === null ? null : parseNativeExecution(JSON.parse(row.nativeExecution)),
     resources: parseResources(JSON.parse(row.resources)), recovery: parseRecovery(JSON.parse(row.recovery)),
     cleanup: row.cleanup === null ? null : parseCleanup(JSON.parse(row.cleanup)), control: row.control === null ? null : parseControl(JSON.parse(row.control)) });
 const schema = `
   CREATE TABLE projects (
     server_origin TEXT NOT NULL, project_id TEXT NOT NULL, repo_url TEXT NOT NULL, local_path TEXT NOT NULL,
+    claim_attempt TEXT CHECK(claim_attempt IS NULL OR json_valid(claim_attempt)),
     PRIMARY KEY(server_origin, project_id)
   ) STRICT;
   CREATE TABLE tasks (
     server_origin TEXT NOT NULL, project_id TEXT NOT NULL, task_id TEXT NOT NULL, claim_id TEXT NOT NULL,
-    worker_id TEXT NOT NULL, worktree_id TEXT NOT NULL,
+    worker_id TEXT NOT NULL, worktree_id TEXT NOT NULL, user_id TEXT,
     status TEXT NOT NULL CHECK(status IN ('pending', 'active', 'done')),
     repo_url TEXT NOT NULL, repository_path TEXT NOT NULL,
     configuration TEXT CHECK(configuration IS NULL OR json_valid(configuration)),
-    resources TEXT NOT NULL CHECK(json_valid(resources)), recovery TEXT NOT NULL CHECK(json_valid(recovery)),
+    resources TEXT NOT NULL CHECK(json_valid(resources)), native_execution TEXT CHECK(native_execution IS NULL OR json_valid(native_execution)), recovery TEXT NOT NULL CHECK(json_valid(recovery)),
     cleanup TEXT CHECK(cleanup IS NULL OR json_valid(cleanup)), control TEXT CHECK(control IS NULL OR json_valid(control)),
     created_at INTEGER NOT NULL CHECK(created_at >= 0), updated_at INTEGER NOT NULL CHECK(updated_at >= 0),
     PRIMARY KEY(server_origin, project_id, task_id, claim_id), UNIQUE(server_origin, claim_id)
   ) STRICT;
   CREATE UNIQUE INDEX tasks_one_active_per_task ON tasks(server_origin, project_id, task_id) WHERE status = 'active';
-  PRAGMA user_version = 1;
+  PRAGMA user_version = 3;
 `;
 export const openWorkerStore = (databaseFile, options = {}) => {
     absolutePath(databaseFile, "The SQLite database path");
@@ -162,8 +288,8 @@ export const openWorkerStore = (databaseFile, options = {}) => {
             throw new Error("SQLite refused synchronous=FULL.");
         db.transaction(() => {
             const currentVersion = db.pragma("user_version", { simple: true });
-            if (currentVersion !== 0 && currentVersion !== 1)
-                throw new Error(`Unsupported worker SQLite schema version ${currentVersion}; supported version is 1.`);
+            if (currentVersion !== 0 && currentVersion !== 1 && currentVersion !== 2 && currentVersion !== 3)
+                throw new Error(`Unsupported worker SQLite schema version ${currentVersion}; supported version is 3.`);
             const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name").all();
             if (currentVersion === 0) {
                 if (tables.length !== 0)
@@ -172,6 +298,10 @@ export const openWorkerStore = (databaseFile, options = {}) => {
             }
             else if (!same(tables.map(({ name }) => name), ["projects", "tasks"]))
                 throw new Error("The worker database does not contain its projects/tasks schema.");
+            if (currentVersion === 1)
+                db.exec("ALTER TABLE tasks ADD COLUMN native_execution TEXT CHECK(native_execution IS NULL OR json_valid(native_execution)); ALTER TABLE tasks ADD COLUMN user_id TEXT; ALTER TABLE projects ADD COLUMN claim_attempt TEXT CHECK(claim_attempt IS NULL OR json_valid(claim_attempt)); UPDATE tasks SET cleanup = json_set(cleanup, '$.baseline', json('null')) WHERE cleanup IS NOT NULL; PRAGMA user_version = 2;");
+            if (currentVersion === 1 || currentVersion === 2)
+                db.exec("UPDATE tasks SET native_execution = json_set(native_execution, '$.stopObservation.nativeProcessIds', json('null')) WHERE native_execution IS NOT NULL AND json_type(native_execution, '$.stopObservation') = 'object'; PRAGMA user_version = 3;");
             db.prepare(`SELECT ${projectColumns} FROM projects LIMIT 0`).all();
             db.prepare(`SELECT ${taskColumns} FROM tasks LIMIT 0`).all();
         }).immediate();
@@ -186,7 +316,10 @@ export const openWorkerStore = (databaseFile, options = {}) => {
         throw error;
     }
     const atomic = (operation) => db.transaction(operation).immediate();
-    const getProject = (identity) => db.prepare(`SELECT ${projectColumns} FROM projects WHERE server_origin = @serverOrigin AND project_id = @projectId`).get(projectKey(identity)) ?? null;
+    const getProject = (identity) => {
+        const row = db.prepare(`SELECT ${projectColumns} FROM projects WHERE server_origin = @serverOrigin AND project_id = @projectId`).get(projectKey(identity));
+        return row === undefined ? null : asProject(row);
+    };
     const getTask = (identity) => {
         const row = db.prepare(`SELECT ${taskColumns} FROM tasks WHERE server_origin = @serverOrigin AND project_id = @projectId AND task_id = @taskId AND claim_id = @claimId`).get(claimKey(identity));
         return row === undefined ? null : asTask(row);
@@ -198,9 +331,10 @@ export const openWorkerStore = (databaseFile, options = {}) => {
         return task;
     };
     const writeTask = (task) => {
-        const values = { ...task, configuration: task.configuration === null ? null : JSON.stringify(parseConfiguration(task.configuration)), resources: JSON.stringify(parseResources(task.resources)), recovery: JSON.stringify(parseRecovery(task.recovery)),
+        validateNativeExecution(task);
+        const values = { ...task, configuration: task.configuration === null ? null : JSON.stringify(parseConfiguration(task.configuration)), resources: JSON.stringify(parseResources(task.resources)), nativeExecution: task.nativeExecution === null ? null : JSON.stringify(parseNativeExecution(task.nativeExecution)), recovery: JSON.stringify(parseRecovery(task.recovery)),
             cleanup: task.cleanup === null ? null : JSON.stringify(parseCleanup(task.cleanup)), control: task.control === null ? null : JSON.stringify(parseControl(task.control)) };
-        db.prepare(`UPDATE tasks SET status = @status, configuration = @configuration, resources = @resources, recovery = @recovery,
+        db.prepare(`UPDATE tasks SET user_id = @userId, status = @status, configuration = @configuration, resources = @resources, native_execution = @nativeExecution, recovery = @recovery,
       cleanup = @cleanup, control = @control, updated_at = @updatedAt
       WHERE server_origin = @serverOrigin AND project_id = @projectId AND task_id = @taskId AND claim_id = @claimId`).run(values);
         return needTask(task);
@@ -228,47 +362,129 @@ export const openWorkerStore = (databaseFile, options = {}) => {
         if (cleanup.kind !== "terminal" || cleanup.result === null || !cleanup.agentStopped || !cleanup.workspaceClosed || !cleanup.worktreeDeleted)
             throw new Error("Terminal cleanup must record its result and confirm agent stopped, workspace closed and worktree deleted.");
     };
+    const controlIntent = (task, input) => {
+        const intent = parseIntent(input);
+        if (intent.sourceClaimId !== task.claimId)
+            throw new Error("The control intent must name the original claim.");
+        if (intent.kind === "transfer" && (intent.targetClaimId === task.claimId || intent.target.worktreeId === task.worktreeId))
+            throw new Error("Transfer requires new claim and worktree identities.");
+        return intent;
+    };
+    const unsubmittedControl = (intent, requestedAt) => ({ intent, requestedAt, submission: "not-submitted", submittedAt: null, outcome: null, resultVersion: null, error: null });
+    const authorizeRecoveryRetry = (task, expectedCount) => {
+        requireOrdinary(task);
+        if (expectedCount !== undefined && task.recovery.count !== integer(expectedCount, "Expected recovery count"))
+            throw new Error("The recovery count changed after the explicit retry decision.");
+        if (task.status !== "active" || task.recovery.pauseReason === null)
+            throw new Error("An extra recovery requires a paused active execution.");
+        return { ...task, recovery: { ...task.recovery, retryAuthorized: true } };
+    };
     return {
         close: () => { db.close(); },
         getProject,
-        listProjects: () => db.prepare(`SELECT ${projectColumns} FROM projects ORDER BY server_origin, project_id`).all(),
+        listProjects: () => db.prepare(`SELECT ${projectColumns} FROM projects ORDER BY server_origin, project_id`).all().map(asProject),
         registerProject: (project) => atomic(() => {
             const value = { ...projectKey(project), repoUrl: text(project.repoUrl, "Repository URL"), localPath: absolutePath(project.localPath, "Project local path") };
             const existing = getProject(value);
             if (existing !== null && (existing.repoUrl !== value.repoUrl || existing.localPath !== value.localPath)) {
+                if (existing.claimAttempt !== null)
+                    throw new Error("An unresolved claim attempt prevents changing its project repository binding.");
                 const unfinished = db.prepare("SELECT 1 FROM tasks WHERE server_origin = @serverOrigin AND project_id = @projectId AND status <> 'done' LIMIT 1").get(value);
                 if (unfinished !== undefined)
                     throw new Error("An unfinished execution prevents changing its project repository binding.");
             }
             db.prepare(`INSERT INTO projects(server_origin, project_id, repo_url, local_path) VALUES (@serverOrigin, @projectId, @repoUrl, @localPath)
         ON CONFLICT(server_origin, project_id) DO UPDATE SET repo_url = excluded.repo_url, local_path = excluded.local_path`).run(value);
-            return value;
+            return getProject(value);
+        }),
+        getClaimAttempt: (identity) => {
+            const project = getProject(identity);
+            if (project === null)
+                throw new Error("The project repository binding is not registered.");
+            return project.claimAttempt;
+        },
+        listClaimAttempts: () => db.prepare(`SELECT ${projectColumns} FROM projects WHERE claim_attempt IS NOT NULL ORDER BY server_origin, project_id`).all().map(asProject).map((project) => ({ ...projectKey(project), attempt: project.claimAttempt })),
+        beginClaimAttempt: (identity, input) => atomic(() => {
+            const key = projectKey(identity);
+            const project = getProject(key);
+            if (project === null)
+                throw new Error("The project repository binding must be persisted before claiming a task.");
+            const attempt = parseClaimAttempt(input);
+            if (project.claimAttempt !== null)
+                throw new Error("The project already has an unresolved claim attempt; it cannot be replayed or replaced.");
+            db.prepare("UPDATE projects SET claim_attempt = @claimAttempt WHERE server_origin = @serverOrigin AND project_id = @projectId").run({ ...key, claimAttempt: JSON.stringify(attempt) });
+            return attempt;
+        }),
+        rejectClaimAttempt: (identity, expectedClaimId, proof) => atomic(() => {
+            const key = projectKey(identity);
+            const project = getProject(key);
+            if (project === null || project.claimAttempt === null || project.claimAttempt.claimId !== id(expectedClaimId, "Rejected claim ID"))
+                throw new Error("The original unresolved claim attempt does not match.");
+            if (!("definiteRejection" in proof && proof.definiteRejection === true) && !("notSubmitted" in proof && proof.notSubmitted === true))
+                throw new Error("Clearing a claim attempt requires definite rejection or proven non-submission of the original mutation.");
+            db.prepare("UPDATE projects SET claim_attempt = NULL WHERE server_origin = @serverOrigin AND project_id = @projectId").run(key);
         }),
         getTask,
         listTasks: () => db.prepare(`SELECT ${taskColumns} FROM tasks ORDER BY created_at, server_origin, project_id, task_id, claim_id`).all().map(asTask),
         listUnfinishedTasks: () => db.prepare(`SELECT ${taskColumns} FROM tasks WHERE status <> 'done' ORDER BY created_at, server_origin, project_id, task_id, claim_id`).all().map(asTask),
-        registerPending: (claim, input, now) => atomic(() => {
+        recordObservedUnattemptedWorkspace: (owner, now) => atomic(() => {
+            const key = { ...claimKey(owner), workerId: id(owner.workerId, "Observed worker ID"), worktreeId: id(owner.worktreeId, "Observed worktree ID") };
+            integer(now, "Workspace observation time");
+            const task = getTask(key);
+            if (task === null)
+                return null;
+            if (task.workerId !== key.workerId || task.worktreeId !== key.worktreeId)
+                throw new Error("The observed workspace does not match the original execution's worker and worktree identity.");
+            const native = task.nativeExecution;
+            if (task.status === "done" || task.resources.herdr !== null || native === null || native.workspaceSubmission !== "not-submitted" || native.launchSubmission !== "never-submitted")
+                return task;
+            return writeTask({ ...task, nativeExecution: { ...unknownNativeExecution(), summary: native.summary }, updatedAt: now });
+        }),
+        registerPending: (claim, input, now, verifiedUserId = null) => atomic(() => {
             const key = { ...claimKey(claim), workerId: id(claim.workerId, "Worker ID"), worktreeId: id(claim.worktreeId, "Worktree ID") };
+            const owner = verifiedUserId === null ? null : id(verifiedUserId, "Verified claim user ID");
             integer(now, "Task creation time");
             oneOf(input.kind, ["new", "recovered"], "Pending registration kind");
             if (input.kind === "new" && input.configuration === null)
                 throw new Error("A new execution requires its frozen configuration.");
             const configuration = input.configuration === null ? null : parseConfiguration(input.configuration);
+            const project = getProject(key);
+            if (project === null)
+                throw new Error("The project repository binding must be persisted before claiming a task.");
+            const confirmAttempt = (originalConfiguration) => {
+                const attempt = project.claimAttempt;
+                if (attempt === null || attempt.claimId !== key.claimId)
+                    return originalConfiguration;
+                if (attempt.taskId !== key.taskId || attempt.worktreeId !== key.worktreeId || attempt.workerId !== key.workerId || (originalConfiguration !== null && !same(attempt.configuration, originalConfiguration)))
+                    throw new Error("The actual granted claim does not preserve its original claim attempt and frozen configuration.");
+                if (owner === null)
+                    return originalConfiguration;
+                if (attempt.userId !== owner)
+                    throw new Error("The actual granted claim does not preserve its original authenticated claim attempt owner.");
+                db.prepare("UPDATE projects SET claim_attempt = NULL WHERE server_origin = @serverOrigin AND project_id = @projectId").run(projectKey(key));
+                return originalConfiguration === null ? attempt.configuration : originalConfiguration;
+            };
             const existing = getTask(key);
             if (existing !== null) {
                 if (existing.workerId !== key.workerId || existing.worktreeId !== key.worktreeId)
                     throw new Error("The claim is already bound to a different worker or worktree identity.");
+                const scoped = owner === null ? existing : withUserScope(existing, owner);
+                const originalConfiguration = confirmAttempt(existing.configuration);
+                if (scoped.userId !== existing.userId || originalConfiguration !== existing.configuration) {
+                    if (existing.status === "done")
+                        throw new Error("The local execution is already done; its unknown authenticated scope cannot be replaced.");
+                    return writeTask({ ...scoped, configuration: originalConfiguration, updatedAt: now });
+                }
                 return existing;
             }
-            const project = getProject(key);
-            if (project === null)
-                throw new Error("The project repository binding must be persisted before claiming a task.");
-            const values = { ...key, configuration: configuration === null ? null : JSON.stringify(configuration), repoUrl: project.repoUrl, repositoryPath: project.localPath,
-                resources: JSON.stringify({ worktree: null, herdr: null, nativeSession: null }), recovery: JSON.stringify({ count: 0, pauseReason: configuration === null ? "Original frozen execution configuration is missing." : null, retryAuthorized: false }), now };
-            db.prepare(`INSERT INTO tasks(server_origin, project_id, task_id, claim_id, worker_id, worktree_id, status, repo_url, repository_path, configuration, resources, recovery, created_at, updated_at)
-        VALUES (@serverOrigin, @projectId, @taskId, @claimId, @workerId, @worktreeId, 'pending', @repoUrl, @repositoryPath, @configuration, @resources, @recovery, @now, @now)`).run(values);
+            const originalConfiguration = confirmAttempt(configuration);
+            const values = { ...key, userId: owner, configuration: originalConfiguration === null ? null : JSON.stringify(originalConfiguration), repoUrl: project.repoUrl, repositoryPath: project.localPath,
+                resources: JSON.stringify({ worktree: null, herdr: null, nativeSession: null }), nativeExecution: input.kind === "new" ? JSON.stringify(freshNativeExecution()) : null, recovery: JSON.stringify({ count: 0, pauseReason: originalConfiguration === null ? "Original frozen execution configuration is missing." : null, retryAuthorized: false }), now };
+            db.prepare(`INSERT INTO tasks(server_origin, project_id, task_id, claim_id, worker_id, worktree_id, user_id, status, repo_url, repository_path, configuration, resources, native_execution, recovery, created_at, updated_at)
+        VALUES (@serverOrigin, @projectId, @taskId, @claimId, @workerId, @worktreeId, @userId, 'pending', @repoUrl, @repositoryPath, @configuration, @resources, @nativeExecution, @recovery, @now, @now)`).run(values);
             return needTask(key);
         }),
+        bindUserScope: (identity, userId, now) => change(identity, now, (task) => withUserScope(task, userId)),
         restoreOriginalConfiguration: (identity, configuration, now) => change(identity, now, (task) => {
             const original = parseConfiguration(configuration);
             if (task.configuration !== null && !same(task.configuration, original))
@@ -281,6 +497,13 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("The execution is paused.");
             return { ...task, status: "active" };
         }),
+        activatePausedRecovery: (identity, reason, now) => change(identity, now, (task) => {
+            if (task.control !== null || task.cleanup !== null)
+                throw new Error("A control or cleanup intent prevents recovery promotion.");
+            if (task.nativeExecution?.launchSubmission === "never-submitted" && task.resources.worktree === null && task.resources.herdr === null && task.resources.nativeSession === null)
+                throw new Error("Paused recovery requires unknown original provenance or existing execution resources.");
+            return { ...task, status: "active", recovery: { ...task.recovery, pauseReason: text(reason, "Recovery pause reason") } };
+        }),
         bindWorktree: (identity, binding, now) => change(identity, now, (task) => {
             if (task.status !== "active")
                 throw new Error("Resource creation requires an active execution.");
@@ -299,6 +522,125 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("The execution already has a different Herdr binding.");
             return { ...task, resources: { ...task.resources, herdr: value } };
         }),
+        bindHerdrExecution: (identity, binding, workspaceEvidence, now) => change(identity, now, (task) => {
+            if (task.status !== "active" || task.resources.worktree === null)
+                throw new Error("Herdr binding requires an active execution and its original worktree.");
+            const value = parseTaskBinding(binding);
+            const core = { session: value.session, workspaceId: value.workspaceId, paneId: value.paneId };
+            if (task.resources.herdr !== null && !same(task.resources.herdr, core))
+                throw new Error("The execution already has a different Herdr binding.");
+            const state = task.nativeExecution === null ? unknownNativeExecution() : task.nativeExecution;
+            if (state.terminalId !== null && state.terminalId !== value.terminalId)
+                throw new Error("The original terminal cannot change without confirmed stop and workspace closure.");
+            if (state.workspaceSubmission === "unknown" && state.terminalId !== null && task.resources.herdr !== null)
+                throw new Error("An unresolved replacement workspace cannot be acknowledged by its previous binding.");
+            const evidence = workspaceEvidence === null ? state.workspaceEvidence : parseWorkspaceEvidence(workspaceEvidence);
+            if (state.workspaceEvidence !== null && !same(state.workspaceEvidence, evidence))
+                throw new Error("The original workspace evidence cannot be replaced.");
+            return { ...task, resources: { ...task.resources, herdr: core }, nativeExecution: { ...state, terminalId: value.terminalId, workspaceSubmission: "acknowledged", workspaceEvidence: evidence } };
+        }),
+        markWorkspaceSubmitting: (identity, now) => change(identity, now, (task) => {
+            requireOrdinary(task);
+            const state = task.nativeExecution;
+            if (task.status !== "active" || task.resources.worktree === null || state === null)
+                throw new Error("Workspace creation requires its active original worktree and persisted provenance.");
+            if (state.workspaceSubmission === "unknown")
+                throw new Error("The original workspace creation is unresolved and cannot be replayed.");
+            if (state.launchSubmission !== "never-submitted" && task.resources.nativeSession === null)
+                throw new Error("The original native session ID is missing; workspace replacement cannot start a new conversation.");
+            if (task.resources.herdr !== null && state.launchSubmission !== "never-submitted" && state.stopObservation === null)
+                throw new Error("Workspace replacement requires its durable original native stop observation.");
+            return { ...task, nativeExecution: { ...state, workspaceSubmission: "unknown" } };
+        }),
+        recordWorkspaceNotSubmitted: (identity, proof, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            if (state === null || state.workspaceSubmission !== "unknown")
+                throw new Error("Workspace non-submission requires its original unresolved create attempt.");
+            if (!("notSubmitted" in proof && proof.notSubmitted === true) && !("definiteRejection" in proof && proof.definiteRejection === true))
+                throw new Error("Resetting workspace creation requires proven non-submission or definite rejection before dispatch.");
+            return { ...task, nativeExecution: { ...state, workspaceSubmission: "not-submitted" } };
+        }),
+        markNativeLaunchSubmitting: (identity, now) => change(identity, now, (task) => {
+            requireOrdinary(task);
+            const state = task.nativeExecution;
+            if (task.status !== "active" || task.recovery.pauseReason !== null || state === null || state.terminalId === null || state.workspaceSubmission !== "acknowledged" || state.workspaceEvidence === null || state.launchSubmission !== "never-submitted")
+                throw new Error("Native launch requires a proven unlaunched active execution and its verified workspace.");
+            return { ...task, nativeExecution: { ...state, launchSubmission: "unknown", promptSubmission: "unknown" } };
+        }),
+        recordNativeLaunchNotSubmitted: (identity, proof, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            if (task.status !== "active" || state === null || state.launchSubmission !== "unknown" || state.launchEvidence !== null || state.stopObservation !== null || state.promptSubmission === "submitted")
+                throw new Error("A native launch can be unsubmitted only before acknowledged launch, prompt submission or native process evidence.");
+            if (!("notSubmitted" in proof && proof.notSubmitted === true) && !("definiteRejection" in proof && proof.definiteRejection === true))
+                throw new Error("Resetting a native launch requires proven non-submission or definite rejection before native dispatch.");
+            return { ...task, nativeExecution: { ...state, launchSubmission: "never-submitted", promptSubmission: "not-submitted" } };
+        }),
+        markNativePromptSubmitting: (identity, now) => change(identity, now, (task) => {
+            requireOrdinary(task);
+            const state = task.nativeExecution;
+            if (task.status !== "active" || task.recovery.pauseReason !== null || state === null || state.workspaceSubmission !== "acknowledged" || state.launchSubmission !== "acknowledged" || state.launchEvidence === null || state.promptSubmission !== "not-submitted")
+                throw new Error("Deferred startup input requires its original acknowledged launch and a proven unsubmitted prompt.");
+            return { ...task, nativeExecution: { ...state, promptSubmission: "unknown" } };
+        }),
+        recordNativeStartOutcome: (identity, input, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            if (task.status !== "active" || state === null || state.terminalId === null || state.launchSubmission === "never-submitted")
+                throw new Error("Native startup outcome requires the original persisted submission attempt.");
+            const promptSubmission = oneOf(input.promptSubmission, ["not-submitted", "unknown", "submitted"], "Native prompt outcome");
+            if (state.promptSubmission === "submitted" && promptSubmission !== "submitted")
+                throw new Error("A confirmed startup prompt cannot become unsubmitted or unknown.");
+            const launchEvidence = input.launchEvidence === undefined ? state.launchEvidence : parseLaunchEvidence(input.launchEvidence);
+            if (state.launchEvidence !== null && !same(state.launchEvidence, launchEvidence))
+                throw new Error("The original native launch evidence cannot be replaced.");
+            return { ...task, nativeExecution: { ...state, launchEvidence, launchSubmission: launchEvidence === null ? state.launchSubmission : "acknowledged", promptSubmission } };
+        }),
+        recordStopObservation: (identity, observation, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            if (task.status !== "active" || state === null || state.terminalId === null || state.launchSubmission === "never-submitted")
+                throw new Error("A native stop observation requires the original possibly launched terminal.");
+            const evidence = parseStopObservation(observation);
+            if (state.stopObservation !== null && !same(state.stopObservation, evidence))
+                throw new Error("The original native process observation cannot be replaced before confirmed closure.");
+            return { ...task, nativeExecution: { ...state, stopObservation: evidence } };
+        }),
+        markExecutionSummarySubmitting: (identity, input, now) => change(identity, now, (task) => {
+            requireOrdinary(task);
+            if (task.status !== "active")
+                throw new Error("Execution summary publication requires an active execution.");
+            const state = task.nativeExecution === null ? unknownNativeExecution() : task.nativeExecution;
+            if (state.summary?.submission === "unknown")
+                throw new Error("The original execution summary mutation is unresolved and cannot be replayed or replaced.");
+            const summary = parseExecutionSummary({ ...input, submission: "unknown" });
+            if (!same(summary.herdr, task.resources.herdr) || summary.nativeSessionId !== (task.resources.nativeSession === null ? null : task.resources.nativeSession.sessionId))
+                throw new Error("Execution summary must describe its original actual resource bindings.");
+            return { ...task, nativeExecution: { ...state, summary } };
+        }),
+        recordExecutionSummaryOutcome: (identity, expectedVersion, submission, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            const summary = state === null ? null : state.summary;
+            const outcome = oneOf(submission, ["confirmed", "rejected"], "Summary mutation outcome");
+            if (summary === null || summary.version !== version(expectedVersion) || (summary.submission !== "unknown" && summary.submission !== outcome))
+                throw new Error("The original execution summary submission does not match this outcome.");
+            return { ...task, nativeExecution: { ...state, summary: { ...summary, submission: outcome } } };
+        }),
+        recordExecutionSummaryNotSubmitted: (identity, expectedVersion, proof, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            const summary = state === null ? null : state.summary;
+            if (summary === null || summary.submission !== "unknown" || summary.version !== version(expectedVersion))
+                throw new Error("The original unresolved execution summary does not match this non-submission.");
+            if (proof.notSubmitted !== true)
+                throw new Error("Clearing an execution summary requires proven non-submission before dispatch.");
+            return { ...task, nativeExecution: { ...state, summary: null } };
+        }),
+        reconcileExecutionSummary: (identity, input, now) => change(identity, now, (task) => {
+            const state = task.nativeExecution;
+            const summary = state === null ? null : state.summary;
+            const observed = parseExecutionSummary({ ...input, submission: "confirmed" });
+            if (summary === null || summary.submission !== "unknown" || BigInt(observed.version) <= BigInt(summary.version))
+                return task;
+            const matched = same(observed.herdr, summary.herdr) && observed.nativeSessionId === summary.nativeSessionId && observed.phase === summary.phase;
+            return { ...task, nativeExecution: { ...state, summary: matched ? { ...summary, submission: "confirmed" } : null } };
+        }),
         rebindHerdr: (identity, expectedPrevious, next, proof, now) => change(identity, now, (task) => {
             requireOrdinary(task);
             if (task.status !== "active" || task.resources.worktree === null || task.resources.herdr === null)
@@ -307,7 +649,26 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("The previous Herdr binding does not match the original execution.");
             if (proof.originalAgentStopped !== true || proof.oldWorkspaceClosed !== true)
                 throw new Error("Herdr rebinding requires confirmed original agent stop and old workspace closure.");
-            return { ...task, resources: { ...task.resources, herdr: parseHerdr(next) } };
+            if (task.resources.nativeSession === null && task.nativeExecution?.launchSubmission !== "never-submitted")
+                throw new Error("The original native session ID is missing; rebinding cannot start a new conversation.");
+            return { ...task, resources: { ...task.resources, herdr: parseHerdr(next) }, nativeExecution: { ...unknownNativeExecution(), summary: task.nativeExecution === null ? null : task.nativeExecution.summary } };
+        }),
+        rebindHerdrExecution: (identity, expectedPrevious, next, workspaceEvidence, proof, now) => change(identity, now, (task) => {
+            requireOrdinary(task);
+            const previous = parseTaskBinding(expectedPrevious);
+            const state = task.nativeExecution;
+            if (task.status !== "active" || task.resources.worktree === null || task.resources.herdr === null || state === null || !same({ ...task.resources.herdr, terminalId: state.terminalId }, previous))
+                throw new Error("The previous full Herdr binding does not match the active execution.");
+            if (proof.originalAgentStopped !== true || proof.oldWorkspaceClosed !== true || (state.stopObservation === null && state.launchSubmission !== "never-submitted"))
+                throw new Error("Herdr rebinding requires durable original stop provenance and confirmed old workspace closure.");
+            if (state.launchSubmission !== "never-submitted" && task.resources.nativeSession === null)
+                throw new Error("The original native session ID is missing; rebinding cannot start a new conversation.");
+            if (state.workspaceSubmission !== "unknown")
+                throw new Error("Herdr rebinding requires the persisted new workspace creation attempt.");
+            const binding = parseTaskBinding(next);
+            if (same(binding, previous))
+                throw new Error("A fresh Herdr execution must use a new workspace or terminal binding.");
+            return { ...task, resources: { ...task.resources, herdr: { session: binding.session, workspaceId: binding.workspaceId, paneId: binding.paneId } }, nativeExecution: { ...freshNativeExecution(), terminalId: binding.terminalId, workspaceSubmission: "acknowledged", workspaceEvidence: workspaceEvidence === null ? null : parseWorkspaceEvidence(workspaceEvidence), summary: state.summary } };
         }),
         bindNativeSession: (identity, reference, now) => change(identity, now, (task) => {
             if (task.status !== "active" || task.resources.herdr === null)
@@ -323,11 +684,9 @@ export const openWorkerStore = (databaseFile, options = {}) => {
             return { ...task, recovery: { ...task.recovery, pauseReason: null } };
         }),
         authorizeRecoveryRetry: (identity, now) => change(identity, now, (task) => {
-            requireOrdinary(task);
-            if (task.status !== "active" || task.recovery.pauseReason === null)
-                throw new Error("An extra recovery requires a paused active execution.");
-            return { ...task, recovery: { ...task.recovery, retryAuthorized: true } };
+            return authorizeRecoveryRetry(task);
         }),
+        authorizeRecoveryRetryAtCount: (identity, expectedCount, now) => change(identity, now, (task) => authorizeRecoveryRetry(task, expectedCount)),
         beginRecovery: (identity, now) => change(identity, now, (task) => {
             requireOrdinary(task);
             if (task.status !== "active")
@@ -348,7 +707,7 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 return { ...task, cleanup: { ...existing, kind: existing.kind === "terminal" ? "terminal" : input.kind } };
             if (task.control !== null && input.kind !== "terminal")
                 throw new Error("A source control intent requires terminal cleanup.");
-            return { ...task, status: "active", cleanup: parseCleanup({ kind: input.kind, startedAt: now, deadline: input.deadline, input: "not-submitted", result: null, error: null, agentStopped: false, workspaceClosed: false, worktreeDeleted: false }) };
+            return { ...task, status: "active", cleanup: parseCleanup({ kind: input.kind, startedAt: now, deadline: input.deadline, input: "not-submitted", baseline: null, result: null, error: null, agentStopped: false, workspaceClosed: false, worktreeDeleted: false }) };
         }),
         markCleanupInputSubmitting: (identity, now) => change(identity, now, (task) => {
             const cleanup = needCleanup(task);
@@ -365,6 +724,15 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("The cleanup input outcome conflicts with the original submission.");
             return { ...task, cleanup: { ...cleanup, input } };
         }),
+        recordCleanupInputEvidence: (identity, baseline, now) => change(identity, now, (task) => {
+            const cleanup = needCleanup(task);
+            if (cleanup.input !== "submitted")
+                throw new Error("Cleanup completion evidence requires the original confirmed input submission.");
+            const evidence = parseCleanupBaseline(baseline);
+            if (cleanup.baseline !== null && !same(cleanup.baseline, evidence))
+                throw new Error("The original cleanup completion baseline cannot be replaced.");
+            return { ...task, cleanup: { ...cleanup, baseline: evidence } };
+        }),
         recordCleanupResult: (identity, result, error, now) => change(identity, now, (task) => {
             const cleanup = needCleanup(task);
             oneOf(result, ["completed", "timed-out", "failed", "unavailable"], "Cleanup result");
@@ -398,20 +766,33 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("Shutdown resume requires the original agent stopped, workspace closed and its cleanup result recorded.");
             if (task.configuration === null)
                 throw new Error("The original frozen execution configuration is missing.");
-            return { ...task, cleanup: null, resources: { ...task.resources, herdr: null } };
+            if (task.resources.nativeSession === null && task.nativeExecution?.launchSubmission !== "never-submitted")
+                return { ...task, cleanup: null, recovery: { ...task.recovery, pauseReason: "The original native session ID is missing; recover its exact history identity before resuming this claim." } };
+            return { ...task, cleanup: null, resources: { ...task.resources, herdr: null }, nativeExecution: { ...freshNativeExecution(), summary: task.nativeExecution === null ? null : task.nativeExecution.summary } };
         }),
         recordControlIntent: (identity, input, now) => change(identity, now, (task) => {
-            const intent = parseIntent(input);
-            if (intent.sourceClaimId !== task.claimId)
-                throw new Error("The control intent must name the original claim.");
-            if (intent.kind === "transfer" && (intent.targetClaimId === task.claimId || intent.target.worktreeId === task.worktreeId))
-                throw new Error("Transfer requires new claim and worktree identities.");
+            const intent = controlIntent(task, input);
             if (task.control !== null) {
                 if (!same(task.control.intent, intent))
                     throw new Error("A different source control intent is already recorded.");
                 return task;
             }
-            return { ...task, cleanup: task.cleanup === null ? null : { ...task.cleanup, kind: "terminal" }, control: { intent, requestedAt: now, submission: "not-submitted", submittedAt: null, outcome: null, resultVersion: null, error: null } };
+            return { ...task, cleanup: task.cleanup === null ? null : { ...task.cleanup, kind: "terminal" }, control: unsubmittedControl(intent, now) };
+        }),
+        replaceRejectedControlIntent: (identity, input, proof, now) => change(identity, now, (task) => {
+            const intent = controlIntent(task, input);
+            if (task.control?.submission !== "rejected")
+                throw new Error("A new explicit control decision can replace only a definitely rejected submission; unknown writes remain fenced.");
+            if (exactVersion(proof.observedVersion) !== intent.version)
+                throw new Error("The replacement decision must use its newly observed explicit version.");
+            return { ...task, control: unsubmittedControl(intent, now) };
+        }),
+        confirmUnstartedControlCleanup: (identity, proof, deadline, now) => change(identity, now, (task) => {
+            if (proof.completeHerdrInventory !== true || proof.noOwnedResources !== true)
+                throw new Error("An unstarted source cleanup requires a complete Herdr inventory proving no original resources.");
+            if (task.userId === null || task.control === null || !isUnstartedPendingSource(task))
+                throw new Error("Only a scoped unstarted pending source with a saved control intent can finish without activation.");
+            return { ...task, cleanup: parseCleanup({ kind: "terminal", startedAt: now, deadline, input: "unavailable", baseline: null, result: "completed", error: null, agentStopped: true, workspaceClosed: true, worktreeDeleted: true }) };
         }),
         markControlSubmitting: (identity, expectedVersion, now) => change(identity, now, (task) => {
             fullyCleaned(task);
@@ -444,6 +825,53 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 return task;
             return { ...task, control: { ...control, submission: "confirmed", outcome: "ownership-ended", resultVersion: null, error: null } };
         }),
+        confirmControlOwnershipEndedByTask: (identity, proof, now) => change(identity, now, (task) => {
+            fullyCleaned(task);
+            const control = task.control;
+            if (control === null)
+                throw new Error("A source control intent is required for targeted management reconciliation.");
+            const observedClaimId = nullable(proof.observedClaimId, (value) => id(value, "Observed claim ID"));
+            const observedState = nullable(proof.observedState, (value) => oneOf(value, ["active", "released", "completed"], "Observed claim state"));
+            if ((observedClaimId === null) !== (observedState === null))
+                throw new Error("The targeted task observation must include both claim identity and state, or neither.");
+            if (observedClaimId === task.claimId && observedState === "active")
+                throw new Error("The targeted task observation still contains the original active claim.");
+            if (control.submission === "confirmed")
+                return task;
+            return { ...task, control: { ...control, submission: "confirmed", outcome: "ownership-ended", resultVersion: null, error: null } };
+        }),
+        completeAppliedControl: (identity, expectedIntent, resultVersion, now) => atomic(() => {
+            const task = needTask(identity);
+            fullyCleaned(task);
+            const control = task.control;
+            if (control === null || !same(control.intent, parseIntent(expectedIntent)))
+                throw new Error("The observed remote result does not belong to the current concrete management decision.");
+            if (task.status === "done") {
+                if (control.submission !== "confirmed")
+                    throw new Error("A completed source must have a confirmed management result.");
+                return task;
+            }
+            if (control.submission !== "unknown" && control.submission !== "confirmed")
+                throw new Error("An applied control result requires the original submitted decision.");
+            return writeTask({ ...task, status: "done", control: { ...control, submission: "confirmed", outcome: "applied", resultVersion: exactVersion(resultVersion), error: null }, updatedAt: integer(now, "Task update time") });
+        }),
+        completeEndedControl: (identity, expectedIntent, proof, now) => atomic(() => {
+            const task = needTask(identity);
+            fullyCleaned(task);
+            const control = task.control;
+            if (control === null || !same(control.intent, parseIntent(expectedIntent)))
+                throw new Error("The observed ownership exit does not belong to the current concrete management decision.");
+            if (task.status === "done") {
+                if (control.submission !== "confirmed")
+                    throw new Error("A completed source must have a confirmed management result.");
+                return task;
+            }
+            const observedClaimId = nullable(proof.observedClaimId, (value) => id(value, "Observed claim ID"));
+            const observedState = nullable(proof.observedState, (value) => oneOf(value, ["active", "released", "completed"], "Observed claim state"));
+            if ((observedClaimId === null) !== (observedState === null) || (observedClaimId === task.claimId && observedState === "active"))
+                throw new Error("The targeted task observation does not prove the original active claim ended.");
+            return writeTask({ ...task, status: "done", control: { ...control, submission: "confirmed", outcome: "ownership-ended", resultVersion: null, error: null }, updatedAt: integer(now, "Task update time") });
+        }),
         rejectControlSubmission: (identity, error, now) => change(identity, now, (task) => {
             if (task.control === null || task.control.submission !== "unknown")
                 throw new Error("A definite control rejection requires an original unknown submission.");
@@ -455,6 +883,17 @@ export const openWorkerStore = (databaseFile, options = {}) => {
                 throw new Error("The source control outcome must be reconciled before local completion.");
             return { ...task, status: "done" };
         }),
+        completeUnstartedPending: (identity, proof, now) => change(identity, now, (task) => {
+            if (proof.completeOwnClaimInventory !== true || proof.claimAbsent !== true)
+                throw new Error("Completing an unstarted pending claim requires its absence from a successful complete own-claim inventory.");
+            if (!isUnstartedPending(task))
+                throw new Error("Only a proven unstarted pending execution with no resources or outstanding actions can complete directly.");
+            if (task.userId === null || task.userId !== id(proof.authenticatedUserId, "Authenticated user ID"))
+                throw new Error("The complete own-claim inventory must belong to the original authenticated claim owner.");
+            const completed = { ...task, status: "done", cleanup: { kind: "terminal", startedAt: now, deadline: now, input: "unavailable", baseline: null, result: "completed", error: null, agentStopped: true, workspaceClosed: true, worktreeDeleted: true } };
+            fullyCleaned(completed);
+            return completed;
+        }),
     };
 };
 //# sourceMappingURL=store.js.map