@keyou007/agent-bot 0.1.15-alpha.0 → 0.1.15-alpha.2

package/src/state/StateStore.ts

@@ -68,6 +68,13 @@ export interface AgentBotTurnMessageRecord extends TurnAnchorRecord {
   messageKind: "progress" | "final";
 }
 
+export interface GoalCardDeliveryRecord {
+  localSessionId: string;
+  contextKey: string;
+  messageId: string;
+  updatedAt: string;
+}
+
 export interface TurnRuntimeOriginRecord {
   turnId: string;
   localSessionId: string;
@@ -242,6 +249,46 @@ export class StateStore {
     `);
   }
 
+  saveGoalCardDelivery(localSessionId: string, contextKey: string, messageId: string): void {
+    const updatedAt = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO goal_card_deliveries (local_session_id, context_key, message_id, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(local_session_id, context_key) DO UPDATE SET
+        message_id = excluded.message_id,
+        updated_at = excluded.updated_at
+    `).run(localSessionId, contextKey, messageId, updatedAt);
+  }
+
+  getGoalCardDelivery(localSessionId: string, contextKey: string): GoalCardDeliveryRecord | undefined {
+    const row = this.db.prepare(`
+      SELECT local_session_id, context_key, message_id, updated_at
+      FROM goal_card_deliveries
+      WHERE local_session_id = ? AND context_key = ?
+    `).get(localSessionId, contextKey) as {
+      local_session_id: string;
+      context_key: string;
+      message_id: string;
+      updated_at: string;
+    } | undefined;
+    return row ? goalCardDeliveryFromRow(row) : undefined;
+  }
+
+  listGoalCardDeliveries(localSessionId: string): GoalCardDeliveryRecord[] {
+    const rows = this.db.prepare(`
+      SELECT local_session_id, context_key, message_id, updated_at
+      FROM goal_card_deliveries
+      WHERE local_session_id = ?
+      ORDER BY updated_at ASC
+    `).all(localSessionId) as Array<{
+      local_session_id: string;
+      context_key: string;
+      message_id: string;
+      updated_at: string;
+    }>;
+    return rows.map(goalCardDeliveryFromRow);
+  }
+
   close(): void {
     this.db.close();
   }
@@ -1058,6 +1105,91 @@ export class StateStore {
     }));
   }
 
+  listTaskTurnGraph(localSessionId: string): CompletedTurnSnapshotRecord[] {
+    this.backfillTurnParents(localSessionId);
+    const records = new Map(
+      this.listCompletedTurnGraphRows(localSessionId).map((record) => [record.turnId, record]),
+    );
+    let ancestorTurnId = this.findForkSourceTurnId(localSessionId)
+      ?? this.findCrossSessionParentTurnId(localSessionId);
+    const visited = new Set<string>();
+
+    while (ancestorTurnId && !visited.has(ancestorTurnId)) {
+      visited.add(ancestorTurnId);
+      const ancestor = this.getCompletedTurnGraphRecord(ancestorTurnId);
+      if (!ancestor) break;
+      records.set(ancestor.turnId, ancestor);
+      ancestorTurnId = ancestor.parentTurnId;
+    }
+
+    return [...records.values()].sort(compareCompletedTurnSnapshots);
+  }
+
+  private listCompletedTurnGraphRows(localSessionId: string): CompletedTurnSnapshotRecord[] {
+    const rows = this.db.prepare(`
+      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
+      FROM turn_snapshots ts
+      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
+      WHERE ts.local_session_id = ?
+        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
+    `).all(localSessionId) as Array<{
+      turn_id: string;
+      parent_turn_id: string | null;
+      snapshot_json: string;
+      updated_at: string;
+    }>;
+    return rows.map(mapCompletedTurnSnapshot);
+  }
+
+  private getCompletedTurnGraphRecord(turnId: string): CompletedTurnSnapshotRecord | undefined {
+    const owner = this.db.prepare(`
+      SELECT local_session_id
+      FROM turn_snapshots
+      WHERE turn_id = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+    `).get(turnId) as { local_session_id: string } | undefined;
+    if (!owner) return undefined;
+    this.backfillTurnParents(owner.local_session_id);
+    const row = this.db.prepare(`
+      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
+      FROM turn_snapshots ts
+      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
+      WHERE ts.turn_id = ?
+        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
+    `).get(turnId) as {
+      turn_id: string;
+      parent_turn_id: string | null;
+      snapshot_json: string;
+      updated_at: string;
+    } | undefined;
+    return row ? mapCompletedTurnSnapshot(row) : undefined;
+  }
+
+  private findForkSourceTurnId(localSessionId: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT json_extract(payload_json, '$.sourceTurnId') AS source_turn_id
+      FROM audit_events
+      WHERE event_type IN ('session_forked', 'thread_forked')
+        AND json_extract(payload_json, '$.forkedLocalSessionId') = ?
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(localSessionId) as { source_turn_id: string | null } | undefined;
+    return row?.source_turn_id ?? undefined;
+  }
+
+  private findCrossSessionParentTurnId(localSessionId: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT links.parent_turn_id
+      FROM turn_parent_links links
+      JOIN turn_snapshots parent ON parent.turn_id = links.parent_turn_id
+      WHERE links.local_session_id = ?
+        AND parent.local_session_id <> ?
+      ORDER BY links.created_at ASC
+      LIMIT 1
+    `).get(localSessionId, localSessionId) as { parent_turn_id: string } | undefined;
+    return row?.parent_turn_id;
+  }
+
   private backfillTurnParents(localSessionId: string): void {
     const turns = this.db.prepare(`
       SELECT
@@ -1873,6 +2005,20 @@ function mapMessageReaction(row: MessageReactionRow): MessageReactionRecord {
   };
 }
 
