svamp-cli 0.2.346 → 0.2.358

package/dist/{run-ChdsgaSD.mjs → run-Bc81iurl.mjs}

@@ -1,12 +1,12 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { a as composeSessionId, g as generateFriendlyName } from './friendlyName-1UZcyDhu.mjs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { c as composeSessionId, g as generateFriendlyName } from './friendlyName-B-OEwt0t.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync, watch } from 'node:fs';
 import { c as connectToHypha } from './hyphaClient-ybivOjZo.mjs';
-import { c as createSessionStore, r as registerMachineService, g as generateHookSettings } from './hookSettings-DYMTUgVA.mjs';
+import { c as createSessionStore, r as registerMachineService, g as generateHookSettings } from './hookSettings-CvvUhwCK.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
-import { applyClaudeProxyEnv } from './claudeAuth-iAerdaMr.mjs';
+import { applyClaudeProxyEnv } from './claudeAuth-DMDvPNhO.mjs';
 import { createInterface } from 'node:readline';
 import 'node:crypto';
 import 'fs';
@@ -23,9 +23,10 @@ import 'http';
 import 'net';
 import 'os';
 import './instance-CeHz5C8v.mjs';
-import './serveAuth-DbVLRCRR.mjs';
+import './serveAuth-4M0vwMyj.mjs';
 import './envFlag-COOuJ3AH.mjs';
 import './codexProvider-BtxYc5Rj.mjs';
+import './inboxGuard-CDqmIypF.mjs';
 import './fileLock-BMPwCrB6.mjs';
 import 'node:events';
 import './cron-hHGdb5kU.mjs';
