@saadnvd1/agent-os 0.3.502 → 0.3.505

package/components/SessionLogs/ProjectLogsSection.tsx

@@ -0,0 +1,140 @@
+"use client";
+
+import { useState } from "react";
+import { ScrollText } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import {
+  useProjectLogsQuery,
+  useSetLogFolder,
+  type LogHeader,
+} from "@/data/session-logs";
+import { LogDocument } from "./LogDocument";
+
+const day = (h: LogHeader) => (h.mergedAt ?? h.createdAt).slice(0, 10);
+
+function LogRow({ log, onOpen }: { log: LogHeader; onOpen: () => void }) {
+  return (
+    <li>
+      <button
+        type="button"
+        onClick={onOpen}
+        className="hover:bg-accent/50 flex min-h-11 w-full items-center gap-3 px-3 py-2 text-left transition-colors"
+      >
+        <span className="min-w-0 flex-1">
+          <span className="block truncate text-sm font-medium">{log.name}</span>
+          <span className="text-muted-foreground block truncate text-xs">
+            {day(log)}
+            {log.prNumber ? ` · #${log.prNumber}` : ""}
+            {` · $${log.costUsd.toFixed(2)}`}
+          </span>
+        </span>
+        <ScrollText className="text-muted-foreground h-4 w-4 shrink-0" />
+      </button>
+    </li>
+  );
+}
+
+// A project's logs of merged tasks, newest first, and the folder their
+// files go to (the default is outside every repository).
+export function ProjectLogsSection({
+  projectId,
+  open,
+}: {
+  projectId: string;
+  open: boolean;
+}) {
+  const { data, isPending, isError, error } = useProjectLogsQuery(
+    projectId,
+    open
+  );
+  const save = useSetLogFolder(projectId);
+  const [draft, setDraft] = useState<string | null>(null);
+  const [viewing, setViewing] = useState<LogHeader | null>(null);
+  const folder = draft ?? data?.folder ?? "";
+
+  return (
+    <div className="space-y-2">
+      <h3 className="text-sm font-medium">Session logs</h3>
+      <p className="text-muted-foreground text-xs">
+        When a task merges, AgentOS writes a log of it from what it already
+        recorded. No model is involved.
+      </p>
+      <div className="space-y-1.5">
+        <label htmlFor={`log-folder-${projectId}`} className="text-sm">
+          Session log folder
+        </label>
+        <div className="flex gap-2">
+          <Input
+            id={`log-folder-${projectId}`}
+            value={folder}
+            onChange={(e) => setDraft(e.target.value)}
+            placeholder={data ? `${data.defaultFolder}/…` : "~/path/to/logs"}
+            className="h-11 flex-1 md:h-9"
+            onKeyDown={(e) => {
+              if (e.key !== "Enter") return;
+              // Not the project form's submit.
+              e.preventDefault();
+              if (draft !== null)
+                save.mutate(draft, { onSuccess: () => setDraft(null) });
+            }}
+          />
+          <Button
+            type="button"
+            variant="outline"
+            className="h-11 md:h-9"
+            disabled={save.isPending || draft === null}
+            onClick={() =>
+              save.mutate(draft ?? "", { onSuccess: () => setDraft(null) })
+            }
+          >
+            Save
+          </Button>
+        </div>
+        {save.isError && (
+          <p className="text-destructive text-sm">{save.error.message}</p>
+        )}
+        <p className="text-muted-foreground text-xs">
+          An absolute or ~ path, never inside the project&apos;s repository.
+          Empty uses the default.
+        </p>
+      </div>
+      {isPending && (
+        <div className="bg-muted/40 h-16 animate-pulse rounded-lg" />
+      )}
+      {isError && <p className="text-destructive text-sm">{error.message}</p>}
+      {data &&
+        (data.logs.length ? (
+          <ul className="bg-muted/40 divide-border max-h-64 divide-y overflow-y-auto rounded-lg">
+            {data.logs.map((l) => (
+              <LogRow key={l.id} log={l} onOpen={() => setViewing(l)} />
+            ))}
+          </ul>
+        ) : (
+          <p className="text-muted-foreground text-sm">
+            No merged tasks logged yet.
+          </p>
+        ))}
+      <Dialog open={!!viewing} onOpenChange={(o) => !o && setViewing(null)}>
+        <DialogContent className="max-h-[90vh] max-w-3xl overflow-hidden [&>*]:min-w-0">
+          <DialogHeader>
+            <DialogTitle className="truncate">
+              {viewing?.name ?? "Log"}
+            </DialogTitle>
+            <DialogDescription>Session log</DialogDescription>
+          </DialogHeader>
+          <div className="h-[70vh]">
+            {viewing && <LogDocument sessionId={viewing.id} />}
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}

package/components/views/types.ts

@@ -1,3 +1,4 @@
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { SessionNeed } from "@/lib/sidebar/shelves";
 import type { Session } from "@/lib/db";
 import type { ProjectWithDevServers } from "@/lib/projects";
@@ -15,6 +16,7 @@ export interface SessionStatus {
   unread?: boolean;
   // A chat summarising its context; status stays "running".
   compacting?: { since: number; before?: number };
+  prStage?: PrStage;
   claudeSessionId?: string | null;
   // From a program's OSC 7501 report: untrusted, rendered as plain text.
   detail?: string | null;

package/contexts/PaneContext.tsx

@@ -26,7 +26,7 @@ import {
 } from "@/lib/panes";
 import { useViewport } from "@/hooks/useViewport";
 
-export type ViewMode = "terminal" | "files" | "git" | "workers";
+export type ViewMode = "terminal" | "files" | "git" | "workers" | "log";
 
 export interface PaneViewState {
   viewMode: ViewMode;

package/data/session-logs/index.ts

@@ -0,0 +1,73 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { LogHeader } from "@/lib/session-logs/store";
+
+export type { LogHeader };
+
+export const sessionLogKeys = {
+  all: ["session-logs"] as const,
+  task: (id: string) => [...sessionLogKeys.all, "task", id] as const,
+  project: (id: string) => [...sessionLogKeys.all, "project", id] as const,
+};
+
+export interface TaskLog {
+  header: LogHeader;
+  markdown: string;
+}
+
+export interface ProjectLogs {
+  folder: string | null;
+  defaultFolder: string;
+  logs: LogHeader[];
+}
+
+// null: this task has no log (it didn't merge, or it predates logs).
+export function useTaskLogQuery(sessionId: string | undefined, enabled = true) {
+  return useQuery({
+    queryKey: sessionLogKeys.task(sessionId ?? ""),
+    queryFn: async (): Promise<TaskLog | null> => {
+      const res = await fetch(
+        `/api/session-logs/${encodeURIComponent(sessionId!)}`
+      );
+      if (res.status === 404) return null;
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Request failed");
+      return data;
+    },
+    enabled: enabled && !!sessionId,
+    // A written log doesn't change; a task that just merged may not have
+    // one for a moment.
+    staleTime: (query) => (query.state.data ? Infinity : 10_000),
+  });
+}
+
+async function projectLogs(res: Response): Promise<ProjectLogs> {
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export function useProjectLogsQuery(projectId: string, enabled = true) {
+  return useQuery({
+    queryKey: sessionLogKeys.project(projectId),
+    queryFn: async () =>
+      projectLogs(await fetch(`/api/projects/${projectId}/session-logs`)),
+    enabled,
+    staleTime: 30_000,
+  });
+}
+
+export function useSetLogFolder(projectId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (folder: string) =>
+      projectLogs(
+        await fetch(`/api/projects/${projectId}/session-logs`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ folder }),
+        })
+      ),
+    onSuccess: (data) =>
+      queryClient.setQueryData(sessionLogKeys.project(projectId), data),
+  });
+}