+function goalCardDeliveryFromRow(row: {
+  local_session_id: string;
+  context_key: string;
+  message_id: string;
+  updated_at: string;
+}): GoalCardDeliveryRecord {
+  return {
+    localSessionId: row.local_session_id,
+    contextKey: row.context_key,
+    messageId: row.message_id,
+    updatedAt: row.updated_at,
+  };
+}
+
 function mapQueuedPrompt(row: QueuedPromptRow): QueuedPromptRecord {
   const parsedPaths = JSON.parse(row.local_image_paths_json) as unknown;
   const localImagePaths = Array.isArray(parsedPaths)
@@ -1915,6 +2061,40 @@ function mapTurnAttempt(row: TurnAttemptRow): TurnAttemptRecord {
   };
 }
 
+function mapCompletedTurnSnapshot(row: {
+  turn_id: string;
+  parent_turn_id: string | null;
+  snapshot_json: string;
+  updated_at: string;
+}): CompletedTurnSnapshotRecord {
+  return {
+    turnId: row.turn_id,
+    parentTurnId: row.parent_turn_id ?? undefined,
+    snapshot: JSON.parse(row.snapshot_json),
+    updatedAt: row.updated_at,
+  };
+}
+
+function compareCompletedTurnSnapshots(
+  left: CompletedTurnSnapshotRecord,
+  right: CompletedTurnSnapshotRecord,
+): number {
+  const timeDifference = completedTurnTimestamp(right) - completedTurnTimestamp(left);
+  return timeDifference || right.updatedAt.localeCompare(left.updatedAt);
+}
+
+function completedTurnTimestamp(record: CompletedTurnSnapshotRecord): number {
+  const snapshot = record.snapshot && typeof record.snapshot === "object"
+    ? record.snapshot as { completedAt?: unknown; startedAt?: unknown }
+    : undefined;
+  const timestamp = typeof snapshot?.completedAt === "number"
+    ? snapshot.completedAt
+    : typeof snapshot?.startedAt === "number"
+      ? snapshot.startedAt
+      : Date.parse(record.updatedAt);
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+
 function isIncompleteTurnAttemptStatus(status: TurnAttemptStatus): boolean {
   return status === "accepted" || status === "running" || status === "recovering";
 }

package/src/state/migrations.ts

@@ -173,4 +173,15 @@ export const migrations = [
   CREATE INDEX IF NOT EXISTS idx_turn_attempts_turn
     ON turn_attempts(turn_id);
   `,
+  `
+  CREATE TABLE IF NOT EXISTS goal_card_deliveries (
+    local_session_id TEXT NOT NULL,
+    context_key TEXT NOT NULL,
+    message_id TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (local_session_id, context_key)
+  );
+  CREATE INDEX IF NOT EXISTS idx_goal_card_deliveries_session
+    ON goal_card_deliveries(local_session_id);
+  `,
 ] as const;

package/src/supervision/SupervisorDiagnostics.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { AppConfig } from "../config/schema.js";
+import { DailyLogStream, dailyLogPath } from "../logging/DailyLogStream.js";
 
 const MAX_LOG_BYTES = 10 * 1024 * 1024;
 const LOG_BACKUP_COUNT = 3;
@@ -42,8 +43,12 @@ type ExtendedProcessReport = typeof process.report & {
 
 export class SupervisorDiagnostics {
   readonly paths: SupervisorDiagnosticsPaths;
+  private workerStderrStream?: DailyLogStream;
 
-  constructor(config: Pick<AppConfig, "logging" | "storage">) {
+  constructor(
+    config: Pick<AppConfig, "logging" | "storage">,
+    private readonly clock: () => Date = () => new Date(),
+  ) {
     this.paths = resolveSupervisorDiagnosticsPaths(config);
   }
 
@@ -51,13 +56,13 @@ export class SupervisorDiagnostics {
     try {
       ensurePrivateDirectory(path.dirname(this.paths.supervisorLogPath));
       ensurePrivateDirectory(this.paths.crashReportDirectory);
-      rotateLogFile(this.paths.supervisorLogPath);
-      rotateLogFile(this.paths.workerStderrPath);
+      rotateLogFile(this.currentSupervisorLogPath());
+      rotateLogFile(this.currentWorkerStderrPath());
       this.configureCurrentProcessReports();
       this.writeEvent("diagnostics_initialized", {
         nodeVersion: process.versions.node,
-        supervisorLogPath: this.paths.supervisorLogPath,
-        workerStderrPath: this.paths.workerStderrPath,
+        supervisorLogPath: this.currentSupervisorLogPath(),
+        workerStderrPath: this.currentWorkerStderrPath(),
         crashReportDirectory: this.paths.crashReportDirectory,
       });
     } catch (error) {
@@ -73,40 +78,51 @@ export class SupervisorDiagnostics {
       ...data,
     })}\n`;
     try {
-      fs.appendFileSync(this.paths.supervisorLogPath, line, { encoding: "utf8", mode: 0o600 });
-      restrictFilePermissions(this.paths.supervisorLogPath);
+      const logPath = this.currentSupervisorLogPath();
+      rotateLogFile(logPath);
+      fs.appendFileSync(logPath, line, { encoding: "utf8", mode: 0o600 });
+      restrictFilePermissions(logPath);
     } catch (error) {
       writeFallbackDiagnostic(event, error);
     }
   }
 
-  openWorkerStderr(): number | "ignore" {
+  openWorkerStderr(): DailyLogStream | "ignore" {
     try {
-      rotateLogFile(this.paths.workerStderrPath);
-      fs.appendFileSync(
-        this.paths.workerStderrPath,
-        `${JSON.stringify({ event: "worker_started", time: new Date().toISOString() })}\n`,
-        { encoding: "utf8", mode: 0o600 },
-      );
-      restrictFilePermissions(this.paths.workerStderrPath);
-      return fs.openSync(this.paths.workerStderrPath, "a", 0o600);
+      const stream = new DailyLogStream(this.paths.workerStderrPath, {
+        clock: this.clock,
+        mode: 0o600,
+        beforeOpen: (filePath) => rotateLogFile(filePath),
+      });
+      stream.on("error", (error) => {
+        this.writeEvent("worker_stderr_write_failed", { error: errorMessage(error) });
+      });
+      stream.write(`${JSON.stringify({ event: "worker_started", time: this.clock().toISOString() })}\n`);
+      this.workerStderrStream = stream;
+      return stream;
     } catch (error) {
       this.writeEvent("worker_stderr_open_failed", { error: errorMessage(error) });
       return "ignore";
     }
   }
 
-  closeWorkerStderr(target: number | "ignore"): void {
-    if (typeof target !== "number") return;
-    try {
-      fs.closeSync(target);
-    } catch (error) {
-      this.writeEvent("worker_stderr_close_failed", { error: errorMessage(error) });
-    }
+  closeWorkerStderr(target: DailyLogStream | "ignore"): Promise<void> {
+    if (target === "ignore") return Promise.resolve();
+    return new Promise((resolve) => target.end(resolve));
+  }
+
+  currentSupervisorLogPath(date = this.clock()): string {
+    return dailyLogPath(this.paths.supervisorLogPath, date);
+  }
+
+  currentWorkerStderrPath(date = this.clock()): string {
+    return dailyLogPath(this.paths.workerStderrPath, date);
   }
 
   recordCrash(context: WorkerCrashContext): WorkerCrashRecord | undefined {
     try {
+      const exitedAt = new Date(context.exitedAt);
+      const crashDate = Number.isNaN(exitedAt.getTime()) ? this.clock() : exitedAt;
       const record: WorkerCrashRecord = {
         version: 1,
         ...context,
@@ -114,8 +130,8 @@ export class SupervisorDiagnostics {
         nodeVersion: process.versions.node,
         executablePath: process.execPath,
         cwd: process.cwd(),
-        supervisorLogPath: this.paths.supervisorLogPath,
-        workerStderrPath: this.paths.workerStderrPath,
+        supervisorLogPath: this.currentSupervisorLogPath(crashDate),
+        workerStderrPath: this.workerStderrStream?.filePath ?? this.currentWorkerStderrPath(crashDate),
         crashReportDirectory: this.paths.crashReportDirectory,
         diagnosticReports: findDiagnosticReports(
           this.paths.crashReportDirectory,

package/src/supervisor.ts

@@ -70,18 +70,24 @@ async function startChild(): Promise<void> {
         AGENT_BOT_SUPERVISED: "1",
         AGENT_BOT_RESTART_REASON: restartReason,
       }, restartNotificationTargets),
-      stdio: ["ignore", "ignore", workerStderr],
+      stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
     });
-  } finally {
-    diagnostics.closeWorkerStderr(workerStderr);
+    if (workerStderr === "ignore") {
+      child.stderr?.resume();
+    } else {
+      child.stderr?.pipe(workerStderr);
+    }
+  } catch (error) {
+    void diagnostics.closeWorkerStderr(workerStderr);
+    throw error;
   }
   const workerPid = child.pid;
   writeSupervisorLog("started", {
     pid: child.pid,
     restartReason,
     restartNotificationTargets,
-    workerStderrPath: diagnostics.paths.workerStderrPath,
+    workerStderrPath: diagnostics.currentWorkerStderrPath(),
     crashReportDirectory: diagnostics.paths.crashReportDirectory,
   });
 

package/src/utils/executeShellCommand.ts

@@ -11,10 +11,16 @@ export interface ShellCommandResult {
   outputTruncated: boolean;
 }
 
+export type ShellCommandOutputSnapshot = Pick<
+  ShellCommandResult,
+  "stdout" | "stderr" | "outputTruncated"
+>;
+
 export interface ShellCommandOptions {
   timeoutMs?: number;
   maxOutputBytes?: number;
   platform?: NodeJS.Platform;
+  onOutput?: (snapshot: ShellCommandOutputSnapshot) => void;
 }
 
 export function executeShellCommand(
@@ -40,8 +46,16 @@ export function executeShellCommand(
       child.kill();
     }, timeoutMs);
 
-    child.stdout.on("data", (chunk: Buffer) => output.append("stdout", chunk));
-    child.stderr.on("data", (chunk: Buffer) => output.append("stderr", chunk));
+    const appendOutput = (stream: "stdout" | "stderr", chunk: Buffer): void => {
+      output.append(stream, chunk);
+      try {
+        options.onOutput?.(output.result());
+      } catch {
+        // Output presentation must never interrupt the child process.
+      }
+    };
+    child.stdout.on("data", (chunk: Buffer) => appendOutput("stdout", chunk));
+    child.stderr.on("data", (chunk: Buffer) => appendOutput("stderr", chunk));
     child.once("error", (error) => {
       clearTimeout(timeout);
       reject(error);
@@ -68,30 +82,104 @@ function prepareShellCommand(command: string, platform: NodeJS.Platform): { comm
 }
 
 class BoundedOutput {
-  private readonly stdout: Buffer[] = [];
-  private readonly stderr: Buffer[] = [];
-  private retainedBytes = 0;
+  private retained: OutputChunk[] = [];
+  private readonly seenBytes = { stdout: 0, stderr: 0 };
+  private readonly headBytes: number;
+  private readonly tailBytes: number;
   private truncated = false;
 
-  constructor(private readonly maxBytes: number) {}
+  constructor(maxBytes: number) {
+    const normalizedMaxBytes = Math.max(1, Math.floor(maxBytes));
+    this.headBytes = Math.ceil(normalizedMaxBytes / 3);
+    this.tailBytes = normalizedMaxBytes - this.headBytes;
+  }
 
   append(stream: "stdout" | "stderr", chunk: Buffer): void {
-    const remaining = Math.max(0, this.maxBytes - this.retainedBytes);
-    if (remaining === 0) {
+    if (chunk.length === 0) return;
+    this.seenBytes[stream] += chunk.length;
+
+    if (!this.truncated) {
+      const next = [...this.retained, { stream, data: chunk }];
+      if (outputChunksLength(next) <= this.headBytes + this.tailBytes) {
+        this.retained = next;
+        return;
+      }
       this.truncated = true;
+      this.retained = [
+        ...takeOutputChunkHead(next, this.headBytes),
+        ...takeOutputChunkTail(next, this.tailBytes),
+      ];
       return;
     }
-    const retained = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
-    this[stream].push(retained);
-    this.retainedBytes += retained.length;
-    if (retained.length < chunk.length) this.truncated = true;
+
+    const head = takeOutputChunkHead(this.retained, this.headBytes);
+    const previousTail = takeOutputChunkTail(this.retained, this.tailBytes);
+    const tail = takeOutputChunkTail([...previousTail, { stream, data: chunk }], this.tailBytes);
+    this.retained = [...head, ...tail];
   }
 
-  result(): Pick<ShellCommandResult, "stdout" | "stderr" | "outputTruncated"> {
+  result(): ShellCommandOutputSnapshot {
     return {
-      stdout: Buffer.concat(this.stdout).toString("utf8"),
-      stderr: Buffer.concat(this.stderr).toString("utf8"),
+      stdout: this.streamResult("stdout"),
+      stderr: this.streamResult("stderr"),
       outputTruncated: this.truncated,
     };
   }
+
+  private streamResult(stream: "stdout" | "stderr"): string {
+    if (!this.truncated) {
+      return Buffer.concat(
+        this.retained.filter((chunk) => chunk.stream === stream).map((chunk) => chunk.data),
+      ).toString("utf8");
+    }
+    const head = takeOutputChunkHead(this.retained, this.headBytes)
+      .filter((chunk) => chunk.stream === stream);
+    const tail = takeOutputChunkTail(this.retained, this.tailBytes)
+      .filter((chunk) => chunk.stream === stream);
+
+    const retainedBytes = outputChunksLength([...head, ...tail]);
+    const marker = this.seenBytes[stream] > retainedBytes
+      ? Buffer.from("\n... output truncated ...\n", "utf8")
+      : Buffer.alloc(0);
+    return Buffer.concat([
+      ...head.map((chunk) => chunk.data),
+      marker,
+      ...tail.map((chunk) => chunk.data),
+    ]).toString("utf8");
+  }
+}
+
+interface OutputChunk {
+  stream: "stdout" | "stderr";
+  data: Buffer;
+}
+
+function outputChunksLength(chunks: OutputChunk[]): number {
+  return chunks.reduce((total, chunk) => total + chunk.data.length, 0);
+}
+
+function takeOutputChunkHead(chunks: OutputChunk[], maxBytes: number): OutputChunk[] {
+  const retained: OutputChunk[] = [];
+  let remaining = maxBytes;
+  for (const chunk of chunks) {
+    if (remaining <= 0) break;
+    const data = chunk.data.length <= remaining ? chunk.data : chunk.data.subarray(0, remaining);
+    retained.push({ stream: chunk.stream, data });
+    remaining -= data.length;
+  }
+  return retained;
+}
+
+function takeOutputChunkTail(chunks: OutputChunk[], maxBytes: number): OutputChunk[] {
+  const retained: OutputChunk[] = [];
+  let remaining = maxBytes;
+  for (let index = chunks.length - 1; index >= 0 && remaining > 0; index -= 1) {
+    const chunk = chunks[index]!;
+    const data = chunk.data.length <= remaining
+      ? chunk.data
+      : chunk.data.subarray(chunk.data.length - remaining);
+    retained.unshift({ stream: chunk.stream, data });
+    remaining -= data.length;
+  }
+  return retained;
 }