@overdeck/desktop 0.47.1 → 0.48.0

package/server/{src-Dm_NV7f6.js → src-DQnkPN2i.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { i as init_esm_min, n as FormData, o as Blob, r as formDataToBlob, s as init_fetch_blob, t as init_from } from "./from-DxGcivc9.js";
+import { i as init_esm_min, n as FormData, o as Blob, r as formDataToBlob, s as init_fetch_blob, t as init_from } from "./from-BogSwvr2.js";
 import { deprecate, promisify, types } from "node:util";
 import { format } from "node:url";
 import http from "node:http";
@@ -209,7 +209,7 @@ var init_body = __esmMin((() => {
 				for (const [name, value] of parameters) formData.append(name, value);
 				return formData;
 			}
-			const { toFormData } = await import("./multipart-parser-D0twwRjz.js");
+			const { toFormData } = await import("./multipart-parser-CL5QG8iv.js");
 			return toFormData(this.body, ct);
 		}
 		/**
@@ -1176,4 +1176,4 @@ __esmMin((() => {
 }))();
 export { fetch as default };
 
-//# sourceMappingURL=src-Dm_NV7f6.js.map
+//# sourceMappingURL=src-DQnkPN2i.js.map

package/server/{src-B2e5rGu2.js → src-DhfDV0o4.js}

@@ -1,6 +1,6 @@
 import { i as __require, o as __toESM, t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { r as init_esm_shims, t as __dirname } from "./esm-shims-CaBWIR7f.js";
-import { n as require_dist$1, r as require_src$14, t as require_dist$2 } from "./dist-C5FT9lTG.js";
+import { r as init_esm_shims, t as __dirname } from "./esm-shims-Bzy4ZzNU.js";
+import { n as require_dist$1, r as require_src$14, t as require_dist$2 } from "./dist-3W--cGMa.js";
 //#region ../../../node_modules/.bun/@google-cloud+promisify@4.1.0/node_modules/@google-cloud/promisify/build/src/index.js
 var require_src$13 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -1198,12 +1198,12 @@ var require_gaxios = /* @__PURE__ */ __commonJSMin(((exports) => {
 		* @returns A proxy agent
 		*/
 		static async #getProxyAgent() {
-			this.#proxyAgent ||= (await import("./dist-qcf9gAP0.js").then((m) => /* @__PURE__ */ __toESM(m.default))).HttpsProxyAgent;
+			this.#proxyAgent ||= (await import("./dist-BR0QtwmS.js").then((m) => /* @__PURE__ */ __toESM(m.default))).HttpsProxyAgent;
 			return this.#proxyAgent;
 		}
 		static async #getFetch() {
 			const hasWindow = typeof window !== "undefined" && !!window;
-			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-Dm_NV7f6.js")).default;
+			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-DQnkPN2i.js")).default;
 			return this.#fetch;
 		}
 		/**
@@ -10601,7 +10601,7 @@ var require_src$7 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const TeenyStatistics_1 = require_TeenyStatistics();
 	const crypto_1 = __require("crypto");
 	const streamEvents = require_stream_events();
-	const fetch = (...args) => import("./src-Dm_NV7f6.js").then(({ default: fetch }) => fetch(...args));
+	const fetch = (...args) => import("./src-DQnkPN2i.js").then(({ default: fetch }) => fetch(...args));
 	var RequestError = class extends Error {
 		code;
 	};
@@ -133656,4 +133656,4 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports) => {
 export default require_src();
 export {};
 
-//# sourceMappingURL=src-B2e5rGu2.js.map
+//# sourceMappingURL=src-DhfDV0o4.js.map

package/server/{stack-health-Bf2WdG4E.js → stack-health-D_iKwNRg.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Gn as init_projects, ar as resolveProjectFromIssueSync, gr as init_issue_id, vr as parseIssueIdSync, zn as getProjectSync } from "./config-yaml-CxdwhAIA.js";
-import { o as init_activity_logger, r as emitActivityEntrySync } from "./activity-logger-CyteR4JO.js";
+import { Fn as parseIssueIdSync, Nn as init_issue_id, Sn as resolveProjectFromIssueSync, cn as init_projects, nn as getProjectSync } from "./config-yaml-BSCqwmX0.js";
+import { a as emitActivityEntrySync, c as init_activity_logger } from "./activity-logger-Co5qljIj.js";
 import { join } from "node:path";
 import { Duration, Effect, Schedule, Stream } from "effect";
 import { existsSync, readFileSync } from "node:fs";
@@ -177,33 +177,116 @@ var init_docker_stats = __esmMin((() => {
 }));
 //#endregion
 //#region ../../lib/workspace/stack-health.ts
+/**
+* Canonical compose-project-name resolver (PAN-3049).
+*
+* `composeProjectNameForWorkspace` / `requireComposeProjectNameForWorkspace`
+* are the ONLY place a workspace's Docker Compose project name is derived.
+* A workspace's compose project is whatever it DECLARES — the dev-script
+* `COMPOSE_PROJECT_NAME` or a compose file's top-level `name:` field — never
+* an independently re-guessed prefix. Every consumer (rebuild, teardown,
+* health checks, reapers, doctor) must call through this module rather than
+* re-deriving the name; two independent derivations disagreeing is exactly
+* what let a duplicate `overdeck-feature-*` stack spring up beside a
+* workspace's real `myn-feature-*` one. See docs/WORKSPACE-CONTAINERS.md
+* ("Compose project naming") for the full contract.
+*/
 function declaredComposeProjectName(content, featureFolder) {
 	const templatedMatch = content.match(/COMPOSE_PROJECT_NAME="([^$"]*)\$\{FEATURE_FOLDER\}"/);
 	if (templatedMatch) return `${templatedMatch[1]}${featureFolder}`;
 	return content.match(/COMPOSE_PROJECT_NAME="([^"]+)"/)?.[1] ?? null;
 }
+function findDevcontainerComposeFile(workspacePath) {
+	const devcontainerDir = join(workspacePath, ".devcontainer");
+	for (const file of COMPOSE_FILE_CANDIDATES) {
+		const fullPath = join(devcontainerDir, file);
+		if (existsSync(fullPath)) return fullPath;
+	}
+	return null;
+}
+/** Parse a top-level (unindented) compose `name:` key, e.g. `name: myn-feature-min-901`. */
+function declaredComposeFileProjectName(content, featureFolder) {
+	const match = content.match(/^name:\s*['"]?([^'"\n]+?)['"]?\s*$/m);
+	if (!match) return null;
+	const raw = match[1].trim();
+	return raw.includes("${FEATURE_FOLDER}") ? raw.replace("${FEATURE_FOLDER}", featureFolder) : raw;
+}
+function assertValidComposeProjectNameGrammar(sourcePath, declaredKey, declared) {
+	if (!VALID_COMPOSE_PROJECT_NAME_RE.test(declared)) throw new Error(`Refusing workspace rebuild: ${sourcePath} declares ${declaredKey}=${declared}, which is not a valid Docker Compose project name (lowercase letters, digits, hyphens, and underscores only, starting with a letter or digit)`);
+}
+function assertDeclaredNameMatchesFeatureFolder(sourcePath, declaredKey, declared, featureFolder) {
+	assertValidComposeProjectNameGrammar(sourcePath, declaredKey, declared);
+	if (!declared.endsWith(featureFolder)) throw new Error(`Refusing workspace rebuild: ${sourcePath} declares ${declaredKey}=${declared}, expected a name ending in ${featureFolder}`);
+}
 /**
-* Derive the canonical `COMPOSE_PROJECT_NAME` for a workspace. Throws when the
-* workspace declares a name that does not end in the feature folder — a
-* mismatch means `docker compose down` would target the wrong stack.
-* (Lives here rather than in rebuild-stack so health checks can scope
-* container matching without an import cycle.)
+* Resolve the compose project name declared by the workspace's dev script or
+* devcontainer compose file, without applying the `overdeck-` fallback.
+* Returns `{ name: null, composeFilePath }` when neither source declares one —
+* `composeFilePath` is non-null when a compose file exists so callers can
+* report where they looked.
 */
-function composeProjectNameForWorkspace(workspacePath, issueId) {
-	const featureFolder = `feature-${issueId.toLowerCase()}`;
-	const fallback = `overdeck-${featureFolder}`;
+function resolveDeclaredComposeProjectName(workspacePath, featureFolder) {
 	for (const devPath of [join(workspacePath, ".devcontainer", "dev"), join(workspacePath, "dev")]) {
 		if (!existsSync(devPath)) continue;
 		try {
 			const declared = declaredComposeProjectName(readFileSync(devPath, "utf-8"), featureFolder);
 			if (!declared) continue;
-			if (!declared.endsWith(featureFolder)) throw new Error(`Refusing workspace rebuild: ${devPath} declares COMPOSE_PROJECT_NAME=${declared}, expected a name ending in ${featureFolder}`);
-			return declared;
+			assertDeclaredNameMatchesFeatureFolder(devPath, "COMPOSE_PROJECT_NAME", declared, featureFolder);
+			return {
+				name: declared,
+				composeFilePath: null
+			};
 		} catch (err) {
 			if (err instanceof Error && err.message.startsWith("Refusing workspace rebuild:")) throw err;
 		}
 	}
-	return fallback;
+	const composeFilePath = findDevcontainerComposeFile(workspacePath);
+	if (!composeFilePath) return {
+		name: null,
+		composeFilePath: null
+	};
+	const declared = declaredComposeFileProjectName(readFileSync(composeFilePath, "utf-8"), featureFolder);
+	if (!declared) return {
+		name: null,
+		composeFilePath
+	};
+	assertDeclaredNameMatchesFeatureFolder(composeFilePath, "name", declared, featureFolder);
+	return {
+		name: declared,
+		composeFilePath
+	};
+}
+/**
+* Derive the canonical `COMPOSE_PROJECT_NAME` for a workspace. Throws when the
+* workspace declares a name that does not end in the feature folder — a
+* mismatch means `docker compose down` would target the wrong stack.
+* (Lives here rather than in rebuild-stack so health checks can scope
+* container matching without an import cycle.)
+*
+* Silently falls back to `overdeck-feature-<issue>` when no dev script or
+* compose file declares a name. Use `requireComposeProjectNameForWorkspace`
+* at bring-up time, where a workspace with a compose file but no resolvable
+* name is a bug to surface, not a condition to paper over with a guess.
+*/
+function composeProjectNameForWorkspace(workspacePath, issueId) {
+	const featureFolder = `feature-${issueId.toLowerCase()}`;
+	const fallback = `overdeck-${featureFolder}`;
+	return resolveDeclaredComposeProjectName(workspacePath, featureFolder).name ?? fallback;
+}
+/**
+* Strict counterpart to `composeProjectNameForWorkspace`. When a devcontainer
+* compose file exists but neither it nor any dev script declares a name,
+* throws instead of silently returning the `overdeck-` fallback — that
+* silent guess is what let a second stack spring up beside a workspace's real
+* `myn-feature-*` stack (PAN-3049). Non-docker workspaces (no compose file at
+* all) still resolve to the `overdeck-` fallback, matching the lenient variant.
+*/
+function requireComposeProjectNameForWorkspace(workspacePath, issueId) {
+	const featureFolder = `feature-${issueId.toLowerCase()}`;
+	const resolved = resolveDeclaredComposeProjectName(workspacePath, featureFolder);
+	if (resolved.name) return resolved.name;
+	if (!resolved.composeFilePath) return `overdeck-${featureFolder}`;
+	throw new Error(`Cannot resolve compose project name for workspace ${workspacePath}: ${resolved.composeFilePath} declares no top-level 'name:' and neither ${join(workspacePath, ".devcontainer", "dev")} nor ${join(workspacePath, "dev")} declares COMPOSE_PROJECT_NAME`);
 }
 /**
 * Best-effort canonical compose project for a workspace — null when the
@@ -331,7 +414,7 @@ function recordWorkspaceStackHealthTransition(issueId, health) {
 	});
 	return true;
 }
-var execFileAsync, DEFAULT_STUCK_CREATED_THRESHOLD_MS, lastHealthByIssue, collectDockerContainerLifecycleSnapshot, getWorkspaceStackHealth;
+var execFileAsync, DEFAULT_STUCK_CREATED_THRESHOLD_MS, COMPOSE_FILE_CANDIDATES, VALID_COMPOSE_PROJECT_NAME_RE, lastHealthByIssue, collectDockerContainerLifecycleSnapshot, getWorkspaceStackHealth;
 var init_stack_health = __esmMin((() => {
 	init_activity_logger();
 	init_docker_stats();
@@ -339,6 +422,14 @@ var init_stack_health = __esmMin((() => {
 	init_projects();
 	execFileAsync = promisify(execFile);
 	DEFAULT_STUCK_CREATED_THRESHOLD_MS = 12e4;
+	COMPOSE_FILE_CANDIDATES = [
+		"docker-compose.devcontainer.yml",
+		"docker-compose.yml",
+		"docker-compose.yaml",
+		"compose.yml",
+		"compose.yaml"
+	];
+	VALID_COMPOSE_PROJECT_NAME_RE = /^[a-z0-9][a-z0-9_-]*$/;
 	lastHealthByIssue = /* @__PURE__ */ new Map();
 	collectDockerContainerLifecycleSnapshot = () => Effect.tryPromise({
 		try: () => execFileAsync("docker", [
@@ -406,6 +497,6 @@ var init_stack_health = __esmMin((() => {
 	});
 }));
 //#endregion
-export { getWorkspaceStackHealth as a, recordWorkspaceStackHealthTransition as c, init_docker_stats as d, recordDockerContainerLifecycleSnapshot as f, evaluateWorkspaceStackHealth as i, tryComposeProjectNameForWorkspace as l, collectDockerContainerLifecycleSnapshot as n, hasIssueToken as o, composeProjectNameForWorkspace as r, init_stack_health as s, DEFAULT_STUCK_CREATED_THRESHOLD_MS as t, DockerStatsCollector as u };
+export { evaluateWorkspaceStackHealth as a, init_stack_health as c, tryComposeProjectNameForWorkspace as d, DockerStatsCollector as f, defaultWorkspacePath as i, recordWorkspaceStackHealthTransition as l, recordDockerContainerLifecycleSnapshot as m, collectDockerContainerLifecycleSnapshot as n, getWorkspaceStackHealth as o, init_docker_stats as p, composeProjectNameForWorkspace as r, hasIssueToken as s, DEFAULT_STUCK_CREATED_THRESHOLD_MS as t, requireComposeProjectNameForWorkspace as u };
 
-//# sourceMappingURL=stack-health-Bf2WdG4E.js.map
+//# sourceMappingURL=stack-health-D_iKwNRg.js.map

package/server/stack-health-deVSdDwn.js

@@ -0,0 +1,3 @@
+import { c as init_stack_health, o as getWorkspaceStackHealth } from "./stack-health-D_iKwNRg.js";
+init_stack_health();
+export { getWorkspaceStackHealth };

package/server/{stale-task-claims-D1Ll8fI5.js → stale-task-claims-BYJGqhLI.js}

@@ -1,7 +1,7 @@
-import { At as getIssueRecordPath, Gn as init_projects, Pt as init_record, Yn as listProjectsSync, zt as readIssueRecordSync } from "./config-yaml-CxdwhAIA.js";
-import { n as init_fs_lock, r as isPidDead } from "./fs-lock-Bre3sGoz.js";
-import { i as updateIssueRecord, r as init_record_update } from "./record-update-DaOKS7Wb.js";
-import { c as listAllAgentsSync, o as init_agents } from "./agents-CtACUuVG.js";
+import { Q as readIssueRecordSync, U as getIssueRecordPath, cn as init_projects, fn as listProjectsSync, q as init_record } from "./config-yaml-BSCqwmX0.js";
+import { n as init_fs_lock, r as isPidDead } from "./fs-lock-D_GeJtXl.js";
+import { i as updateIssueRecord, r as init_record_update } from "./record-update-CZh46a2f.js";
+import { c as listAllAgentsSync, o as init_agents } from "./agents-Dls7tfJH.js";
 import { dirname } from "node:path";
 import { hostname } from "node:os";
 import { readdirSync } from "node:fs";
@@ -67,4 +67,4 @@ async function patrolStaleTaskClaims() {
 //#endregion
 export { patrolStaleTaskClaims };
 
-//# sourceMappingURL=stale-task-claims-D1Ll8fI5.js.map
+//# sourceMappingURL=stale-task-claims-BYJGqhLI.js.map

package/server/{staleness-CuED1Psm.js → staleness-CopBDKnA.js}

@@ -1,3 +1,3 @@
-import { i as init_staleness, n as _resetForTests, r as computeBuildStaleness, t as BUILD_INPUT_PATHS } from "./staleness-45qZ_a60.js";
+import { i as init_staleness, n as _resetForTests, r as computeBuildStaleness, t as BUILD_INPUT_PATHS } from "./staleness-D8WeMUHd.js";
 init_staleness();
 export { BUILD_INPUT_PATHS, _resetForTests, computeBuildStaleness };

package/server/{staleness-45qZ_a60.js → staleness-D8WeMUHd.js}

@@ -141,4 +141,4 @@ var init_staleness = __esmMin((() => {
 //#endregion
 export { init_staleness as i, _resetForTests as n, computeBuildStaleness as r, BUILD_INPUT_PATHS as t };
 
-//# sourceMappingURL=staleness-45qZ_a60.js.map
+//# sourceMappingURL=staleness-D8WeMUHd.js.map

package/server/{state-home-B4EWfIxF.js → state-home-DjN8qduI.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { En as projectKey, Gn as init_projects, Tn as init_project_key, ci as getOverdeckHome, fn as STATE_BRANCH_PATHS, hn as init_state_plane, li as init_paths, rr as resolveInfraRepo } from "./config-yaml-CxdwhAIA.js";
+import { Et as STATE_BRANCH_PATHS, Ht as init_project_key, Ut as projectKey, bn as resolveInfraRepo, cn as init_projects, hi as init_paths, kt as init_state_plane, mi as getOverdeckHome } from "./config-yaml-BSCqwmX0.js";
 import { dirname, join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
@@ -170,6 +170,27 @@ async function findRecreatedLegacyStatePaths(project) {
 	const legacyStateRoot = project.path;
 	return STATE_BRANCH_PATHS.map((statePath) => join(legacyStateRoot, ".pan", statePath.slice(0, -1))).filter(existsSync);
 }
+/**
+* Synchronous read-door resolution for legacy synchronous APIs. The async
+* resolver remains authoritative for migration detection; this compatibility
+* door uses only an already-materialized, valid state-worktree marker and
+* otherwise falls back read-only to the legacy checkout.
+*/
+function resolveStateReadHomeSync(project, options = {}) {
+	const worktreePath = stateWorktreePath(project, options);
+	if (readMigrationCompleteMarker(join(worktreePath, "migration-complete.json"))) return {
+		root: worktreePath,
+		migrated: true
+	};
+	return {
+		root: resolveInfraRepo(project).repoPath,
+		migrated: false
+	};
+}
+function resolveStateDomainPathSync(project, domain, options = {}) {
+	const home = resolveStateReadHomeSync(project, options);
+	return home.migrated ? join(home.root, domain) : join(home.root, ".pan", domain);
+}
 async function addStateWorktree(repoPath, path, signal) {
 	signal?.throwIfAborted();
 	await mkdir(dirname(path), { recursive: true });
@@ -271,6 +292,6 @@ var init_state_home = __esmMin((() => {
 	migrationCache = /* @__PURE__ */ new Map();
 }));
 //#endregion
-export { findRecreatedLegacyStatePaths as a, isStateMigrated as c, ensureStateWorktree as i, stateWorktreePath as l, STATE_BRANCH as n, init_state_home as o, clearStateMigrationCache as r, inspectStateMigration as s, MIGRATION_COMPLETE_MARKER as t };
+export { findRecreatedLegacyStatePaths as a, isStateMigrated as c, ensureStateWorktree as i, resolveStateDomainPathSync as l, STATE_BRANCH as n, init_state_home as o, clearStateMigrationCache as r, inspectStateMigration as s, MIGRATION_COMPLETE_MARKER as t, stateWorktreePath as u };
 
-//# sourceMappingURL=state-home-B4EWfIxF.js.map
+//# sourceMappingURL=state-home-DjN8qduI.js.map

package/server/{state-mapping-BEONzr8P.js → state-mapping-DlM7OYRW.js}

@@ -29,4 +29,4 @@ var init_state_mapping = __esmMin((() => {}));
 //#endregion
 export { mapGitHubStateToCanonical as n, init_state_mapping as t };
 
-//# sourceMappingURL=state-mapping-BEONzr8P.js.map
+//# sourceMappingURL=state-mapping-DlM7OYRW.js.map

package/server/{state-migrate-Cd8BH33U.js → state-migrate-a2p1gtD7.js}

@@ -1,6 +1,6 @@
-import { Gn as init_projects, bn as init_state_migration_lock, cn as flushAutoCommits, fn as STATE_BRANCH_PATHS, hn as init_state_plane, ln as init_auto_commit, rr as resolveInfraRepo, yn as acquireStateMigrationLock, zn as getProjectSync } from "./config-yaml-CxdwhAIA.js";
-import { o as init_lifecycle } from "./lifecycle-DOgGnpIv.js";
-import { l as stateWorktreePath, n as STATE_BRANCH, o as init_state_home, r as clearStateMigrationCache, t as MIGRATION_COMPLETE_MARKER } from "./state-home-B4EWfIxF.js";
+import { Et as STATE_BRANCH_PATHS, It as acquireStateMigrationLock, Lt as init_state_migration_lock, St as init_auto_commit, bn as resolveInfraRepo, cn as init_projects, kt as init_state_plane, nn as getProjectSync, xt as flushAutoCommits } from "./config-yaml-BSCqwmX0.js";
+import { o as init_lifecycle } from "./lifecycle-D2X3al0D.js";
+import { n as STATE_BRANCH, o as init_state_home, r as clearStateMigrationCache, t as MIGRATION_COMPLETE_MARKER, u as stateWorktreePath } from "./state-home-DjN8qduI.js";
 import { dirname, join } from "node:path";
 import { Effect } from "effect";
 import { tmpdir } from "node:os";
@@ -484,4 +484,4 @@ async function migrateProjectState(projectKey, options = {}, projectOverride) {
 //#endregion
 export { migrateProjectState };
 
-//# sourceMappingURL=state-migrate-Cd8BH33U.js.map
+//# sourceMappingURL=state-migrate-a2p1gtD7.js.map

package/server/state-mirror-Cv_XgvT5.js

@@ -0,0 +1,121 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { Ct as pushPendingStateCommits, St as init_auto_commit, cn as init_projects, nn as getProjectSync, wt as queueAutoCommit, xt as flushAutoCommits } from "./config-yaml-BSCqwmX0.js";
+import { l as resolveStateDomainPathSync, o as init_state_home } from "./state-home-DjN8qduI.js";
+import { dirname, join } from "node:path";
+import { Effect } from "effect";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+//#region ../../lib/memory/state-mirror.ts
+/**
+* Memory state-domain mirror (PAN-1990 D-9).
+*
+* Durable memory artifacts — daily summaries and pinned-doc descriptors — are
+* mirrored onto the project's `overdeck-state` branch (or its legacy `.pan/`
+* equivalent pre-migration) through the same state-door commit path other
+* domain writers use (queueAutoCommit/flushAutoCommits). Rolling observations,
+* pending/, and status.json are high-churn and NEVER belong on the state
+* branch — writeMemoryStateMirror/removeMemoryStateMirror reject them.
+*
+* A projectId with no classic projects.yaml registration has nothing to
+* mirror to; callers no-op rather than fail, since mirroring is a durability
+* convenience, not the source of truth (the memory-home file is).
+*/
+function assertMirrorable(relativePath) {
+	const normalized = relativePath.replace(/\\/g, "/");
+	if (FORBIDDEN_MIRROR_PREFIXES.some((prefix) => normalized.startsWith(prefix))) throw new MemoryMirrorRejectedError(`refusing to mirror rolling memory path onto the state branch: ${relativePath}`);
+}
+/** Queues + flushes a commit for `targetPath` and returns the raw FlushResult (never throws). */
+function flushMirrorCommit(project, targetPath, subject) {
+	queueAutoCommit({
+		projectRoot: project.path,
+		paths: [targetPath],
+		subject
+	});
+	return Effect.runPromise(flushAutoCommits(project.path));
+}
+async function commitMirror(project, targetPath, subject) {
+	const flushed = await flushMirrorCommit(project, targetPath, subject);
+	if (flushed.errored || flushed.pushed === false) throw new Error(flushed.reason ?? `memory state mirror commit was not pushed: ${targetPath}`);
+}
+/** Writes `relativePath` under the project's memory state-domain and commits+pushes it through the state door. */
+async function writeMemoryStateMirror(projectId, relativePath, content, subject) {
+	assertMirrorable(relativePath);
+	const project = getProjectSync(projectId);
+	if (!project) return;
+	const target = join(resolveStateDomainPathSync(project, MEMORY_STATE_DOMAIN), relativePath);
+	await mkdir(dirname(target), { recursive: true });
+	await writeFile(target, content, "utf8");
+	await commitMirror(project, target, subject);
+}
+/**
+* Deletes `relativePath` under the project's memory state-domain and
+* commits+pushes the removal.
+*
+* Review fix (cycle 3, corrected in cycle 4): a prior call can have already
+* deleted `target` from disk and either (a) fully committed that removal
+* locally but failed only at the push step, or (b) failed at `git add`/`git
+* commit` itself (index lock, hook/signing failure, branch mismatch) — in
+* which case NOTHING was committed at all. Cycle 3's fix treated both the
+* same way (push-only retry), which silently "succeeds" for case (b): there
+* is nothing ahead to push, `git push` reports success trivially, and the
+* remote mirror is never actually removed while the caller believes it was.
+*
+* The fix: re-run the SAME add+commit+push flow first — `git add` on a path
+* that no longer exists on disk but is still tracked STAGES the deletion
+* (identical to `git rm`), so this correctly recovers case (b) by actually
+* committing the deletion this time. Only when that reports "nothing to
+* commit" (a real diff never existed for this attempt — the deletion is
+* either already fully committed, or this pin's mirror was never written in
+* the first place) does it fall back to retrying the push alone, which
+* covers case (a) and is a safe no-op for "never mirrored."
+*/
+async function removeMemoryStateMirror(projectId, relativePath, subject) {
+	assertMirrorable(relativePath);
+	const project = getProjectSync(projectId);
+	if (!project) return;
+	const target = join(resolveStateDomainPathSync(project, MEMORY_STATE_DOMAIN), relativePath);
+	if (!existsSync(target)) {
+		const flushed = await flushMirrorCommit(project, target, subject);
+		if (flushed.errored) throw new Error(flushed.reason ?? `memory state mirror retry commit failed: ${target}`);
+		if (flushed.committed) {
+			if (flushed.pushed === false) throw new Error(flushed.reason ?? `memory state mirror retry commit was not pushed: ${target}`);
+			return;
+		}
+		const push = await Effect.runPromise(pushPendingStateCommits(project.path));
+		if (push && !push.pushed) throw new Error(push.reason ?? `memory state mirror retry-push was not confirmed: ${target}`);
+		return;
+	}
+	await rm(target);
+	await commitMirror(project, target, subject);
+}
+async function mirrorDailySummary(projectId, workspaceName, date, markdown) {
+	await writeMemoryStateMirror(projectId, join("summaries", projectId, `${workspaceName}-${date}.md`), markdown, `chore(memory): mirror daily summary ${projectId}/${workspaceName}-${date}`);
+}
+/**
+* Non-blocking review fix: replacing `/` with `__` made `a/b.md` and
+* `a__b.md` map to the same filename, so pinning one could silently overwrite
+* or delete the other's mirror descriptor. Hashing docPath instead of
+* transliterating it makes the filename collision-resistant regardless of
+* what characters the path contains; docPath itself is still stored inside
+* the JSON descriptor content for readability.
+*/
+function pinMirrorPath(scope, scopeId, docPath) {
+	return join("pins", `${scope}__${scopeId}__${createHash("sha256").update(docPath).digest("hex").slice(0, 16)}.json`);
+}
+async function unmirrorPin(projectId, scope, scopeId, docPath) {
+	await removeMemoryStateMirror(projectId, pinMirrorPath(scope, scopeId, docPath), `chore(memory): unmirror pin ${scope}:${scopeId}:${docPath}`);
+}
+var MEMORY_STATE_DOMAIN, FORBIDDEN_MIRROR_PREFIXES, MemoryMirrorRejectedError;
+var init_state_mirror = __esmMin((() => {
+	init_projects();
+	init_state_home();
+	init_auto_commit();
+	MEMORY_STATE_DOMAIN = "memory";
+	FORBIDDEN_MIRROR_PREFIXES = ["observations/", "pending/"];
+	MemoryMirrorRejectedError = class extends Error {};
+}));
+//#endregion
+export { mirrorDailySummary as n, unmirrorPin as r, init_state_mirror as t };
+
+//# sourceMappingURL=state-mirror-Cv_XgvT5.js.map

package/server/{stuck-remediation-ChcooZuk.js → stuck-remediation-CXJX_kki.js}

@@ -1,2 +1,2 @@
-import { r as shouldSkipIdlePokeForAgent } from "./stuck-remediation-DmY5UJLg.js";
+import { r as shouldSkipIdlePokeForAgent } from "./stuck-remediation-CbCRSz1v.js";
 export { shouldSkipIdlePokeForAgent };