@@ -321,6 +322,7 @@ async function runRemoteMode(opts) {
     opts.abort.addEventListener("abort", () => abortController.abort(), { once: true });
   }
   try {
+    let liveSessionId = opts.claudeSessionId;
     while (!exitReason && !abortController.signal.aborted) {
       const message = await Promise.race([
         opts.nextMessage(),
@@ -334,12 +336,25 @@ async function runRemoteMode(opts) {
         claudeBin,
         cwd,
         message,
-        sessionId: opts.claudeSessionId,
+        // #1703: read the LIVE id, not the one captured when runRemoteMode was called.
+        //
+        // This used to pass `opts.claudeSessionId`, which is frozen at entry — and the id
+        // discovered on turn 1 is written by onSessionFound into loop.ts's own variable,
+        // which this function will not re-read until it returns and is called again. So
+        // turn 2 spawned with NO --resume: the web app sent "read foo.ts" then "now
+        // refactor it", and the second turn had never heard of foo.ts. EVERY remote-mode
+        // turn after the first was amnesiac, and each one was a full uncached prefix.
+        // loop.ts's header states the intended contract: "Session ID is preserved across
+        // switches (same Claude conversation)."
+        sessionId: liveSessionId,
         permissionMode: opts.permissionMode,
         hookSettingsPath: opts.hookSettingsPath,
         claudeArgs: opts.claudeArgs,
         signal: abortController.signal,
-        onSessionFound: opts.onSessionFound,
+        onSessionFound: (id) => {
+          liveSessionId = id;
+          opts.onSessionFound(id);
+        },
         onThinkingChange,
         onMessage,
         log
@@ -385,6 +400,8 @@ async function runClaudeTurn(opts) {
 `);
   const spawnEnv = { ...process.env, CLAUDE_CODE_ENTRYPOINT: "sdk-ts" };
   delete spawnEnv.CLAUDECODE;
+  const proxyDesc = applyClaudeProxyEnv(spawnEnv);
+  if (proxyDesc) opts.log?.(`[remote] Claude auth: ${proxyDesc}`);
   const child = spawn(opts.claudeBin, args, {
     stdio: ["pipe", "pipe", "pipe"],
     cwd: opts.cwd,
@@ -526,7 +543,7 @@ function mapPermissionMode(mode) {
 async function loop(opts) {
   const { log } = opts;
   let mode = opts.startingMode;
-  let claudeSessionId = null;
+  let claudeSessionId = opts.resumeSessionId || null;
   const onSessionFound = (id) => {
     if (id !== claudeSessionId) {
       log(`[loop] Session ID: ${id}`);
@@ -872,7 +889,7 @@ async function runInteractive(options) {
   process.on("SIGTERM", handleExit);
   process.on("SIGINT", handleExit);
   const claudeArgs = [...options.claudeArgs || []];
-  if (options.resumeSessionId) ; else if (options.continueSession) {
+  if (!options.resumeSessionId && options.continueSession) {
     claudeArgs.push("--continue");
   }
   restoreConsoleLogs();
@@ -898,6 +915,8 @@ async function runInteractive(options) {
   try {
     const exitCode = await loop({
       cwd,
+      resumeSessionId: options.resumeSessionId,
+      // #1702
       startingMode: "local",
       hookSettingsPath: hookSettings?.settingsPath || "",
       permissionMode,

package/dist/{run-DkjwF-zA.mjs → run-DKOND4dO.mjs}

@@ -1,19 +1,20 @@
 import os from 'os';
 import fs from 'fs/promises';
-import fs__default, { existsSync as existsSync$1, readFileSync as readFileSync$1, realpathSync, writeFileSync as writeFileSync$1, renameSync as renameSync$1, rmSync as rmSync$1, mkdirSync as mkdirSync$1, copyFileSync, unlinkSync as unlinkSync$1, readdirSync as readdirSync$1, watch, rmdirSync, statSync as statSync$1 } from 'fs';
+import fs__default, { existsSync as existsSync$1, readFileSync as readFileSync$1, realpathSync, writeFileSync as writeFileSync$1, renameSync as renameSync$1, rmSync as rmSync$1, mkdirSync as mkdirSync$1, copyFileSync, unlinkSync as unlinkSync$1, readdirSync as readdirSync$1, watch, rmdirSync, statSync as statSync$1, chmodSync } from 'fs';
 import { delimiter, join as join$1, resolve, dirname as dirname$1, basename as basename$1 } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn as spawn$1, execFile, exec } from 'child_process';
 import { randomUUID, createHash } from 'crypto';
-import { a as authorizeRequest, b as countFileLines, P as ProcessSupervisor, d as retryStreakExhausted, e as computeRetryDelayMs, f as getRateLimitRetryConfig, g as generateHookSettings, h as getAccount, i as resolveAccountEnv, j as isRetryableRateLimit, c as createSessionStore, E as EXEC_MAX_BUFFER, k as execFailureOutcome, l as execSuccessOutcome, m as formatInboxMessageXml, n as loadInbox, o as isPending, p as ensureCodexHome, q as loadPersistedMachineMetadata, s as savePersistedMachineMetadata, r as registerMachineService, t as channelKeyGrantsFileAccess, C as ChannelStore, u as refreshDueAnthropicAccounts, v as refreshAnthropicToken } from './hookSettings-DYMTUgVA.mjs';
-import { a as composeSessionId, g as generateFriendlyName, d as friendlyNameFromId, f as formatHandle, e as clearInboundContext, w as writeInboundContext, i as isHopCapParked, j as classifyInbound, k as consumeAwaitingReply, l as peekAwaitingReply } from './friendlyName-1UZcyDhu.mjs';
+import { a as authorizeRequest, b as countFileLines, P as ProcessSupervisor, d as retryStreakExhausted, e as computeRetryDelayMs, f as getRateLimitRetryConfig, g as generateHookSettings, h as getAccount, i as resolveAccountEnv, j as isRetryableRateLimit, c as createSessionStore, E as EXEC_MAX_BUFFER, k as execFailureOutcome, l as execSuccessOutcome, m as formatInboxMessageXml, n as loadInbox, o as isPending, p as ensureCodexHome, q as loadPersistedMachineMetadata, s as savePersistedMachineMetadata, r as registerMachineService, t as channelKeyGrantsFileAccess, C as ChannelStore, u as refreshDueAnthropicAccounts, v as refreshAnthropicToken } from './hookSettings-CvvUhwCK.mjs';
+import { c as composeSessionId, g as generateFriendlyName, a as friendlyNameFromId, f as formatHandle } from './friendlyName-B-OEwt0t.mjs';
 import { w as withFileLock } from './fileLock-BMPwCrB6.mjs';
 import { mkdirSync, writeFileSync, rmSync, existsSync, renameSync, readFileSync, statSync, openSync, fstatSync, readSync, closeSync, readdirSync, unlinkSync, linkSync } from 'node:fs';
 import { join, dirname, basename, resolve as resolve$1 } from 'node:path';
 import { c as connectToHypha } from './hyphaClient-ybivOjZo.mjs';
+import { clearInboundContext, writeInboundContext, isHopCapParked, classifyInbound, consumeAwaitingReply, peekAwaitingReply } from './inboxGuard-CDqmIypF.mjs';
 import { execSync, execFileSync, spawn } from 'node:child_process';
 import { S as SharingNotificationSync } from './sharingNotificationSync-qGIQ-3yf.mjs';
-import { AcpBackend } from './acpBackend-BZ1MJhQV.mjs';
+import { AcpBackend } from './acpBackend-UaBD4zL3.mjs';
 import { KNOWN_ACP_AGENTS, KNOWN_CODEX_AGENTS } from './acpAgentConfig-CObOPlA8.mjs';
 import { c as codexAppServerAvailable, C as CodexAppServerBackend } from './codexAppServerBackend-VGsYtbqg.mjs';
 import { codexPermissionSettings, codexForcedModel, codexModelMenu, codexClampModel, resolveCodexProvider, codexDefaultModel } from './codexProvider-BtxYc5Rj.mjs';
@@ -22,19 +23,19 @@ import { GeminiTransport } from './GeminiTransport-3OkhtFRO.mjs';
 import { KimiTransport } from './KimiTransport-D8n009Tr.mjs';
 import { kimiModelMenu, kimiClampModel, kimiSpawnEnv, kimiDefaultModel } from './kimiProvider-DbxODebR.mjs';
 import { ensureKimiProviderConfigured } from './kimiSetup-NGsoYB5h.mjs';
-import { detectIsolationCapabilities } from './detectIsolation-CzoDCEnh.mjs';
+import { detectIsolationCapabilities } from './detectIsolation-CrV8IFDv.mjs';
 import { w as wrapWithIsolation } from './wrapCommand-CdNawSaa.mjs';
 import { applySecurityContext } from './securityContext-Cm5UTCuD.mjs';
-import { mkdir, copyFile, writeFile, rm, readdir, stat, readFile, rename } from 'node:fs/promises';
+import { mkdir, copyFile, writeFile, chmod, rm, readdir, stat, readFile, rename } from 'node:fs/promises';
 import { homedir, platform } from 'node:os';
-import { applyClaudeProxyEnv, updateEnvFile } from './claudeAuth-iAerdaMr.mjs';
+import { applyClaudeProxyEnv, probeLongContext1MEntitlement, LONG_CONTEXT_ENTITLEMENT_RECHECK_MS, updateEnvFile } from './claudeAuth-DMDvPNhO.mjs';
 import { d as decodeTokenExpiry, i as isTokenExpired, c as classifyBootFailure, w as writeBootStatus, a as clearBootStatus, b as isAuthExpiryError, s as shouldRenewToken, T as TOKEN_LIFETIME_SEC, R as RENEW_CHECK_INTERVAL_MS } from './bootStatus-DqtNgJch.mjs';
 import { e as envFlagEnabled } from './envFlag-COOuJ3AH.mjs';
-import { r as resolveEvaluatorModel, c as backlogOraclePending, d as runLoopVerification, l as loopCancelledDuringVerify, e as resolveLoopDurable, f as decideLoopContinuation, g as resolveMaxAutoResumes, h as grantedExtensionCount, i as resolveMaxExtensions, j as resolveStuckLimit, k as decideVerifyErrorHandling, m as resolveVerifyErrorRetries, t as terminalPhaseForDone, n as accumulateLedger, s as sumUsageTokens, o as effectiveSoftCap, p as checkLoopBudget, q as isHardBudgetStop, u as isCostCeiling, v as summarizeExtensions, w as rearmStartedAt, x as oracleScopeSessionId, y as shouldRearmDormantLoop, z as parseDaemonShareEmails, D as DAEMON_SHARE_EMAILS_ENV, A as applyDaemonShareSeed, a as buildMachineShareUrl, B as recordProgressMarker, C as assessLoopProgress, E as resolveExtensionTurns, F as grantLoopExtension, G as buildGoalCondition, H as computeSoftTurnCap, U as UNBOUNDED_LOOP_ITERATIONS } from './loopVerify-B47sSjxe.mjs';
-import { p as parseJwtEmail } from './serveAuth-DbVLRCRR.mjs';
+import { r as resolveEvaluatorModel, c as backlogOraclePending, d as runLoopVerification, l as loopCancelledDuringVerify, e as resolveLoopDurable, f as decideLoopContinuation, g as resolveMaxAutoResumes, h as grantedExtensionCount, i as resolveMaxExtensions, j as resolveStuckLimit, k as decideVerifyErrorHandling, m as resolveVerifyErrorRetries, t as terminalPhaseForDone, n as accumulateLedger, s as sumUsageTokens, o as effectiveSoftCap, p as checkLoopBudget, q as isHardBudgetStop, u as isCostCeiling, v as summarizeExtensions, w as rearmStartedAt, x as oracleScopeSessionId, y as shouldRearmDormantLoop, z as parseDaemonShareEmails, D as DAEMON_SHARE_EMAILS_ENV, A as applyDaemonShareSeed, a as buildMachineShareUrl, B as recordProgressMarker, C as assessLoopProgress, E as resolveExtensionTurns, F as grantLoopExtension, G as buildGoalCondition, H as computeSoftTurnCap, U as UNBOUNDED_LOOP_ITERATIONS } from './loopVerify-CxAKJB5a.mjs';
+import { p as parseJwtEmail } from './serveAuth-4M0vwMyj.mjs';
 import { getSkillsServer, getArtifactBaseUrl } from './api-BHjyC0Ph.mjs';
 import { l as loadInstanceConfig } from './instance-CeHz5C8v.mjs';
-import { l as listIssues, h as addIssue, o as routeCrewVerdict, r as resolveProjectRoot$1 } from './store-Bn0ByYev.mjs';
+import { r as resolveProjectRoot$1, l as listIssues, i as addIssue, q as routeCrewVerdict } from './store-D8dok6_d.mjs';
 import { c as workflowSteps, d as workflowsDir, l as listWorkflows, i as isWorkflowEnabled } from './store-fi0f-ff1.mjs';
 import { randomBytes } from 'node:crypto';
 
@@ -1390,7 +1391,8 @@ async function stageCredentialsForSharing(sessionId) {
           "-w"
         ], { encoding: "utf-8", timeout: 5e3 }).trim();
         if (keychainData.startsWith("{") || keychainData.startsWith("[")) {
-          await writeFile(stagedCredFile, keychainData);
+          await writeFile(stagedCredFile, keychainData, { mode: 384 });
+          await chmod(stagedCredFile, 384);
         }
       } catch {
       }
@@ -1550,6 +1552,25 @@ function resolveContainedCwd(directory, cwd, hasSecurityContext) {
   return resolved;
 }
 
+function getLoopDir(directory, sessionId) {
+  let root = directory;
+  try {
+    root = resolveProjectRoot$1(directory);
+  } catch {
+  }
+  if (sessionId) {
+    const rooted = join(root, ".svamp", sessionId, "loop");
+    if (existsSync(join(rooted, "loop-state.json"))) return rooted;
+    const rawScoped = join(directory, ".svamp", sessionId, "loop");
+    if (existsSync(join(rawScoped, "loop-state.json"))) return rawScoped;
+    for (const legacy of [join(root, ".claude", "loop"), join(directory, ".claude", "loop")]) {
+      if (existsSync(join(legacy, "loop-state.json"))) return legacy;
+    }
+    return rooted;
+  }
+  return join(root, ".claude", "loop");
+}
+
 const DEFAULT_LOG_PRUNE_POLICY = {
   keepFiles: 10,
   maxAgeDays: 14,
@@ -1682,6 +1703,25 @@ function shortRunId(seed) {
   return (h >>> 0).toString(36).padStart(7, "0").slice(0, 7);
 }
 const RECONCILE_GRACE_MS = 12e4;
+const reportedWriteErrnos = /* @__PURE__ */ new Set();
+const RUN_STORE_LOCK_OPTS = (where) => ({
+  deadlineMs: 3e3,
+  breakOnDeadOwner: true,
+  onFailOpen: (lockPath) => reportRunStoreWriteFailure(
+    `${where}/fail-open`,
+    Object.assign(new Error(`lock timeout on ${lockPath} \u2014 wrote UNLOCKED, a concurrent run record may have been lost`), { code: "ELOCKTIMEOUT" })
+  )
+});
+function reportRunStoreWriteFailure(where, err) {
+  const code = String(err?.code || err?.name || "UNKNOWN");
+  if (reportedWriteErrnos.has(code)) return;
+  reportedWriteErrnos.add(code);
+  const hint = code === "ENOSPC" ? " \u2014 THE DISK IS FULL. Workflow run records are being DROPPED, and session transcripts are likely failing to persist too. This also mimics a concurrency bug (#0681/#1631)." : code === "EROFS" ? " \u2014 the filesystem is read-only." : code === "EACCES" || code === "EPERM" ? " \u2014 permission denied on the runs directory." : "";
+  console.error(`[workflow] run-store write failed in ${where} (${code})${hint} Further ${code} failures will not be repeated. (#1631)`);
+}
+function __resetRunStoreWriteFailureReporting() {
+  reportedWriteErrnos.clear();
+}
 function recordRun(projectRoot, run) {
   try {
     const dir = runsDir(projectRoot);
@@ -1696,8 +1736,9 @@ function recordRun(projectRoot, run) {
       const tmp = `${file}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
       writeFileSync(tmp, kept.map((r) => JSON.stringify(r)).join("\n") + "\n");
       renameSync(tmp, file);
-    });
-  } catch {
+    }, RUN_STORE_LOCK_OPTS("recordRun"));
+  } catch (err) {
+    reportRunStoreWriteFailure("recordRun", err);
   }
 }
 function loadRuns(projectRoot, workflow) {
@@ -1740,40 +1781,47 @@ function reconcileInterruptedRuns(projectRoot) {
     for (const entry of readdirSync(dir)) {
       if (!entry.endsWith(".jsonl")) continue;
       const file = join(dir, entry);
-      let runs;
+      let fixedHere = 0;
       try {
-        runs = readFileSync(file, "utf-8").split("\n").filter(Boolean).map((l) => {
+        withFileLock(`${file}.lock`, () => {
+          let runs;
           try {
-            return JSON.parse(l);
+            runs = readFileSync(file, "utf-8").split("\n").filter(Boolean).map((l) => {
+              try {
+                return JSON.parse(l);
+              } catch {
+                return null;
+              }
+            }).filter((r) => !!r);
           } catch {
-            return null;
+            return;
           }
-        }).filter((r) => !!r);
-      } catch {
-        continue;
-      }
-      let changed = false;
-      for (const r of runs) {
-        if (r.status !== "running") continue;
-        if (isWorkflowInFlight(projectRoot, r.workflow)) continue;
-        if (typeof r.startedAt === "number" && Date.now() - r.startedAt < RECONCILE_GRACE_MS) continue;
-        r.status = "failed";
-        r.error = r.error || "interrupted by daemon restart";
-        r.finishedAt = r.finishedAt || r.startedAt;
-        changed = true;
-        fixed++;
-      }
-      if (!changed) continue;
-      try {
-        withFileLock(`${file}.lock`, () => {
+          let changed = false;
+          for (const r of runs) {
+            if (r.status !== "running") continue;
+            if (isWorkflowInFlight(projectRoot, r.workflow)) continue;
+            const raw = r.startedAt;
+            const startedMs = typeof raw === "number" ? raw : Date.parse(String(raw ?? ""));
+            if (Number.isFinite(startedMs) && Date.now() - startedMs < RECONCILE_GRACE_MS) continue;
+            r.status = "failed";
+            r.error = r.error || "interrupted by daemon restart";
+            r.finishedAt = r.finishedAt || r.startedAt;
+            changed = true;
+            fixedHere++;
+          }
+          if (!changed) return;
+          const kept = runs.slice(-maxRunsPerWorkflow());
           const tmp = `${file}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
-          writeFileSync(tmp, runs.map((r) => JSON.stringify(r)).join("\n") + "\n");
+          writeFileSync(tmp, kept.map((r) => JSON.stringify(r)).join("\n") + "\n");
           renameSync(tmp, file);
-        });
-      } catch {
+        }, RUN_STORE_LOCK_OPTS("reconcileInterruptedRuns"));
+      } catch (err) {
+        reportRunStoreWriteFailure("reconcileInterruptedRuns", err);
       }
+      fixed += fixedHere;
     }
-  } catch {
+  } catch (err) {
+    reportRunStoreWriteFailure("reconcileInterruptedRuns/outer", err);
   }
   return fixed;
 }
@@ -1960,6 +2008,7 @@ var runStore = /*#__PURE__*/Object.freeze({
     MAX_RUNS_PER_WORKFLOW: MAX_RUNS_PER_WORKFLOW,
     MAX_STREAM_CHARS: MAX_STREAM_CHARS,
     STEP_TIMEOUT_MS: STEP_TIMEOUT_MS,
+    __resetRunStoreWriteFailureReporting: __resetRunStoreWriteFailureReporting,
     capStream: capStream,
     escalateWorkflowFailure: escalateWorkflowFailure,
     getRun: getRun,
@@ -1969,6 +2018,7 @@ var runStore = /*#__PURE__*/Object.freeze({
     maxRunsPerWorkflow: maxRunsPerWorkflow,
     reconcileInterruptedRuns: reconcileInterruptedRuns,
     recordRun: recordRun,
+    reportRunStoreWriteFailure: reportRunStoreWriteFailure,
     runWorkflow: runWorkflow,
     runsDir: runsDir,
     stepTimeoutMs: stepTimeoutMs
@@ -2353,7 +2403,16 @@ function acquireSupervisorLock(pidFile, pid = process.pid) {
     }
     return { acquired: false, staleCleaned: true };
   }
-  if (isPidAlive(existingPid)) {
+  const alive = isPidAlive(existingPid);
+  const verdict = classifyLockHolder({
+    pid: existingPid,
+    alive,
+    // Only interrogate a live pid — a dead one is already stale, and `ps` costs a fork.
+    holderStartedMs: alive ? readProcessStartMs(existingPid) : null,
+    lockWrittenMs: getFileWrittenMs(pidFile),
+    bootTimeMs: getBootTimeMs()
+  });
+  if (verdict === "held") {
     return { acquired: false, heldBy: existingPid };
   }
   try {
@@ -2362,6 +2421,62 @@ function acquireSupervisorLock(pidFile, pid = process.pid) {
   }
   return { acquired: false, staleCleaned: true };
 }
+const RECYCLED_PID_TOLERANCE_MS = 5e3;
+function classifyLockHolder(opts) {
+  const { pid, alive, holderStartedMs = null, lockWrittenMs = null, bootTimeMs = null } = opts;
+  if (!pid || Number.isNaN(pid) || pid <= 0) return "stale";
+  if (!alive) return "stale";
+  if (bootTimeMs !== null && lockWrittenMs !== null && lockWrittenMs < bootTimeMs) return "stale";
+  if (holderStartedMs !== null && lockWrittenMs !== null && holderStartedMs > lockWrittenMs + RECYCLED_PID_TOLERANCE_MS) {
+    return "stale";
+  }
+  return "held";
+}
+function readProcessStartMs(pid) {
+  if (!pid || Number.isNaN(pid) || pid <= 0) return null;
+  if (process.platform === "win32") return null;
+  try {
+    const out = execFileSync("ps", ["-ww", "-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out) return null;
+    const ms = Date.parse(out);
+    return Number.isFinite(ms) ? ms : null;
+  } catch {
+    return null;
+  }
+}
+function getFileWrittenMs(file) {
+  try {
+    return statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function getBootTimeMs() {
+  if (process.platform === "win32") return null;
+  try {
+    if (process.platform === "linux") {
+      const uptimeSec = parseFloat(readFileSync("/proc/uptime", "utf-8").trim().split(/\s+/)[0]);
+      if (!Number.isFinite(uptimeSec) || uptimeSec < 0) return null;
+      return Date.now() - uptimeSec * 1e3;
+    }
+    const out = execFileSync("sysctl", ["-n", "kern.boottime"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const m = out.match(/sec\s*=\s*(\d+)/);
+    if (!m) return null;
+    const sec = parseInt(m[1], 10);
+    if (!Number.isFinite(sec) || sec <= 0) return null;
+    return sec * 1e3;
+  } catch {
+    return null;
+  }
+}
 function acquireSupervisorLockWithRetry(pidFile, pid = process.pid) {
   let result = acquireSupervisorLock(pidFile, pid);
   if (!result.acquired && result.staleCleaned) {
@@ -2390,7 +2505,7 @@ function isSupervisorPid(pid) {
   if (!pid || Number.isNaN(pid) || pid <= 0) return false;
   if (process.platform === "win32") return null;
   try {
-    const out = execFileSync("ps", ["-o", "command=", "-p", String(pid)], {
+    const out = execFileSync("ps", ["-ww", "-o", "command=", "-p", String(pid)], {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -2510,11 +2625,15 @@ var supervisorLock = /*#__PURE__*/Object.freeze({
     __proto__: null,
     acquireSupervisorLock: acquireSupervisorLock,
     acquireSupervisorLockWithRetry: acquireSupervisorLockWithRetry,
+    classifyLockHolder: classifyLockHolder,
     findOrphanedSyncPids: findOrphanedSyncPids,
+    getBootTimeMs: getBootTimeMs,
+    getFileWrittenMs: getFileWrittenMs,
     getPpid: getPpid,
     isPidAlive: isPidAlive,
     isSupervisorPid: isSupervisorPid,
     killOrphanedSyncs: killOrphanedSyncs,
+    readProcessStartMs: readProcessStartMs,
     releaseSupervisorLock: releaseSupervisorLock,
     shouldSignalSupervisor: shouldSignalSupervisor,
     watchParentLiveness: watchParentLiveness
@@ -3119,16 +3238,6 @@ function writeSvampConfig(configPath, config) {
 }
 const DEFAULT_LOOP_MAX_ITERATIONS = UNBOUNDED_LOOP_ITERATIONS;
 const LOOP_CHECKPOINT_CADENCE = 25;
-function getLoopDir(directory, sessionId) {
-  if (sessionId) {
-    const scoped = join$1(directory, ".svamp", sessionId, "loop");
-    if (existsSync$1(join$1(scoped, "loop-state.json"))) return scoped;
-    const legacy = join$1(directory, ".claude", "loop");
-    if (existsSync$1(join$1(legacy, "loop-state.json"))) return legacy;
-    return scoped;
-  }
-  return join$1(directory, ".claude", "loop");
-}
 function readLoopState(directory, sessionId) {
   try {
     const p = join$1(getLoopDir(directory, sessionId), "loop-state.json");
@@ -4237,7 +4346,11 @@ async function startDaemon(options) {
   function saveExposedTunnels(specs) {
     try {
       mkdirSync$1(SVAMP_HOME, { recursive: true });
-      writeFileSync$1(EXPOSED_TUNNELS_FILE, JSON.stringify({ tunnels: specs }, null, 2));
+      writeFileSync$1(EXPOSED_TUNNELS_FILE, JSON.stringify({ tunnels: specs }, null, 2), { mode: 384 });
+      try {
+        chmodSync(EXPOSED_TUNNELS_FILE, 384);
+      } catch {
+      }
     } catch (err) {
       logger.log(`[exposed-tunnels] Persist failed: ${err.message}`);
     }
@@ -4256,7 +4369,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-B2Nl7Fof.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-C_KvvYFp.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -4278,7 +4391,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-B2Nl7Fof.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-C_KvvYFp.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const incoming = [{
@@ -4299,7 +4412,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-B2Nl7Fof.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-C_KvvYFp.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "serve", mountName)) {
@@ -4315,7 +4428,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-B2Nl7Fof.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-C_KvvYFp.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "tunnel", tunnelName)) {
@@ -4332,7 +4445,7 @@ async function startDaemon(options) {
   let managedLinkSessionsSeeded = false;
   async function reconcileAllServiceLinks() {
     try {
-      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-B2Nl7Fof.mjs');
+      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-C_KvvYFp.mjs');
       const desiredBySession = /* @__PURE__ */ new Map();
       const push = (sessionId, entry) => {
         if (!sessionId || !entry.url) return;
@@ -4406,7 +4519,7 @@ async function startDaemon(options) {
     }, delayMs);
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./hookSettings-DYMTUgVA.mjs').then(function (n) { return n.w; });
+    const { FrpcTunnel } = await import('./hookSettings-CvvUhwCK.mjs').then(function (n) { return n.w; });
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -4427,7 +4540,7 @@ async function startDaemon(options) {
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
   const tunnelRecreateInFlight = /* @__PURE__ */ new Set();
-  const { ServeManager } = await import('./hookSettings-DYMTUgVA.mjs').then(function (n) { return n.y; });
+  const { ServeManager } = await import('./hookSettings-CvvUhwCK.mjs').then(function (n) { return n.y; });
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   serveManager.setMountUnboundHook((sessionId, mountName) => {
     void dropMountSessionLink(sessionId, mountName);
@@ -5354,21 +5467,34 @@ ${parts.join("\n")}`);
           } catch (e) {
             logger.log(`[Session ${sessionId}] verifyGoalCompletion threw \u2014 failing closed (retry/park): ${e?.message || e}`);
             try {
+              const curLsErr = readLoopState(directory, sessionId);
+              if (loopCancelledDuringVerify(curLsErr)) {
+                logger.log(`[Session ${sessionId}] loop was cancelled during a FAILED verification \u2014 not re-kicking (#0308/#1542)`);
+                return;
+              }
+              const freshErr = curLsErr || ls;
+              const carry = {
+                ledger: freshErr.ledger ?? ls.ledger,
+                progress_history: freshErr.progress_history ?? ls.progress_history,
+                extensions: freshErr.extensions ?? ls.extensions,
+                auto_resumes: freshErr.auto_resumes ?? ls.auto_resumes,
+                holds: freshErr.holds ?? ls.holds
+              };
               const durable2 = resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd });
               const decision = decideVerifyErrorHandling({
-                priorErrors: ls.verify_errors,
+                priorErrors: freshErr.verify_errors ?? ls.verify_errors,
                 maxRetries: resolveVerifyErrorRetries(process.env.SVAMP_LOOP_VERIFY_ERROR_RETRIES),
                 reason: `verify threw: ${e?.message || e}`
               });
               if (decision.action === "retry") {
                 const cond = ls.task || "";
-                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", started_at: startedAt, verify_errors: decision.attempt });
+                writeGoalLoopState(directory, sessionId, { ...ls, ...carry, active: true, phase: "continue", started_at: startedAt, verify_errors: decision.attempt });
                 sessionService.pushMessage({ type: "message", message: `\u26A0\uFE0F Loop verification error \u2014 ${decision.reason}`, level: "warning" }, "event");
                 enqueueLoopMessage(`/goal ${cond} \u2014 the completion check could not run; CONTINUE and it will be re-verified. Not done.`, "\u26A0\uFE0F Re-verifying loop");
                 if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
               } else {
                 const parkPhase = terminalPhaseForDone(durable2);
-                writeGoalLoopState(directory, sessionId, { ...ls, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), verify_errors: 0 });
+                writeGoalLoopState(directory, sessionId, { ...ls, ...carry, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), verify_errors: 0 });
                 checkSvampConfig?.();
               }
             } catch {
@@ -5851,7 +5977,7 @@ ${parts.join("\n")}`);
                       const hasBackgroundTasks = backgroundTaskCount > 0;
                       if (hasBackgroundTasks) {
                         const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
-                        sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
+                        sessionService.pushMessage({ type: "message", message: taskInfo, level: "warning" }, "event");
                       }
                       signalProcessing(false);
                       sessionWasProcessing = false;
@@ -5974,7 +6100,7 @@ ${parts.join("\n")}`);
                     if (backgroundTaskCount > 0) {
                       const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
                       logger.log(`[Session ${sessionId}] ${taskInfo}`);
-                      sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
+                      sessionService.pushMessage({ type: "message", message: taskInfo, level: "warning" }, "event");
                     }
                     justCompactedTurn = false;
                     compactTurnLatch = false;
@@ -6889,12 +7015,12 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-Cf0grcru.mjs');
+              const { issueRpc } = await import('./rpc-CAlAHQAy.mjs');
               const issueCwd = resolveContainedCwd(directory, params?.cwd, !!sessionMetadata.securityContext);
               return issueRpc(issueCwd, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BB6RF4-F.mjs');
+              const { workflowRpc } = await import('./rpc-CacreLQ8.mjs');
               const wfCwd = resolveContainedCwd(directory, params?.cwd, !!sessionMetadata.securityContext);
               return workflowRpc(wfCwd, params || {});
             },
@@ -7646,12 +7772,12 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-Cf0grcru.mjs');
+              const { issueRpc } = await import('./rpc-CAlAHQAy.mjs');
               const issueCwd = resolveContainedCwd(directory, params?.cwd, !!sessionMetadata.securityContext);
               return issueRpc(issueCwd, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BB6RF4-F.mjs');
+              const { workflowRpc } = await import('./rpc-CacreLQ8.mjs');
               const wfCwd = resolveContainedCwd(directory, params?.cwd, !!sessionMetadata.securityContext);
               return workflowRpc(wfCwd, params || {});
             },
@@ -8391,6 +8517,24 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       }
       return { success: false, message: `Session ${sessionId} not found or already stopped.` };
     };
+    {
+      let lastEntitlementState;
+      const runEntitlementProbe = (first) => {
+        const env = {};
+        applyClaudeProxyEnv(env);
+        void probeLongContext1MEntitlement(env.ANTHROPIC_BASE_URL, env.ANTHROPIC_API_KEY).then((state) => {
+          if (!first && state === lastEntitlementState) return;
+          lastEntitlementState = state;
+          if (state === "entitled") logger.log("[1m-context] entitlement confirmed \u2014 sessions will request the 1M window");
+          else if (state === "not-entitled") logger.log("[1m-context] NOT entitled for this account \u2014 NOT requesting the 1M beta (sessions compact at the 200K window). See #1585.");
+          else logger.log("[1m-context] entitlement could not be determined \u2014 NOT requesting the 1M beta (safe default). See #1585.");
+        }).catch(() => {
+        });
+      };
+      runEntitlementProbe(true);
+      const entitlementTimer = setInterval(() => runEntitlementProbe(false), LONG_CONTEXT_ENTITLEMENT_RECHECK_MS);
+      if (typeof entitlementTimer.unref === "function") entitlementTimer.unref();
+    }
     let isolationCapabilities;
     try {
       isolationCapabilities = await detectIsolationCapabilities();
@@ -9007,13 +9151,18 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-BY30ZrB9.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-IyLWBF8T.mjs');
     const workflowProjectRoots = () => {
-      const dirs = /* @__PURE__ */ new Set();
+      const roots = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {
-        if (!s.stopped && s.directory) dirs.add(s.directory);
+        if (s.stopped || !s.directory) continue;
+        try {
+          roots.add(resolveProjectRoot$1(s.directory));
+        } catch {
+          roots.add(s.directory);
+        }
       }
-      return [...dirs];
+      return [...roots];
     };
     try {
       const { reconcileInterruptedRuns } = await Promise.resolve().then(function () { return runStore; });
@@ -9692,4 +9841,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { stopDaemon as a, stopMarkerExists as b, clearStopMarker as c, daemonStatus as d, runStore as e, supervisorLock as f, getRun as g, run as h, listRuns as l, projectInfo as p, runWorkflow as r, startDaemon as s };
+export { stopDaemon as a, stopMarkerExists as b, clearStopMarker as c, daemonStatus as d, loadRuns as e, runStore as f, getRun as g, supervisorLock as h, run as i, listRuns as l, projectInfo as p, runWorkflow as r, startDaemon as s };