@agentbridge1/cli 0.0.1

package/dist/server-sync.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openServerSession = openServerSession;
+exports.createChangeRequest = createChangeRequest;
+exports.getChangeRequest = getChangeRequest;
+exports.updateChangeRequestStatus = updateChangeRequestStatus;
+exports.updateChangeRequest = updateChangeRequest;
+exports.listChangeRequests = listChangeRequests;
+exports.listWorkIdentities = listWorkIdentities;
+exports.fetchCallerIdentityPacket = fetchCallerIdentityPacket;
+exports.postObservedDiff = postObservedDiff;
+exports.postScopedApproval = postScopedApproval;
+exports.closeServerSession = closeServerSession;
+exports.fetchAcceptanceCheck = fetchAcceptanceCheck;
+exports.reviewOnceForWatch = reviewOnceForWatch;
+exports.isWatchFastPathUnavailable = isWatchFastPathUnavailable;
+exports.fetchMemorySuggestion = fetchMemorySuggestion;
+exports.applyMemoryCandidateRequest = applyMemoryCandidateRequest;
+exports.rejectMemoryCandidateRequest = rejectMemoryCandidateRequest;
+exports.deferMemoryCandidateRequest = deferMemoryCandidateRequest;
+exports.revertMemoryCandidateRequest = revertMemoryCandidateRequest;
+exports.intakeEscapedBugRequest = intakeEscapedBugRequest;
+exports.resolveCurrentServerSession = resolveCurrentServerSession;
+exports.listWorkSessions = listWorkSessions;
+exports.getWorkSession = getWorkSession;
+exports.cancelWorkSession = cancelWorkSession;
+exports.postVerificationRun = postVerificationRun;
+exports.postHandoff = postHandoff;
+exports.acceptWorkSession = acceptWorkSession;
+exports.createAgentHandshake = createAgentHandshake;
+exports.fetchProjectPacket = fetchProjectPacket;
+exports.fetchDomainPacket = fetchDomainPacket;
+const http_1 = require("./http");
+const http_2 = require("./http");
+async function openServerSession(ctx, input) {
+    const baselinePayload = input.sessionBaseline
+        ? {
+            git_head_at_start: input.sessionBaseline.gitHeadAtStart ?? null,
+            dirty_files_at_start: input.sessionBaseline.dirtyFilesAtStart,
+            file_fingerprints_at_start: input.sessionBaseline.dirtyFilesAtStart.map((path) => {
+                const fingerprint = input.sessionBaseline?.fingerprintsAtStart[path];
+                const looksLikeSha = typeof fingerprint === "string" && /^[a-f0-9]{64}$/i.test(fingerprint);
+                const mtime = !looksLikeSha && fingerprint ? Number.parseFloat(fingerprint) : Number.NaN;
+                return {
+                    path,
+                    exists: true,
+                    sha256: looksLikeSha ? fingerprint : null,
+                    mtime_ms: Number.isFinite(mtime) ? mtime : null,
+                    size: null,
+                    file_type: "file",
+                };
+            }),
+            claimed_paths: input.sessionBaseline.claimedPaths,
+            started_at: input.sessionBaseline.startedAt,
+        }
+        : undefined;
+    const res = await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions`, {
+        mode: "execution",
+        change_request_id: input.changeRequestId,
+        execution_surface_id: input.executionSurfaceId,
+        intent: input.intent,
+        declared_intent: input.intent,
+        task_summary: input.intent,
+        active_agent_id: input.activeAgentId,
+        inferred_lane_domain: input.inferredLaneDomain ?? null,
+        claimed_paths: input.claimedPaths,
+        session_baseline: baselinePayload,
+    });
+    const workSessionId = res.id ?? res.session_id;
+    if (!workSessionId) {
+        throw new Error("Server did not return work session id.");
+    }
+    return { workSessionId };
+}
+async function createChangeRequest(ctx, input) {
+    const res = await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/change-requests`, {
+        title: input.title,
+        reason: input.reason,
+        affected_domains: input.affectedDomains ?? [],
+        risk_level: input.riskLevel ?? "medium",
+        scope: input.scope ?? [],
+        owner_work_identity_id: input.ownerWorkIdentityId,
+    });
+    return res.change_request;
+}
+async function getChangeRequest(ctx, changeRequestId) {
+    const res = await (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/change-requests/${encodeURIComponent(changeRequestId)}`);
+    return res.change_request;
+}
+async function updateChangeRequestStatus(ctx, changeRequestId, status) {
+    return updateChangeRequest(ctx, changeRequestId, { status });
+}
+async function updateChangeRequest(ctx, changeRequestId, patch) {
+    const res = await (0, http_1.putJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/change-requests/${encodeURIComponent(changeRequestId)}`, {
+        ...(patch.status !== undefined ? { status: patch.status } : {}),
+        ...(patch.ownerWorkIdentityId !== undefined
+            ? { owner_work_identity_id: patch.ownerWorkIdentityId }
+            : {}),
+        ...(patch.affectedDomains !== undefined
+            ? { affected_domains: patch.affectedDomains }
+            : {}),
+        ...(patch.scope !== undefined ? { scope: patch.scope } : {}),
+    });
+    return res.change_request;
+}
+async function listChangeRequests(ctx, options) {
+    const params = new URLSearchParams();
+    if (options?.status?.trim())
+        params.set("status", options.status.trim());
+    const qs = params.toString();
+    const res = await (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/change-requests${qs ? `?${qs}` : ""}`);
+    return res.change_requests ?? [];
+}
+async function listWorkIdentities(ctx) {
+    const res = await (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/identities`);
+    return res.identities ?? [];
+}
+async function fetchCallerIdentityPacket(ctx) {
+    const response = await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/hello`, { tool_type: "cli" });
+    if (response.identity_model !== "work_identity" || typeof response.work_identity !== "object") {
+        return null;
+    }
+    const workIdentity = response.work_identity;
+    if (typeof workIdentity.id !== "string" || typeof workIdentity.name !== "string") {
+        return null;
+    }
+    const domainCandidate = typeof workIdentity.domain === "object" && workIdentity.domain !== null
+        ? workIdentity.domain
+        : null;
+    const domain = domainCandidate &&
+        typeof domainCandidate.id === "string" &&
+        typeof domainCandidate.name === "string"
+        ? { id: domainCandidate.id, name: domainCandidate.name }
+        : null;
+    return {
+        identity_model: "work_identity",
+        work_identity: {
+            id: workIdentity.id,
+            name: workIdentity.name,
+            domain,
+        },
+    };
+}
+async function postObservedDiff(ctx, binding, payload) {
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(binding.workSessionId)}/observed-diff`, {
+        changed_files: payload.changedFiles,
+        active_lane_domain: payload.activeLaneDomain,
+        source_head: payload.sourceHead,
+        changed_file_entries: payload.changedFileEntries?.map((entry) => ({
+            path: entry.path,
+            status: entry.status,
+            owning_domain: entry.owningDomain,
+            active_lane_domain: entry.activeLaneDomain,
+            crossing: entry.crossing,
+            severity: entry.severity,
+            protection_tier: entry.severity,
+        })),
+        boundary_crossings: payload.boundaryCrossings.map((crossing) => ({
+            file: crossing.file,
+            from_domain: crossing.fromDomain,
+            to_domain: crossing.toDomain,
+            crossing: true,
+            severity: crossing.severity,
+            protection_tier: crossing.severity,
+        })),
+        file_fingerprints: (payload.fileFingerprints ?? []).map((fingerprint) => ({
+            path: fingerprint.path,
+            exists: fingerprint.exists,
+            file_type: fingerprint.fileType,
+            size: fingerprint.size,
+            mtime_ms: fingerprint.mtimeMs,
+            sha256: fingerprint.sha256,
+        })),
+    });
+}
+async function postScopedApproval(ctx, binding, payload) {
+    const decision = payload.decision === "approve"
+        ? "approved"
+        : payload.decision === "deny"
+            ? "denied"
+            : payload.decision === "limit_scope"
+                ? "limited"
+                : payload.decision === "handoff"
+                    ? "handoff_required"
+                    : "abandoned";
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(binding.workSessionId)}/approvals`, {
+        kind: "scoped_approval",
+        session_id: binding.workSessionId,
+        requesting_agent: payload.activeAgentId,
+        owner_agent: payload.ownerAgentId,
+        decision,
+        expires_on_session_close: true,
+        target_domain: payload.targetDomain,
+        approved_files: payload.approvedFiles,
+        limit_mode: payload.limitMode,
+        reason: payload.reason,
+    });
+}
+async function closeServerSession(ctx, binding, payload) {
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(binding.workSessionId)}/close`, {
+        close_outcome: payload.closeOutcome,
+        close_reason: payload.closeReason ?? payload.closeOutcome,
+        note: payload.note,
+        target_agent_id: payload.targetAgentId,
+        target_domain: payload.targetDomain,
+        files_involved: payload.filesInvolved,
+        changed_files: payload.changedFiles,
+        domain_breakdown: payload.domainBreakdown,
+        crossings: payload.crossings?.map((crossing) => ({
+            file: crossing.file,
+            domain: crossing.domain,
+            status: crossing.status,
+            tier: crossing.tier,
+        })),
+        scoped_approvals: payload.scopedApprovals,
+        test_summary: payload.testSummary,
+        implementation_handoff: payload.implementationHandoff,
+    });
+}
+async function fetchAcceptanceCheck(ctx, options) {
+    const rolloutParams = new URLSearchParams();
+    if (options?.rolloutProofTooWeak) {
+        rolloutParams.set("rollout_proof_too_weak", options.rolloutProofTooWeak);
+    }
+    if (options?.rolloutProofNotRelevant) {
+        rolloutParams.set("rollout_proof_not_relevant", options.rolloutProofNotRelevant);
+    }
+    if (options?.rolloutImpactCoverageGap) {
+        rolloutParams.set("rollout_impact_coverage_gap", options.rolloutImpactCoverageGap);
+    }
+    const rolloutSuffix = rolloutParams.toString();
+    if (options?.workSessionId) {
+        const qs = rolloutSuffix ? `?${rolloutSuffix}` : "";
+        return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(options.workSessionId)}/acceptance-check${qs}`);
+    }
+    const queryParams = new URLSearchParams(rolloutParams);
+    if (options?.changeRequestId && options.changeRequestId.trim().length > 0) {
+        queryParams.set("change_request_id", options.changeRequestId);
+    }
+    const query = queryParams.toString();
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/current/acceptance-check${query ? `?${query}` : ""}`);
+}
+/**
+ * One-shot Agent Watch review fast path. Collapses cold-create / resume +
+ * observed-diff sync + acceptance check into a single bounded server call.
+ * Throws CliHttpError(404) when the server build predates this endpoint;
+ * callers should treat that as "fall back to the legacy multi-call flow".
+ */
+async function reviewOnceForWatch(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/watch/review-once`, {
+        task_summary: input.taskSummary,
+        scope: input.scope,
+        domain: input.domain ?? null,
+        local_session_id: input.localSessionId ?? null,
+        local_change_request_id: input.localChangeRequestId ?? null,
+        changed_files: input.changedFiles,
+        scoped_files: input.scopedFiles,
+        out_of_scope_files: input.outOfScopeFiles,
+        file_fingerprints: (input.fileFingerprints ?? []).map((fingerprint) => ({
+            path: fingerprint.path,
+            exists: fingerprint.exists,
+            file_type: fingerprint.fileType,
+            size: fingerprint.size,
+            mtime_ms: fingerprint.mtimeMs,
+            sha256: fingerprint.sha256,
+        })),
+        source_head: input.sourceHead ?? null,
+        allow_dirty: input.allowDirty,
+        once: true,
+    });
+}
+/**
+ * True when an error means the fast review-once endpoint is unavailable on the
+ * connected server (older build), so the caller should fall back to the legacy
+ * start → observed-diff → acceptance-check flow.
+ */
+function isWatchFastPathUnavailable(err) {
+    return err instanceof http_2.CliHttpError && (err.status === 404 || err.status === 405);
+}
+async function fetchMemorySuggestion(ctx, options) {
+    const params = new URLSearchParams();
+    if (options?.workSessionId?.trim()) {
+        params.set("work_session_id", options.workSessionId.trim());
+    }
+    if (options?.changeRequestId?.trim()) {
+        params.set("change_request_id", options.changeRequestId.trim());
+    }
+    if (options?.domain?.trim()) {
+        params.set("domain", options.domain.trim());
+    }
+    const qs = params.toString();
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/suggest${qs ? `?${qs}` : ""}`);
+}
+async function applyMemoryCandidateRequest(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/candidates/apply`, {
+        scope: input.scope,
+        domain: input.domain,
+        items: input.items,
+        reviewer_note: input.reviewerNote,
+        candidate: input.candidate,
+    });
+}
+async function rejectMemoryCandidateRequest(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/candidates/reject`, {
+        reviewer_note: input.reviewerNote,
+        candidate: input.candidate,
+    });
+}
+async function deferMemoryCandidateRequest(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/candidates/defer`, {
+        reviewer_note: input.reviewerNote,
+        candidate: input.candidate,
+    });
+}
+async function revertMemoryCandidateRequest(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/candidates/revert`, {
+        approval_audit_id: input.approvalAuditId,
+        reviewer_note: input.reviewerNote,
+        force: input.force,
+    });
+}
+async function intakeEscapedBugRequest(ctx, finding) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/memory/escaped-bug`, finding);
+}
+function isNoActiveSessionError(err) {
+    if (!(err instanceof http_2.CliHttpError) || err.status !== 404)
+        return false;
+    try {
+        const parsed = JSON.parse(err.body);
+        return parsed.error === "active_work_session_not_found" || parsed.code === "active_work_session_not_found";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * @deprecated Prefer resolveWorkContext — never resolves cross-CR sessions without explicit CR.
+ */
+async function resolveCurrentServerSession(ctx, options) {
+    if (!options?.changeRequestId?.trim()) {
+        return null;
+    }
+    try {
+        const report = await fetchAcceptanceCheck(ctx, {
+            changeRequestId: options.changeRequestId,
+        });
+        return { workSessionId: report.work_session_id };
+    }
+    catch (err) {
+        if (isNoActiveSessionError(err))
+            return null;
+        throw err;
+    }
+}
+async function listWorkSessions(ctx, options) {
+    const params = new URLSearchParams();
+    if (options?.status)
+        params.set("status", options.status);
+    if (options?.crId?.trim())
+        params.set("cr_id", options.crId.trim());
+    const qs = params.toString();
+    const res = await (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions${qs ? `?${qs}` : ""}`);
+    return res.sessions ?? [];
+}
+async function getWorkSession(ctx, workSessionId) {
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(workSessionId)}`);
+}
+async function cancelWorkSession(ctx, workSessionId, reason) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(workSessionId)}/cancel`, { reason });
+}
+async function postVerificationRun(ctx, binding, payload) {
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(binding.workSessionId)}/verification-runs`, {
+        command: payload.command,
+        started_at: payload.startedAt,
+        finished_at: payload.finishedAt,
+        exit_code: payload.exitCode,
+        stdout_excerpt: payload.stdoutExcerpt,
+        stderr_excerpt: payload.stderrExcerpt,
+        git_head: payload.gitHead,
+        changed_files_snapshot: payload.changedFilesSnapshot,
+        proof_scope_files: payload.proofScopeFiles,
+        proof_scope_source: payload.proofScopeSource,
+        repo_dirty_snapshot: payload.repoDirtySnapshot,
+        proof_scope_fingerprints: (payload.proofScopeFingerprints ?? []).map((fingerprint) => ({
+            path: fingerprint.path,
+            exists: fingerprint.exists,
+            file_type: fingerprint.fileType,
+            size: fingerprint.size,
+            mtime_ms: fingerprint.mtimeMs,
+            sha256: fingerprint.sha256,
+        })),
+        status: payload.status,
+        ...(payload.conditions ? { conditions: payload.conditions } : {}),
+        ...(payload.confidence ? { confidence: payload.confidence } : {}),
+    });
+}
+async function postHandoff(ctx, payload) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/handoffs`, {
+        completed: payload.summary,
+        changed_files: payload.changedFiles,
+        commands_run: payload.commandsRun,
+        domains_touched: payload.domainsTouched,
+        review_required: payload.reviewRequired,
+        risks_remaining: payload.risksRemaining ?? null,
+        next_cr_recommended: payload.nextCrRecommended ?? null,
+        do_not_touch_notes: payload.doNotTouchNotes ?? null,
+        work_session_id: payload.workSessionId,
+    });
+}
+async function acceptWorkSession(ctx, binding) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(binding.workSessionId)}/accept`, {});
+}
+async function createAgentHandshake(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/handshakes`, {
+        change_request_id: input.changeRequestId,
+        work_session_id: input.workSessionId,
+        requested_domain: input.requestedDomain,
+        requested_action: input.requestedAction,
+        reason: input.reason,
+    });
+}
+async function fetchProjectPacket(ctx) {
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/packet`);
+}
+async function fetchDomainPacket(ctx, payload) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/packet/domain`, {
+        domain_name: payload.domainName,
+        domains: payload.domains,
+        intent: payload.intent,
+        claimed_paths: payload.claimedPaths,
+        limit: payload.limit,
+    });
+}