package/lib/db/migrations.ts

@@ -1593,6 +1593,30 @@ const migrations: Migration[] = [
       })();
     },
   },
+  {
+    id: 69,
+    name: "session_logs",
+    up: (db) => {
+      // One log per merged task, written by AgentOS from data it already
+      // holds (lib/session-logs). Never deleted: the database is the record,
+      // the markdown file on disk is a copy.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS session_logs (
+          session_id TEXT PRIMARY KEY,
+          project_id TEXT,
+          workspace_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          markdown TEXT NOT NULL,
+          data TEXT NOT NULL,
+          file_path TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_logs_project
+          ON session_logs(project_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_session_logs_workspace
+          ON session_logs(workspace_id, created_at);
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/done/index.ts

@@ -25,6 +25,7 @@ import { sessionMergePolicy } from "../tasks/finish";
 import { releasePorts } from "../ports";
 import { dropSessionDatabase } from "../project-config/database";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
+import { captureMergedTask } from "../session-logs";
 
 export interface DoneOptions {
   // Who asked: the orchestrator's gate failures count toward Saad, as its
@@ -102,6 +103,7 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
       : `UPDATE sessions SET task_status = 'done' WHERE id = ?`
   ).run(s.id);
   syncTaskCardInBackground(s, status, pr);
+  if (status === "merged") void captureMergedTask(s.id, { head: pr?.head });
 }
 
 export async function doneSession(

package/lib/orchestrator/armed.ts

@@ -12,6 +12,7 @@
  * database, so it survives a restart.
  */
 
+import { notifyStatusChanged } from "../status/hub";
 import { db, type Session } from "../db";
 import type { TaskPR } from "../tasks/state";
 import { latestApproval } from "./ask-approvals";
@@ -37,6 +38,7 @@ export function setArmed(sessionId: string, armed: boolean): void {
        merge_armed_seen = NULL WHERE id = ?`
   ).run(sessionId);
   looked.delete(sessionId);
+  notifyStatusChanged();
 }
 
 // The workspace a task's PR merges through when armed: its project's, with

package/lib/orchestrator/brief.ts

@@ -95,6 +95,7 @@ Reading:
 - \`${TOOL_NAMES.sessions}\`: every session in the workspace with its project, view, status, what it's doing, task/PR/CI state and stack position. After them, external sessions: tmux sessions AgentOS didn't start (dispatch, a person's own terminal), on this machine or another, working in one of the workspace's repositories or a worktree of it, each with its branch's open PR. They're read-only: \`read\` works on them; \`send\`, \`stop\` and \`done\` don't. Gate their PRs with \`review\` and \`sign_off\` by number.
 - \`${TOOL_NAMES.read}\` (session, lines?): the end of a session's terminal or chat, or an external session's screen.
 - \`${TOOL_NAMES.cards}\` (board?): the cards on the workspace's LumifyHub boards.
+- \`${TOOL_NAMES.logs}\` (project?, task?, n?): the logs AgentOS wrote when tasks merged. Without task, the latest headers; with it, that task's whole log (brief, plan, timeline, usage, outcome). Check it before repeating work or re-planning a job a merged task already did.
 - \`${TOOL_NAMES.stack_status}\` (id): one stack's items, PRs and progress.
 - \`${TOOL_NAMES.orchestrators}\`: every workspace, and whether it has an orchestrator.
 

package/lib/orchestrator/checks.ts

@@ -5,6 +5,7 @@
  */
 
 import { db } from "../db";
+import { notifyStatusChanged } from "../status/hub";
 
 // ci: when the check count on a commit last changed, for settling.
 export type CheckKind = "review" | "scope" | "ci";
@@ -57,6 +58,7 @@ export function putCheck(row: {
     row.status,
     row.detail ?? null
   );
+  notifyStatusChanged();
   return getCheck(row.sessionId, row.sha, row.kind)!;
 }
 

package/lib/orchestrator/facts.ts

@@ -200,6 +200,7 @@ export async function statusOf(s: Session): Promise<{
 
 // A commit's time never changes: read once per sha.
 const committed = new Map<string, number>();
+export const knownCommitTime = (sha: string) => committed.get(sha) ?? 0;
 
 export async function settleIn(
   workspaceId: string,

package/lib/orchestrator/logs.ts

@@ -0,0 +1,81 @@
+/**
+ * The orchestrator's `logs` tool: session logs read from the database as
+ * they were written. Reading only; nothing here asks a model to summarise.
+ */
+
+import { formatDuration } from "../session-logs/build";
+import { getLog, listLogs, type LogHeader } from "../session-logs";
+import { db } from "../db";
+import { workspaceProject } from "./targets";
+import { untrusted } from "./untrusted";
+
+// About 8k tokens: what one full log may return.
+export const LOG_CHAR_CAP = 30000;
+
+const headerLine = (h: LogHeader) =>
+  [
+    (h.mergedAt ?? h.createdAt).slice(0, 10),
+    `${h.name} [${h.id.slice(0, 8)}]`,
+    h.project ?? "no project",
+    h.prNumber ? `#${h.prNumber}` : "no PR",
+    h.durationMs !== null ? formatDuration(h.durationMs) : "?",
+    `$${h.costUsd.toFixed(2)}`,
+    h.hasPlan ? "plan" : h.planKept ? "no plan" : "plan not kept",
+  ].join(" · ");
+
+function findOne(
+  workspaceId: string,
+  projectId: string | null,
+  ref: string
+): string {
+  const r = ref.trim().toLowerCase();
+  const pr = /^#?(\d+)$/.exec(r);
+  const rows = db
+    .prepare(
+      `SELECT session_id AS id, json_extract(data, '$.name') AS name,
+         json_extract(data, '$.prNumber') AS pr
+       FROM session_logs WHERE workspace_id = ? AND (? IS NULL OR project_id = ?)
+       ORDER BY json_extract(data, '$.mergedAt') DESC`
+    )
+    .all(workspaceId, projectId, projectId) as {
+    id: string;
+    name: string;
+    pr: number | null;
+  }[];
+  const hit = rows.filter(
+    (x) =>
+      x.id === ref ||
+      x.id.startsWith(r) ||
+      x.name.toLowerCase() === r ||
+      (pr !== null && x.pr === Number(pr[1]))
+  );
+  if (hit.length === 1) return hit[0].id;
+  if (hit.length > 1)
+    throw new Error(
+      `"${ref}" matches ${hit.length} logs (${hit.map((x) => x.id.slice(0, 8)).join(", ")}); use an id`
+    );
+  throw new Error(`No log for "${ref}" in this workspace.`);
+}
+
+export function readLogs(
+  workspaceId: string,
+  a: { project?: string; task?: string; n?: number }
+): string {
+  const projectId = a.project
+    ? workspaceProject(workspaceId, a.project).id
+    : null;
+  if (a.task) {
+    const row = getLog(findOne(workspaceId, projectId, a.task))!;
+    const md =
+      row.markdown.length > LOG_CHAR_CAP
+        ? `${row.markdown.slice(0, LOG_CHAR_CAP)}\n… (trimmed; ${row.markdown.length} characters in all)`
+        : row.markdown;
+    return untrusted("session log", md);
+  }
+  const logs = listLogs(
+    { workspaceId, ...(projectId ? { projectId } : {}) },
+    a.n ?? 10
+  );
+  if (!logs.length) return "No session logs yet.";
+  return untrusted("session logs", logs.map(headerLine).join("\n"));
+}

package/lib/orchestrator/serve.ts

@@ -12,6 +12,7 @@ import {
   stop,
 } from "./act";
 import { readCards } from "./cards";
+import { readLogs } from "./logs";
 import { describeSessions } from "./describe";
 import { sessionFacts } from "./facts";
 import { describeExternal, externalSessions } from "./external-sessions";
@@ -85,6 +86,10 @@ export async function runTool(
     }
     case "cards":
       return readCards(w, p(tool, raw).board);
+    case "logs": {
+      const a = p(tool, raw);
+      return readLogs(w, a);
+    }
     case "send": {
       const a = p(tool, raw);
       return send(w, a.session, a.message, {

package/lib/orchestrator/task-state.ts

@@ -114,6 +114,20 @@ async function peerChatWaiting(
 // check has registered on it for 2 minutes. Seconds still to wait.
 export const SETTLE_S = 120;
 
+// When the check count last changed, as ciSettleIn stored it.
+const lastSeen = (detail: string | null | undefined) =>
+  detail ? (JSON.parse(detail) as { count: number; at: number }) : null;
+
+const settleLeft = (
+  last: { count: number; at: number } | null,
+  checkCount: number,
+  committedAt: number,
+  now: number
+) => {
+  const changedAt = last && last.count === checkCount ? last.at : now;
+  return Math.max(0, Math.max(committedAt, changedAt) + SETTLE_S - now);
+};
+
 export function ciSettleIn(input: {
   workspaceId: string;
   taskId: string;
@@ -123,11 +137,7 @@ export function ciSettleIn(input: {
   now?: number;
 }): number {
   const now = Math.floor((input.now ?? Date.now()) / 1000);
-  const seen = getCheck(input.taskId, input.sha, "ci");
-  const last = seen?.detail
-    ? (JSON.parse(seen.detail) as { count: number; at: number })
-    : null;
-  const changedAt = last && last.count === input.checkCount ? last.at : now;
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
   if (!last || last.count !== input.checkCount)
     putCheck({
       workspaceId: input.workspaceId,
@@ -137,8 +147,21 @@ export function ciSettleIn(input: {
       status: "pass",
       detail: JSON.stringify({ count: input.checkCount, at: now }),
     });
-  const settledAt = Math.max(input.committedAt, changedAt) + SETTLE_S;
-  return Math.max(0, settledAt - now);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
+}
+
+// The same answer from what ciSettleIn stored, writing nothing: for a
+// status that only looks.
+export function ciSettleLeft(input: {
+  taskId: string;
+  sha: string;
+  checkCount: number;
+  committedAt: number;
+  now?: number;
+}): number {
+  const now = Math.floor((input.now ?? Date.now()) / 1000);
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
 }
 
 // A head with no checks for this long after its PR became mergeable, in a

package/lib/orchestrator/tool-names.ts

@@ -10,6 +10,7 @@ export const TOOL_NAMES = {
   sessions: name("sessions"),
   read: name("read"),
   cards: name("cards"),
+  logs: name("logs"),
   send: name("send"),
   orchestrators: name("orchestrators"),
   message_orchestrator: name("message_orchestrator"),

package/lib/orchestrator/tool-schemas.ts

@@ -57,6 +57,19 @@ export const TOOL_SHAPES = {
   cards: {
     board: ref("One board, by board or project name").optional(),
   },
+  logs: {
+    project: project.optional(),
+    task: ref(
+      "One merged task's log, by task name, id (or its first characters) or PR (#12); without it, the latest headers"
+    ).optional(),
+    n: z
+      .number()
+      .int()
+      .min(1)
+      .max(50)
+      .optional()
+      .describe("How many headers, newest first (default 10)"),
+  },
   send: {
     session,
     message: z.string().trim().min(1).max(8000),

package/lib/orchestrator/tools.ts

@@ -55,6 +55,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "Every session in this workspace: project, view, status, what it's doing, task/PR/CI state and stack position; then external sessions (tmux sessions AgentOS didn't start, here or on other machines, working in a workspace repository), read-only, with their branch's PR.",
   read: "The end of one session's terminal or chat, or an external session's screen, as plain text (capped at about 4k tokens).",
   cards: "Cards on this workspace's linked LumifyHub boards, by list.",
+  logs: "Session logs AgentOS wrote when tasks merged: the last N headers (task, PR, cost, duration) of the workspace or one project, or one log in full (brief, plan, timeline, usage, outcome). Read straight from the database; nothing is summarised.",
   send: "Message a session in this workspace over the bus. It arrives as its next prompt. When Saad changes a running task's scope, tell it with scope_change set, so its review judges the PR against the brief as amended.",
   orchestrators:
     "Every workspace, and whether it has an orchestrator you can message.",