@cydm/pie 2.6.5 → 2.6.7

package/dist/builtin/extensions/ask-user/index.js

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-QKSK5K5N.js";
-import "../../../chunks/chunk-AETQBDEG.js";
-import "../../../chunks/chunk-5OXH6NUH.js";
+} from "../../../chunks/chunk-T6GMEDIE.js";
+import "../../../chunks/chunk-PAC62XU4.js";
+import "../../../chunks/chunk-7B4IIBVS.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";
 

package/dist/builtin/extensions/mcp-adapter/index.js

@@ -24461,10 +24461,50 @@ function redactSecrets(text, secrets) {
   }
   return sanitized;
 }
+function escapeRegExpLiteral(literal2) {
+  return literal2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function percentEncodeAll(secret) {
+  return [...Buffer.from(secret, "utf-8")].map((byte) => `%${byte.toString(16).toUpperCase().padStart(2, "0")}`).join("");
+}
+function shortEncodedSecretTokens(secrets) {
+  const tokens = { base64: [], percent: [] };
+  for (const secret of secrets) {
+    try {
+      const base64url2 = Buffer.from(secret, "utf-8").toString("base64url");
+      if (base64url2 !== secret && base64url2.length > 0 && base64url2.length < 4) tokens.base64.push(base64url2);
+    } catch {
+    }
+    try {
+      const urlEncoded = encodeURIComponent(secret);
+      if (urlEncoded !== secret && urlEncoded.length > 0 && urlEncoded.length < 4 && /%[0-9A-F]{2}/i.test(urlEncoded)) {
+        tokens.percent.push(urlEncoded);
+      }
+      const percentAll = percentEncodeAll(secret);
+      if (percentAll !== secret && percentAll.length > 0 && percentAll.length < 4) tokens.percent.push(percentAll);
+    } catch {
+    }
+  }
+  return tokens;
+}
+function collectPatternSpans(text, pattern, spans) {
+  for (const match of text.matchAll(new RegExp(`(?=(${pattern.source}))`, pattern.flags))) {
+    spans.push({ start: match.index, end: match.index + match[1].length });
+  }
+}
+function collectShortEncodedTokens(text, secrets, spans) {
+  const { base64: base642, percent } = shortEncodedSecretTokens(secrets);
+  for (const token of base642) {
+    const padding = "=".repeat((4 - token.length % 4) % 4);
+    collectPatternSpans(text, new RegExp(`(?<![A-Za-z0-9+/_-])${escapeRegExpLiteral(token)}(?:${padding})?(?![A-Za-z0-9+/=_-])`, "g"), spans);
+  }
+  for (const token of percent) {
+    collectPatternSpans(text, new RegExp(`(?<![%A-Za-z0-9])${escapeRegExpLiteral(token)}(?![%A-Za-z0-9])`, "gi"), spans);
+  }
+}
 function encodedSecretVariants(secrets) {
   const variants = [...secrets];
   for (const secret of secrets) {
-    if (secret.length < 4) continue;
     try {
       const base642 = Buffer.from(secret, "utf-8").toString("base64");
       if (base642.length >= 4) {
@@ -24472,13 +24512,39 @@ function encodedSecretVariants(secrets) {
         const base64url2 = Buffer.from(secret, "utf-8").toString("base64url");
         if (base64url2 !== base642 && base64url2.length >= 4) variants.push(base64url2);
       }
+    } catch {
+    }
+    try {
       const urlEncoded = encodeURIComponent(secret);
-      if (urlEncoded !== secret && urlEncoded.length >= 4) variants.push(urlEncoded);
+      if (urlEncoded !== secret && urlEncoded.length >= 4 && urlEncoded !== percentEncodeAll(secret)) {
+        variants.push(urlEncoded);
+        const urlLowerHex = urlEncoded.replace(/%[0-9A-F]{2}/g, (m) => `%${m.slice(1).toLowerCase()}`);
+        if (urlLowerHex !== urlEncoded) variants.push(urlLowerHex);
+      }
     } catch {
     }
   }
   return variants;
 }
+function unicodeEscapeAll(text) {
+  let out = "";
+  for (let index = 0; index < text.length; index++) {
+    out += `\\u${text.charCodeAt(index).toString(16).padStart(4, "0")}`;
+  }
+  return out;
+}
+function unicodeEscapeVariants(secrets) {
+  const variants = [];
+  for (const secret of secrets) {
+    const escaped = unicodeEscapeAll(secret);
+    if (escaped !== secret && escaped.length >= 4) {
+      variants.push(escaped);
+      const escapedUpper = escaped.replace(/[0-9a-f]{4}/g, (m) => m.toUpperCase());
+      if (escapedUpper !== escaped) variants.push(escapedUpper);
+    }
+  }
+  return variants;
+}
 function hexSecretVariants(secrets) {
   const variants = [];
   for (const secret of secrets) {
@@ -24492,9 +24558,9 @@ function hexSecretVariants(secrets) {
   return variants;
 }
 var MIN_SECRET_FRAGMENT = 8;
-function redactSecretFragments(text, secrets) {
+function collectSecretFragments(text, secrets, spans) {
   const candidates = secrets.filter((secret) => secret.length >= MIN_SECRET_FRAGMENT);
-  if (candidates.length === 0 || text.length < MIN_SECRET_FRAGMENT) return text;
+  if (candidates.length === 0 || text.length < MIN_SECRET_FRAGMENT) return;
   const grams = /* @__PURE__ */ new Map();
   for (const secret of candidates) {
     for (let offset = 0; offset + MIN_SECRET_FRAGMENT <= secret.length; offset++) {
@@ -24504,9 +24570,7 @@ function redactSecretFragments(text, secrets) {
       else grams.set(gram, [{ secret, offset }]);
     }
   }
-  let out = "";
-  let index = 0;
-  while (index < text.length) {
+  for (let index = 0; index < text.length; index++) {
     const bucket = grams.get(text.slice(index, index + MIN_SECRET_FRAGMENT));
     let best = 0;
     if (bucket) {
@@ -24517,48 +24581,94 @@ function redactSecretFragments(text, secrets) {
         if (length > best) best = length;
       }
     }
-    if (best > 0) {
-      out += "[redacted]";
-      index += best;
-    } else {
-      out += text[index];
-      index += 1;
-    }
+    if (best > 0) spans.push({ start: index, end: index + best });
   }
-  return out;
 }
-function redactLeadingSecretSuffix(text, secrets) {
-  if (secrets.length === 0 || text.length === 0) return text;
+function collectLeadingSecretSuffix(text, secrets, spans) {
+  if (secrets.length === 0 || text.length === 0) return;
   for (const secret of secrets) {
     for (let keep = Math.min(secret.length - 1, text.length); keep >= 4; keep--) {
       if (text.startsWith(secret.slice(secret.length - keep))) {
-        return `[redacted]${text.slice(keep)}`;
+        spans.push({ start: 0, end: keep });
+        break;
       }
     }
   }
-  return text;
 }
-function redactTrailingSecretPrefix(text, secrets) {
-  if (secrets.length === 0 || text.length === 0) return text;
+function collectTrailingSecretPrefix(text, secrets, spans) {
+  if (secrets.length === 0 || text.length === 0) return;
   for (const secret of secrets) {
     for (let keep = Math.min(secret.length - 1, text.length); keep >= 4; keep--) {
       if (text.endsWith(secret.slice(0, keep))) {
-        return `${text.slice(0, text.length - keep)}[redacted]`;
+        spans.push({ start: text.length - keep, end: text.length });
+        break;
       }
     }
   }
-  return text;
 }
 function redactAllSecrets(text, secrets) {
   const encoded = encodedSecretVariants(secrets);
-  const wholeVariants = [...encoded, ...hexSecretVariants(secrets)];
-  return redactTrailingSecretPrefix(
-    redactLeadingSecretSuffix(
-      redactSecretFragments(redactSecrets(text, wholeVariants), encoded),
-      secrets
-    ),
-    secrets
-  );
+  const wholeVariants = [...encoded, ...hexSecretVariants(secrets), ...unicodeEscapeVariants(secrets)];
+  const spans = [];
+  for (const variant of new Set(wholeVariants)) {
+    if (!variant) continue;
+    for (let start = text.indexOf(variant); start !== -1; start = text.indexOf(variant, start + 1)) {
+      spans.push({ start, end: start + variant.length });
+    }
+  }
+  collectCaseInsensitiveEncodedSecrets(text, secrets, spans);
+  collectShortEncodedTokens(text, secrets, spans);
+  collectSecretFragments(text, encoded, spans);
+  collectLeadingSecretSuffix(text, encoded, spans);
+  collectTrailingSecretPrefix(text, encoded, spans);
+  spans.sort((a, b) => a.start - b.start || b.end - a.end);
+  const merged = [];
+  for (const span of spans) {
+    const previous = merged[merged.length - 1];
+    if (previous && span.start < previous.end) previous.end = Math.max(previous.end, span.end);
+    else merged.push({ ...span });
+  }
+  let out = "";
+  let cursor = 0;
+  for (const { start, end } of merged) {
+    out += text.slice(cursor, start) + "[redacted]";
+    cursor = end;
+  }
+  return out + text.slice(cursor);
+}
+function collectCaseInsensitiveEncodedSecrets(text, secrets, spans) {
+  for (const secret of secrets) {
+    const patterns = [];
+    try {
+      const urlEncoded = encodeURIComponent(secret);
+      if (urlEncoded !== secret && urlEncoded.length >= 4 && /%[0-9A-F]{2}/i.test(urlEncoded)) {
+        const urlPattern = urlEncoded.split(/(%[0-9A-F]{2})/g).map(
+          (part) => /^%[0-9A-F]{2}$/.test(part) ? part.replace(/[A-F]/g, (digit) => `[${digit}${digit.toLowerCase()}]`) : escapeRegExpLiteral(part)
+        ).join("");
+        collectPatternSpans(text, new RegExp(urlPattern, "g"), spans);
+      }
+    } catch {
+    }
+    try {
+      const percentAll = percentEncodeAll(secret);
+      if (percentAll !== secret && percentAll.length >= 4 && /%[0-9A-F]{2}/i.test(percentAll)) {
+        patterns.push(percentAll);
+      }
+    } catch {
+    }
+    try {
+      if (secret.length >= 6) {
+        const hex = Buffer.from(secret, "utf-8").toString("hex");
+        if (hex.length >= 12) patterns.push(hex);
+      }
+    } catch {
+    }
+    const escaped = unicodeEscapeAll(secret);
+    if (escaped !== secret && escaped.length >= 4) patterns.push(escaped);
+    for (const pattern of patterns) {
+      collectPatternSpans(text, new RegExp(escapeRegExpLiteral(pattern), "gi"), spans);
+    }
+  }
 }
 function redactStderrTail(tail, secrets) {
   return redactAllSecrets(tail, secrets);

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,9 +7,9 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-QKSK5K5N.js";
-import "../../../chunks/chunk-AETQBDEG.js";
-import "../../../chunks/chunk-5OXH6NUH.js";
+} from "../../../chunks/chunk-T6GMEDIE.js";
+import "../../../chunks/chunk-PAC62XU4.js";
+import "../../../chunks/chunk-7B4IIBVS.js";
 import {
   Type
 } from "../../../chunks/chunk-XXGYUYXI.js";

package/dist/builtin/extensions/subagent/index.js

@@ -1,20 +1,372 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-TFRQE7UQ.js";
+} from "../../../chunks/chunk-VUKF7U7Q.js";
 import {
+  SUBAGENT_SESSION_RECORD_VERSION,
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-QKSK5K5N.js";
-import "../../../chunks/chunk-AETQBDEG.js";
-import "../../../chunks/chunk-5OXH6NUH.js";
+} from "../../../chunks/chunk-T6GMEDIE.js";
+import "../../../chunks/chunk-PAC62XU4.js";
+import "../../../chunks/chunk-7B4IIBVS.js";
 import "../../../chunks/chunk-5353DEEC.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";
 
+// src/files/subagent-session-store.ts
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import * as path from "node:path";
+var MAX_RECORD_BYTES = 4 * 1024 * 1024;
+function isSafeSessionId(id) {
+  return /^[A-Za-z0-9._-]+$/.test(id);
+}
+var RECLAIM_ORPHAN_MS = 6e4;
+var MALFORMED_LOCK_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function defaultReadProcessStartTime(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return void 0;
+  if (process.platform === "win32") {
+    try {
+      const output = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToString('o') }`
+        ],
+        { encoding: "utf-8", timeout: 4e3 }
+      );
+      const line = output.split(/\r?\n/).find((entry) => entry.trim().length > 0);
+      return line?.trim();
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    const output = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf-8",
+      timeout: 1e3,
+      env: { ...process.env, LC_ALL: "C", LANG: "C", TZ: "UTC" }
+    });
+    const trimmed = output.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function leaseOwnerAlive(owner, readStartTime) {
+  if (!Number.isInteger(owner.pid) || owner.pid <= 0) return void 0;
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    if (error.code === "ESRCH") return false;
+  }
+  if (typeof owner.startedAt !== "string" || owner.startedAt.length === 0) {
+    return true;
+  }
+  const current = readStartTime(owner.pid);
+  return current === void 0 || current === owner.startedAt;
+}
+function publishLinkedExclusive(targetPath, content, stagingToken) {
+  const staging = `${targetPath}.stage-${stagingToken}`;
+  let staged = false;
+  try {
+    fs.writeFileSync(staging, content, { mode: 384, flag: "wx" });
+    staged = true;
+    fs.linkSync(staging, targetPath);
+  } finally {
+    if (staged) {
+      try {
+        fs.unlinkSync(staging);
+      } catch {
+      }
+    }
+  }
+}
+function publishReclaimMarker(reclaimPath, marker) {
+  publishLinkedExclusive(reclaimPath, JSON.stringify(marker), marker.token);
+}
+function reclaimMarkerOrphaned(content, mtimeMs, now, readStartTime) {
+  try {
+    const marker = JSON.parse(content);
+    const alive = leaseOwnerAlive(marker, readStartTime);
+    if (alive !== void 0) return !alive;
+  } catch {
+  }
+  return now() - mtimeMs > RECLAIM_ORPHAN_MS;
+}
+function removeOrphanedReclaimMarker(reclaimPath, now, readStartTime) {
+  let content;
+  let mtimeMs;
+  try {
+    content = fs.readFileSync(reclaimPath, "utf8");
+    mtimeMs = fs.statSync(reclaimPath).mtimeMs;
+  } catch {
+    return true;
+  }
+  if (!reclaimMarkerOrphaned(content, mtimeMs, now, readStartTime)) return false;
+  let current;
+  try {
+    current = fs.readFileSync(reclaimPath, "utf8");
+  } catch {
+    current = void 0;
+  }
+  if (current !== content) return false;
+  try {
+    fs.unlinkSync(reclaimPath);
+  } catch {
+  }
+  return true;
+}
+function createSubagentSessionStore(sessionsDir, log, deps) {
+  const now = deps?.now ?? Date.now;
+  const readStartTime = deps?.readProcessStartTime ?? defaultReadProcessStartTime;
+  let selfStartTime;
+  let selfStartTimeRead = false;
+  const ownStartTime = () => {
+    if (!selfStartTimeRead) {
+      selfStartTime = readStartTime(process.pid);
+      selfStartTimeRead = true;
+    }
+    return selfStartTime;
+  };
+  const recordPath = (id) => {
+    if (!isSafeSessionId(id)) return void 0;
+    const filePath = path.join(sessionsDir, `${id}.json`);
+    return path.dirname(filePath) === sessionsDir ? filePath : void 0;
+  };
+  const recordLeaseHeld = (filePath) => {
+    let markerStat;
+    let markerContent;
+    try {
+      markerStat = fs.statSync(`${filePath}.lock.reclaim`);
+      markerContent = fs.readFileSync(`${filePath}.lock.reclaim`, "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") {
+      } else return true;
+    }
+    if (markerContent !== void 0 && !reclaimMarkerOrphaned(markerContent, markerStat.mtimeMs, now, readStartTime)) {
+      return true;
+    }
+    let lockStat;
+    let content;
+    try {
+      lockStat = fs.statSync(`${filePath}.lock`);
+      content = fs.readFileSync(`${filePath}.lock`, "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") return false;
+      return true;
+    }
+    try {
+      const lock = JSON.parse(content);
+      const alive = leaseOwnerAlive(lock, readStartTime);
+      if (alive !== void 0) return alive;
+    } catch {
+    }
+    return now() - lockStat.mtimeMs <= MALFORMED_LOCK_MAX_AGE_MS;
+  };
+  const acquireLease = (id) => {
+    const filePath = recordPath(id);
+    if (!filePath) throw new Error(`Invalid subagent session id "${id}"`);
+    const lockPath = `${filePath}.lock`;
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    const token = `${process.pid}-${now()}-${Math.random()}`;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const owner = { pid: process.pid, startedAt: ownStartTime(), timestamp: now(), token };
+        publishLinkedExclusive(lockPath, JSON.stringify(owner), token);
+        return () => {
+          try {
+            if (JSON.parse(fs.readFileSync(lockPath, "utf8")).token === token) fs.unlinkSync(lockPath);
+          } catch {
+          }
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        const reclaimPath = `${lockPath}.reclaim`;
+        const publishMarker = () => {
+          publishReclaimMarker(reclaimPath, { pid: process.pid, startedAt: ownStartTime(), token });
+        };
+        try {
+          publishMarker();
+        } catch (reclaimError) {
+          if (reclaimError.code !== "EEXIST") throw reclaimError;
+          if (!removeOrphanedReclaimMarker(reclaimPath, now, readStartTime)) {
+            throw new Error(`Subagent session "${id}" is busy (session lease held by another process).`);
+          }
+          try {
+            publishMarker();
+          } catch {
+            throw new Error(`Subagent session "${id}" is busy (session lease held by another process).`);
+          }
+        }
+        try {
+          const stat = fs.statSync(lockPath);
+          let lockContent;
+          try {
+            lockContent = fs.readFileSync(lockPath, "utf8");
+          } catch (readError) {
+            if (readError.code === "ENOENT") continue;
+            throw new Error(`Subagent session "${id}" is busy (session lease is unreadable).`);
+          }
+          let stale = false;
+          try {
+            const lock = JSON.parse(lockContent);
+            const alive = leaseOwnerAlive(lock, readStartTime);
+            stale = alive === void 0 ? now() - stat.mtimeMs > MALFORMED_LOCK_MAX_AGE_MS : !alive;
+          } catch {
+            stale = now() - stat.mtimeMs > MALFORMED_LOCK_MAX_AGE_MS;
+          }
+          if (!stale) throw new Error(`Subagent session "${id}" is busy (session lease held by another process).`);
+          let current;
+          try {
+            current = fs.readFileSync(lockPath, "utf8");
+          } catch {
+            current = void 0;
+          }
+          if (current !== lockContent) {
+            throw new Error(`Subagent session "${id}" is busy (session lease changed during reclamation).`);
+          }
+          try {
+            fs.unlinkSync(lockPath);
+          } catch {
+          }
+        } finally {
+          try {
+            if (JSON.parse(fs.readFileSync(reclaimPath, "utf8")).token === token) fs.unlinkSync(reclaimPath);
+          } catch {
+          }
+        }
+      }
+    }
+    throw new Error(`Subagent session "${id}" is busy (could not acquire session lease).`);
+  };
+  return {
+    acquire(id) {
+      return acquireLease(id);
+    },
+    load(id) {
+      const filePath = recordPath(id);
+      if (!filePath) return void 0;
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf8");
+      } catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR") return void 0;
+        throw error;
+      }
+      try {
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === "object" && typeof parsed.version === "number" && parsed.version !== SUBAGENT_SESSION_RECORD_VERSION) {
+          throw new Error(`session record version ${parsed.version} is not readable by this build (supported version ${SUBAGENT_SESSION_RECORD_VERSION}); it may be history written by a newer Pie`);
+        }
+        if (!parsed || typeof parsed !== "object" || parsed.version !== SUBAGENT_SESSION_RECORD_VERSION || parsed.id !== id || !Array.isArray(parsed.messages)) {
+          return void 0;
+        }
+        return parsed;
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    save(record) {
+      const filePath = recordPath(record.id);
+      if (!filePath) return false;
+      try {
+        const payload = JSON.stringify(record);
+        if (Buffer.byteLength(payload, "utf8") > MAX_RECORD_BYTES) {
+          log?.(`[subagent-sessions] skipping persist of ${record.id}: over the ${MAX_RECORD_BYTES}-byte cap`);
+          return false;
+        }
+        fs.mkdirSync(sessionsDir, { recursive: true });
+        const tmpPath = `${filePath}.tmp-${process.pid}`;
+        try {
+          const fd = fs.openSync(tmpPath, "w", 384);
+          try {
+            fs.writeFileSync(fd, payload);
+            fs.fsyncSync(fd);
+          } finally {
+            fs.closeSync(fd);
+          }
+          fs.renameSync(tmpPath, filePath);
+        } catch (error) {
+          try {
+            fs.unlinkSync(tmpPath);
+          } catch {
+          }
+          throw error;
+        }
+        try {
+          const dirFd = fs.openSync(sessionsDir, "r");
+          try {
+            fs.fsyncSync(dirFd);
+          } finally {
+            fs.closeSync(dirFd);
+          }
+        } catch (error) {
+          const code = error.code;
+          if (!(code === "EISDIR" || code === "EPERM" || code === "EINVAL" || code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "EBUSY")) {
+            throw error;
+          }
+        }
+        return true;
+      } catch (error) {
+        log?.(`[subagent-sessions] persist of ${record.id} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+      }
+    },
+    sweep({ maxAgeMs, maxRecords }) {
+      try {
+        if (!fs.existsSync(sessionsDir)) return;
+        const nowMs = now();
+        const entries = fs.readdirSync(sessionsDir).filter((file) => file.endsWith(".json")).map((file) => {
+          try {
+            const stat = fs.statSync(path.join(sessionsDir, file));
+            return { file, mtimeMs: stat.mtimeMs, dev: stat.dev, ino: stat.ino };
+          } catch {
+            return { file, mtimeMs: 0, dev: -1, ino: -1 };
+          }
+        }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+        entries.forEach((entry, index) => {
+          if (index < maxRecords && nowMs - entry.mtimeMs <= maxAgeMs) return;
+          const filePath = path.join(sessionsDir, entry.file);
+          if (recordLeaseHeld(filePath)) return;
+          let release;
+          try {
+            release = acquireLease(entry.file.slice(0, -".json".length));
+          } catch {
+            return;
+          }
+          try {
+            try {
+              const stat = fs.statSync(filePath);
+              if (stat.dev !== entry.dev || stat.ino !== entry.ino || stat.mtimeMs !== entry.mtimeMs) return;
+            } catch {
+              return;
+            }
+            try {
+              fs.unlinkSync(filePath);
+            } catch {
+            }
+          } finally {
+            void Promise.resolve(release()).catch(() => void 0);
+          }
+        });
+      } catch {
+      }
+    }
+  };
+}
+
 // builtin/extensions/subagent/index.ts
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 function subagentExtension(ctx) {
   ctx.log("Subagent extension loaded (transparent parallel mode)");
   const resolveRuntimePair = () => {
@@ -25,6 +377,10 @@ function subagentExtension(ctx) {
   };
   const skills = ctx.skills || [];
   const capability = createSubagentCapability({
+    // Persisted alongside the CLI's own session state: a sessionId from an
+    // earlier result stays recallable across restarts and /resume. Tools and
+    // credentials are re-resolved at recall time, never persisted.
+    sessionStore: createSubagentSessionStore(path2.join(os.homedir(), ".pie", "subagent-sessions"), (message) => ctx.log(message)),
     get apiKey() {
       return resolveRuntimePair().apiKey;
     },
@@ -47,7 +403,7 @@ function subagentExtension(ctx) {
       if (mode === "edit") {
         throw new Error("Edit delegation requires the parent's executable runtime tools; fallback tools are read-mode only.");
       }
-      const configDir = path.join(os.homedir(), ".pie");
+      const configDir = path2.join(os.homedir(), ".pie");
       const fsOptions = ctx.yoloMode ? { allowlistedDirs: ["/"] } : {
         accessRoots: [
           ctx.cwd,

package/dist/builtin/extensions/todo/index.js

@@ -8,9 +8,9 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-QKSK5K5N.js";
-import "../../../chunks/chunk-AETQBDEG.js";
-import "../../../chunks/chunk-5OXH6NUH.js";
+} from "../../../chunks/chunk-T6GMEDIE.js";
+import "../../../chunks/chunk-PAC62XU4.js";
+import "../../../chunks/chunk-7B4IIBVS.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";