package/dist/session-state.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSessionState = readSessionState;
+exports.writeSessionState = writeSessionState;
+exports.archiveClosedSession = archiveClosedSession;
+exports.archiveHandoff = archiveHandoff;
+exports.readRecentHandoffs = readRecentHandoffs;
+exports.clearSessionState = clearSessionState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const SESSION_PATH = (0, node_path_1.resolve)(process.cwd(), ".agentbridge", "session.json");
+const SESSIONS_DIR = (0, node_path_1.resolve)(process.cwd(), ".agentbridge", "sessions");
+const HANDOFFS_DIR = (0, node_path_1.resolve)(process.cwd(), ".agentbridge", "handoffs");
+const SESSION_DIR = (0, node_path_1.resolve)(process.cwd(), ".agentbridge");
+const SESSION_BACKUP_PATH = (0, node_path_1.resolve)(SESSION_DIR, "session.json.bak");
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isDomainOwnershipArray(value) {
+    return Array.isArray(value);
+}
+function isBoundaryCrossingArray(value) {
+    return Array.isArray(value);
+}
+function isScopedApprovalArray(value) {
+    return Array.isArray(value);
+}
+function isLocalSessionState(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== "string" || value.id.length === 0)
+        return false;
+    if (typeof value.agentId !== "string" || value.agentId.length === 0)
+        return false;
+    if (value.laneDomain !== null && typeof value.laneDomain !== "string")
+        return false;
+    if (!["active", "blocked", "closed"].includes(String(value.status)))
+        return false;
+    if (!isStringArray(value.changedFiles))
+        return false;
+    if (!isBoundaryCrossingArray(value.crossings))
+        return false;
+    if (!isScopedApprovalArray(value.approvals))
+        return false;
+    if (!isDomainOwnershipArray(value.domains))
+        return false;
+    if (typeof value.createdAt !== "string" || value.createdAt.length === 0)
+        return false;
+    if (value.claimedPaths !== undefined && !isStringArray(value.claimedPaths))
+        return false;
+    return true;
+}
+function readJsonFile(path) {
+    return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+}
+function quarantineInvalidSessionFile() {
+    if (!(0, node_fs_1.existsSync)(SESSION_PATH))
+        return;
+    const quarantinedPath = (0, node_path_1.resolve)(SESSION_DIR, `session.invalid-${new Date().toISOString().replace(/[:.]/g, "-")}.json`);
+    (0, node_fs_1.renameSync)(SESSION_PATH, quarantinedPath);
+}
+function readSessionState() {
+    if (!(0, node_fs_1.existsSync)(SESSION_PATH)) {
+        return null;
+    }
+    try {
+        const parsed = readJsonFile(SESSION_PATH);
+        if (!isLocalSessionState(parsed)) {
+            quarantineInvalidSessionFile();
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        quarantineInvalidSessionFile();
+        return null;
+    }
+}
+function writeSessionState(state) {
+    if (!isLocalSessionState(state)) {
+        throw new Error("Refusing to write invalid session state.");
+    }
+    (0, node_fs_1.mkdirSync)(SESSION_DIR, { recursive: true });
+    const tempPath = (0, node_path_1.resolve)(SESSION_DIR, `session.json.tmp-${process.pid.toString()}-${Date.now().toString(36)}`);
+    const serialized = `${JSON.stringify(state, null, 2)}\n`;
+    (0, node_fs_1.writeFileSync)(tempPath, serialized, "utf8");
+    const tempParsed = readJsonFile(tempPath);
+    if (!isLocalSessionState(tempParsed)) {
+        (0, node_fs_1.rmSync)(tempPath, { force: true });
+        throw new Error("Refusing to persist invalid session state payload.");
+    }
+    if ((0, node_fs_1.existsSync)(SESSION_PATH)) {
+        (0, node_fs_1.renameSync)(SESSION_PATH, SESSION_BACKUP_PATH);
+    }
+    (0, node_fs_1.renameSync)(tempPath, SESSION_PATH);
+}
+function timestampPrefix(iso) {
+    return iso.replace(/[:.]/g, "-");
+}
+function writeArchive(dir, state) {
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const at = state.closeReason ? new Date().toISOString() : state.createdAt;
+    const fileName = `${timestampPrefix(at)}-${state.id}.json`;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(dir, fileName), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function archiveClosedSession(state) {
+    writeArchive(SESSIONS_DIR, state);
+}
+function archiveHandoff(state) {
+    writeArchive(HANDOFFS_DIR, state);
+}
+function readRecentHandoffs(limit = 1) {
+    if (!(0, node_fs_1.existsSync)(HANDOFFS_DIR)) {
+        return [];
+    }
+    const files = (0, node_fs_1.readdirSync)(HANDOFFS_DIR)
+        .filter((file) => file.endsWith(".json"))
+        .sort((a, b) => b.localeCompare(a))
+        .slice(0, Math.max(0, limit));
+    return files.map((file) => JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(HANDOFFS_DIR, file), "utf8")));
+}
+function clearSessionState() {
+    writeSessionState({
+        id: "none",
+        agentId: "none",
+        laneDomain: null,
+        status: "closed",
+        closeReason: "completed",
+        changedFiles: [],
+        crossings: [],
+        approvals: [],
+        domains: [],
+        createdAt: new Date(0).toISOString(),
+    });
+}

