@piagent/platform 1.2.9 → 1.2.11

package/packages/piagent-core/extensions/policy-core.js

@@ -1987,6 +1987,7 @@ function extractAttachedRedirectionPaths(segment) {
       index += 1;
     }
 
+    const writesFile = char === ">" || (char === "<" && next === ">");
     if ((char === ">" && (next === ">" || next === "|")) || (char === "<" && next === ">")) index += 1;
     let cursor = index + 1;
     while (/\s/.test(segment[cursor] ?? "")) cursor += 1;
@@ -2054,13 +2055,22 @@ function extractAttachedRedirectionPaths(segment) {
       target += targetChar;
       targetMask += (targetQuote || insideSubstitution) ? "1" : "0";
     }
-    if (target) paths.push({ value: target, literalMask: targetMask });
+    if (target) paths.push({ value: target, literalMask: targetMask, writesFile });
     index = Math.max(index, cursor - 1);
   }
 
   return paths;
 }
 
+export function shellHasFileWriteRedirection(command) {
+  return splitShellSegments(String(command ?? "")).some((segment) => (
+    extractAttachedRedirectionPaths(segment)
+      .filter((redirect) => redirect.writesFile)
+      .flatMap(redirectionTargetWords)
+      .length > 0
+  ));
+}
+
 export function extractShellPathCandidates(command) {
   const candidates = [...xargsPipelineInputCandidates(command)];
   const assignments = new Map();

package/packages/piagent-core/extensions/runtime-evidence.js

@@ -2,6 +2,10 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { redactSensitiveText } from "../security/sensitive-data.js";
+import { appendJsonlBounded, readJsonlTail } from "./state-retention.js";
+import { resolveLocalStatePath } from "./local-state-path.js";
+
+const MAX_OBSERVED_BASH_BYTES = 8 * 1024 * 1024;
 
 export function normalizeEvidenceCommand(command) {
   return String(command ?? "")
@@ -180,40 +184,56 @@ function persistedObservedEntry(entry) {
 }
 
 export function readObservedBashResults(filePath, options = {}) {
-  if (!filePath || !fs.existsSync(filePath)) return [];
+  if (!filePath) return [];
   const maxEntries = Number.isInteger(options.maxEntries) ? options.maxEntries : 5000;
-  const text = fs.readFileSync(filePath, "utf8");
   const entries = [];
-  for (const line of text.split(/\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      const entry = canonicalObservedEntry(parsed);
-      if (entry) entries.push(entry);
-    } catch {
-      // Ignore a partially written/corrupt JSONL line. The ledger is advisory evidence,
-      // and the final gate remains fail-closed when no valid observation is available.
-    }
+  for (const parsed of readJsonlTail(filePath, {
+    maxEntries,
+    limit: maxEntries,
+    maxBytes: MAX_OBSERVED_BASH_BYTES,
+    projectRoot: options.projectRoot
+  })) {
+    const entry = canonicalObservedEntry(parsed);
+    if (entry) entries.push(entry);
   }
   return entries.slice(-maxEntries);
 }
 
-function pruneObservedBashFile(filePath, maxPersistedEntries) {
+function pruneObservedBashFile(filePath, maxPersistedEntries, projectRoot) {
   if (!Number.isInteger(maxPersistedEntries) || maxPersistedEntries <= 0) return;
-  const entries = readObservedBashResults(filePath, { maxEntries: maxPersistedEntries });
+  const entries = readObservedBashResults(filePath, { maxEntries: maxPersistedEntries, projectRoot });
   const lines = entries.map((entry) => JSON.stringify(persistedObservedEntry(entry))).filter(Boolean);
-  fs.writeFileSync(filePath, `${lines.join("\n")}${lines.length ? "\n" : ""}`);
+  const safePath = projectRoot
+    ? resolveLocalStatePath(projectRoot, filePath, { label: "Observed bash ledger", kind: "file" })
+    : filePath;
+  const descriptor = fs.openSync(
+    safePath,
+    fs.constants.O_WRONLY | fs.constants.O_TRUNC | (fs.constants.O_NOFOLLOW ?? 0),
+    0o600
+  );
+  try {
+    fs.writeSync(descriptor, `${lines.join("\n")}${lines.length ? "\n" : ""}`);
+    try {
+      fs.fchmodSync(descriptor, 0o600);
+    } catch {
+      // Best effort on filesystems that do not expose POSIX modes.
+    }
+  } finally {
+    fs.closeSync(descriptor);
+  }
 }
 
 export function appendObservedBashResult(filePath, entry, options = {}) {
   if (!filePath) return undefined;
   const persisted = persistedObservedEntry(entry);
   if (!persisted) return undefined;
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.appendFileSync(filePath, `${JSON.stringify(persisted)}\n`);
+  appendJsonlBounded(filePath, persisted, {
+    maxBytes: MAX_OBSERVED_BASH_BYTES,
+    mode: 0o600,
+    projectRoot: options.projectRoot
+  });
   if (Number.isInteger(options.maxPersistedEntries)) {
-    pruneObservedBashFile(filePath, options.maxPersistedEntries);
+    pruneObservedBashFile(filePath, options.maxPersistedEntries, options.projectRoot);
   }
   return persisted;
 }

package/packages/piagent-core/extensions/state-retention.js

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ensurePrivateStateDirectory, resolveLocalStatePath } from "./local-state-path.js";
+
+const LOCK_WAIT_MS = 500;
+const LOCK_STALE_MS = 5_000;
+const sleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+
+function ensurePrivateParent(filePath, projectRoot) {
+  const safeFilePath = projectRoot
+    ? resolveLocalStatePath(projectRoot, filePath, { label: "Local JSONL state" })
+    : filePath;
+  if (projectRoot) ensurePrivateStateDirectory(projectRoot, path.dirname(filePath), "Local JSONL state directory");
+  else fs.mkdirSync(path.dirname(safeFilePath), { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(path.dirname(safeFilePath), 0o700);
+  } catch {
+    // Best effort on filesystems that do not expose POSIX modes.
+  }
+  return safeFilePath;
+}
+
+function withFileLock(filePath, action) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  let descriptor;
+  while (descriptor === undefined) {
+    try {
+      descriptor = fs.openSync(lockPath, "wx", 0o600);
+      fs.writeFileSync(descriptor, `${process.pid}\n`);
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        if (Date.now() - fs.lstatSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+          fs.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch (statError) {
+        if (statError?.code === "ENOENT") continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for state lock: ${path.basename(filePath)}`);
+      }
+      Atomics.wait(sleepBuffer, 0, 0, 10);
+    }
+  }
+  try {
+    return action();
+  } finally {
+    try {
+      fs.closeSync(descriptor);
+    } finally {
+      fs.rmSync(lockPath, { force: true });
+    }
+  }
+}
+
+function rotateJsonl(filePath, maxBytes, incomingBytes = 0) {
+  if (!Number.isInteger(maxBytes) || maxBytes <= 0) return false;
+  let size;
+  try {
+    size = fs.statSync(filePath).size;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+  if (size === 0 || size + incomingBytes <= maxBytes) return false;
+  const previous = `${filePath}.1`;
+  try {
+    fs.rmSync(previous, { force: true });
+    fs.renameSync(filePath, previous);
+    fs.chmodSync(previous, 0o600);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function boundedJsonLine(record, maxBytes) {
+  const line = `${JSON.stringify(record)}\n`;
+  const originalBytes = Buffer.byteLength(line);
+  if (!Number.isInteger(maxBytes) || maxBytes <= 0 || originalBytes <= maxBytes) return { line, record };
+  const summary = {
+    schemaVersion: Number.isInteger(record?.schemaVersion) ? record.schemaVersion : 1,
+    recordedAt: typeof record?.recordedAt === "string" ? record.recordedAt : new Date().toISOString(),
+    event: typeof record?.event === "string" ? record.event : "oversized_record",
+    truncated: true,
+    originalBytes
+  };
+  const summaryLine = `${JSON.stringify(summary)}\n`;
+  if (Buffer.byteLength(summaryLine) > maxBytes) {
+    throw new RangeError(`maxBytes ${maxBytes} is too small for a bounded JSONL record`);
+  }
+  return { line: summaryLine, record: summary };
+}
+
+export function appendJsonlBounded(filePath, record, options = {}) {
+  const safeFilePath = ensurePrivateParent(filePath, options.projectRoot);
+  const bounded = boundedJsonLine(record, options.maxBytes);
+  return withFileLock(safeFilePath, () => {
+    rotateJsonl(safeFilePath, options.maxBytes, Buffer.byteLength(bounded.line));
+    const descriptor = fs.openSync(
+      safeFilePath,
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND | (fs.constants.O_NOFOLLOW ?? 0),
+      options.mode ?? 0o600
+    );
+    try {
+      fs.writeSync(descriptor, bounded.line);
+      try {
+        fs.fchmodSync(descriptor, options.mode ?? 0o600);
+      } catch {
+        // Best effort on filesystems that do not expose POSIX modes.
+      }
+    } finally {
+      fs.closeSync(descriptor);
+    }
+    return bounded.record;
+  });
+}
+
+function readTailText(filePath, maxBytes) {
+  try {
+    const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+      const stat = fs.fstatSync(descriptor);
+      const start = Math.max(0, stat.size - maxBytes);
+      const length = stat.size - start;
+      const buffer = Buffer.allocUnsafe(length);
+      fs.readSync(descriptor, buffer, 0, length, start);
+      let text = buffer.toString("utf8");
+      if (start > 0) text = text.slice(Math.max(0, text.indexOf("\n") + 1));
+      return text;
+    } finally {
+      fs.closeSync(descriptor);
+    }
+  } catch (error) {
+    if (error?.code === "ENOENT") return "";
+    throw error;
+  }
+}
+
+export function readJsonlTail(filePath, options = {}) {
+  const limit = Math.max(1, Number.isInteger(options.limit) ? options.limit : 100);
+  const maxBytes = Math.max(64 * 1024, Number.isInteger(options.maxBytes) ? options.maxBytes : 8 * 1024 * 1024);
+  const safeFilePath = options.projectRoot
+    ? resolveLocalStatePath(options.projectRoot, filePath, { label: "Local JSONL state" })
+    : filePath;
+  const sources = options.projectRoot
+    ? [
+        resolveLocalStatePath(options.projectRoot, `${filePath}.1`, { label: "Rotated local JSONL state" }),
+        safeFilePath
+      ]
+    : [`${safeFilePath}.1`, safeFilePath];
+  const lines = sources.flatMap((source) => readTailText(source, maxBytes).split(/\r?\n/).filter(Boolean));
+  const records = [];
+  for (const line of lines.slice(-limit)) {
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      // Ignore a partial record left by interruption or concurrent rotation.
+    }
+  }
+  return records;
+}
+
+export function pruneCaptureFiles(root, options = {}) {
+  const safeRoot = options.projectRoot
+    ? resolveLocalStatePath(options.projectRoot, root, { label: "Tool-result capture root" })
+    : root;
+  if (!fs.existsSync(safeRoot)) return { removed: 0, kept: 0, bytes: 0 };
+  if (options.projectRoot) resolveLocalStatePath(options.projectRoot, root, { label: "Tool-result capture root", kind: "directory" });
+  const maxFiles = Math.max(1, Number.isInteger(options.maxFiles) ? options.maxFiles : 500);
+  const maxBytes = Math.max(1024 * 1024, Number.isInteger(options.maxBytes) ? options.maxBytes : 128 * 1024 * 1024);
+  const maxAgeMs = Math.max(60_000, Number.isFinite(options.maxAgeMs) ? options.maxAgeMs : 30 * 24 * 60 * 60 * 1000);
+  const now = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const files = [];
+  const walk = (directory) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error?.code === "ENOENT") return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) walk(absolute);
+      else if (entry.isFile() && entry.name.endsWith(".log")) {
+        try {
+          const stat = fs.statSync(absolute);
+          files.push({ absolute, mtimeMs: stat.mtimeMs, size: stat.size });
+        } catch (error) {
+          if (error?.code !== "ENOENT") throw error;
+        }
+      }
+    }
+  };
+  walk(safeRoot);
+  files.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  let kept = 0;
+  let bytes = 0;
+  let removed = 0;
+  for (const file of files) {
+    const keep = kept < maxFiles && bytes + file.size <= maxBytes && now - file.mtimeMs <= maxAgeMs;
+    if (keep) {
+      kept += 1;
+      bytes += file.size;
+      continue;
+    }
+    try {
+      fs.rmSync(file.absolute);
+      removed += 1;
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+  }
+  return { removed, kept, bytes };
+}

package/packages/piagent-core/extensions/task-lifecycle.js

@@ -0,0 +1,138 @@
+import crypto from "node:crypto";
+
+function sameValues(left, right) {
+  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+
+function matchesStep(step, expected) {
+  return step?.id === expected.id
+    && step?.role === expected.role
+    && step?.mode === expected.mode
+    && sameValues(step?.dependsOn, expected.dependsOn);
+}
+
+const AUTOMATIC_TINY_PLAN = [
+  { id: "implement", role: "parent", mode: "single-writer", dependsOn: undefined },
+  { id: "verify", role: "parent", mode: "review", dependsOn: ["implement"] }
+];
+
+const ASSISTED_NORMAL_PLAN = [
+  { id: "plan", role: "parent", mode: "read-only", dependsOn: undefined },
+  { id: "implement", role: "parent", mode: "single-writer", dependsOn: ["plan"] },
+  { id: "review", role: "piagent-reviewer", mode: "review", dependsOn: ["implement"] }
+];
+
+const AUTOMATIC_READ_ONLY_PLAN = [
+  { id: "scout", role: "parent", mode: "read-only", dependsOn: undefined }
+];
+
+const ASSISTED_READ_ONLY_PLAN = [
+  { id: "scout", role: "parent", mode: "read-only", dependsOn: undefined },
+  { id: "review", role: "piagent-reviewer", mode: "review", dependsOn: ["scout"] }
+];
+
+export function runtimeLifecycleMode(task) {
+  if (!Array.isArray(task?.workPlan)) return "manual";
+  if (
+    task.changeMode === "read-only"
+    && task.riskLane === "tiny"
+    && task.workPlan.length === AUTOMATIC_READ_ONLY_PLAN.length
+    && task.workPlan.every((step, index) => matchesStep(step, AUTOMATIC_READ_ONLY_PLAN[index]))
+  ) return "automatic-readonly";
+  if (
+    task.changeMode === "read-only"
+    && task.riskLane === "normal"
+    && task.workPlan.length === ASSISTED_READ_ONLY_PLAN.length
+    && task.workPlan.every((step, index) => matchesStep(step, ASSISTED_READ_ONLY_PLAN[index]))
+  ) return "assisted-readonly";
+  if (task.changeMode !== "source-change") return "manual";
+  if (
+    task.riskLane === "tiny"
+    && task.workPlan.length === AUTOMATIC_TINY_PLAN.length
+    && task.workPlan.every((step, index) => matchesStep(step, AUTOMATIC_TINY_PLAN[index]))
+  ) return "automatic";
+  if (
+    task.riskLane === "normal"
+    && task.workPlan.length === ASSISTED_NORMAL_PLAN.length
+    && task.workPlan.every((step, index) => matchesStep(step, ASSISTED_NORMAL_PLAN[index]))
+  ) return "assisted";
+  return "manual";
+}
+
+export function workingTreeEvidenceDigest(snapshot) {
+  const entries = Object.entries(snapshot ?? {})
+    .filter(([file, digest]) => typeof file === "string" && typeof digest === "string")
+    .sort(([left], [right]) => left.localeCompare(right));
+  return crypto.createHash("sha256").update(JSON.stringify(entries)).digest("hex");
+}
+
+function setStep(step, status, note, recordedAt) {
+  if (!step || (step.status === status && step.note === note)) return false;
+  step.status = status;
+  step.note = note;
+  step.updatedAt = recordedAt;
+  return true;
+}
+
+export function applyRuntimeLifecycleObservation(task, observation, recordedAt = new Date().toISOString()) {
+  const mode = runtimeLifecycleMode(task);
+  if (mode === "manual") return { changed: false, mode };
+
+  const byId = new Map(task.workPlan.map((step) => [step.id, step]));
+  let changed = false;
+  if (observation === "context-complete") {
+    if (mode === "automatic-readonly") {
+      changed = setStep(byId.get("scout"), "done", "Runtime observed bounded read-only evidence for this scout.", recordedAt) || changed;
+    } else if (mode === "assisted-readonly") {
+      changed = setStep(byId.get("scout"), "done", "Runtime observed bounded read-only evidence for this scout.", recordedAt) || changed;
+      const review = byId.get("review");
+      if (review?.status === "pending") {
+        changed = setStep(review, "in-progress", "Review the evidence and stated unknowns before handoff.", recordedAt) || changed;
+      }
+    }
+    return { changed, mode };
+  }
+
+  if (mode === "automatic-readonly" || mode === "assisted-readonly") {
+    return { changed: false, mode };
+  }
+  if (observation === "mutation") {
+    if (mode === "assisted") {
+      changed = setStep(byId.get("plan"), "done", "Runtime observed bounded context followed by a project mutation.", recordedAt) || changed;
+    }
+    changed = setStep(byId.get("implement"), "in-progress", "Runtime observed a project mutation; current verification is required.", recordedAt) || changed;
+    const terminalStep = byId.get(mode === "automatic" ? "verify" : "review");
+    if (terminalStep && terminalStep.status !== "pending") {
+      changed = setStep(terminalStep, "pending", "A later mutation invalidated the previous terminal evidence.", recordedAt) || changed;
+    }
+    return { changed, mode };
+  }
+
+  if (observation === "verification-pending") {
+    if (mode === "assisted") {
+      changed = setStep(byId.get("plan"), "done", "Runtime observed bounded context followed by implementation.", recordedAt) || changed;
+    }
+    changed = setStep(byId.get("implement"), "done", "Runtime observed project changes and an exact configured verifier.", recordedAt) || changed;
+    const verifyStep = byId.get(mode === "automatic" ? "verify" : "review");
+    if (verifyStep?.status === "pending") {
+      changed = setStep(verifyStep, "in-progress", "Waiting for current passing verification or explicit review evidence.", recordedAt) || changed;
+    }
+    return { changed, mode };
+  }
+
+  if (observation === "verification-complete") {
+    if (mode === "assisted") {
+      changed = setStep(byId.get("plan"), "done", "Runtime observed bounded context followed by implementation.", recordedAt) || changed;
+    }
+    changed = setStep(byId.get("implement"), "done", "All configured verifiers passed against the current working tree.", recordedAt) || changed;
+    if (mode === "automatic") {
+      changed = setStep(byId.get("verify"), "done", "Runtime observed every configured verifier passing against the current working tree.", recordedAt) || changed;
+    } else {
+      const review = byId.get("review");
+      if (review?.status === "pending") {
+        changed = setStep(review, "in-progress", "Verification passed; complete the explicit review lens before handoff.", recordedAt) || changed;
+      }
+    }
+  }
+  return { changed, mode };
+}