package/dist/session.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openExecutionSession = openExecutionSession;
+exports.captureLocalSessionBaseline = captureLocalSessionBaseline;
+exports.openLocalSession = openLocalSession;
+exports.closeLocalSession = closeLocalSession;
+const node_child_process_1 = require("node:child_process");
+const http_1 = require("./http");
+const session_state_1 = require("./session-state");
+const watch_core_1 = require("./watch-core");
+const file_fingerprints_1 = require("./file-fingerprints");
+const git_status_1 = require("./git-status");
+async function openExecutionSession(ctx, input) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions`, {
+        mode: "execution",
+        change_request_id: input.changeRequestId,
+        execution_surface_id: input.executionSurfaceId,
+        intent: input.intent,
+        claimed_paths: input.claimedPaths,
+    });
+}
+function captureGitDirtyFiles() {
+    return (0, git_status_1.repoDirtySnapshotFromGitStatus)();
+}
+function captureGitHead() {
+    try {
+        return (0, node_child_process_1.execSync)("git rev-parse HEAD", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function captureLocalSessionBaseline() {
+    const startedAt = new Date().toISOString();
+    const dirtyFilesAtStart = captureGitDirtyFiles();
+    const gitHead = captureGitHead() ?? undefined;
+    const fingerprintsAtStart = {};
+    for (const fp of (0, file_fingerprints_1.computeFileFingerprints)(dirtyFilesAtStart)) {
+        if (fp.exists) {
+            fingerprintsAtStart[fp.path] = fp.sha256 ?? fp.mtimeMs?.toString() ?? "";
+        }
+    }
+    return {
+        startedAt,
+        gitHead,
+        dirtyFilesAtStart,
+        fingerprintsAtStart,
+    };
+}
+function openLocalSession(input) {
+    const claimedPaths = [...new Set((input.claimedPaths ?? []).map((path) => path.trim()).filter(Boolean))];
+    const baseline = captureLocalSessionBaseline();
+    const state = {
+        id: `local_${Date.now().toString(36)}`,
+        agentId: input.agentId,
+        laneDomain: input.laneDomain,
+        changeRequestId: input.changeRequestId,
+        claimedPaths,
+        status: "active",
+        changedFiles: [],
+        crossings: [],
+        approvals: [],
+        domains: input.domains,
+        serverSessionId: input.serverSessionId,
+        pendingHandoffToAgent: input.pendingHandoffToAgent,
+        pendingHandoffDomain: input.pendingHandoffDomain,
+        createdAt: baseline.startedAt,
+        startedAt: baseline.startedAt,
+        gitHead: baseline.gitHead,
+        dirtyFilesAtStart: baseline.dirtyFilesAtStart,
+        fingerprintsAtStart: baseline.fingerprintsAtStart,
+    };
+    (0, session_state_1.writeSessionState)(state);
+    return state;
+}
+function closeLocalSession(state) {
+    const closable = (0, watch_core_1.canCloseSession)(state);
+    if (!closable.ok) {
+        return { ok: false, reason: closable.reason ?? "Session blocked" };
+    }
+    state.status = "closed";
+    state.closeReason = state.closeReason ?? "completed";
+    (0, session_state_1.archiveClosedSession)(state);
+    (0, session_state_1.writeSessionState)(state);
+    return { ok: true };
+}