@saadnvd1/agent-os 0.3.503 → 0.3.506

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/Workspaces/HqFolderForm.tsx

@@ -0,0 +1,71 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useSetWorkspaceHq, useWorkspaceHqQuery } from "@/data/session-logs";
+
+// The git repo this workspace's session logs are written into and
+// committed to. Blank keeps them in AgentOS's own folder.
+export function HqFolderForm({ workspaceId }: { workspaceId: string }) {
+  const { data, isPending, isError, error } = useWorkspaceHqQuery(workspaceId);
+  const save = useSetWorkspaceHq(workspaceId);
+  const [draft, setDraft] = useState<string | null>(null);
+  const saved = data?.hq?.folder ?? "";
+  const folder = draft ?? saved;
+  const id = `hq-folder-${workspaceId}`;
+
+  if (isPending)
+    return <div className="bg-muted/60 h-11 animate-pulse rounded-md" />;
+  if (isError)
+    return <p className="text-destructive text-xs">{error.message}</p>;
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        save.mutate(folder, {
+          onSuccess: () => {
+            setDraft(null);
+            toast.success(
+              folder.trim() ? "HQ folder saved" : "HQ folder cleared"
+            );
+          },
+          onError: (err) => toast.error(err.message),
+        });
+      }}
+      className="space-y-1.5"
+    >
+      <label htmlFor={id} className="text-sm">
+        HQ folder
+      </label>
+      <div className="flex gap-2">
+        <Input
+          id={id}
+          value={folder}
+          onChange={(e) => setDraft(e.target.value)}
+          placeholder="~/path/to/a/private/git/repo"
+          className="h-11 flex-1 text-base md:h-9 md:text-sm"
+        />
+        <Button
+          type="submit"
+          size="sm"
+          className="h-11 sm:h-9"
+          disabled={folder === saved || save.isPending}
+        >
+          Save
+        </Button>
+      </div>
+      <p className="text-muted-foreground text-xs">
+        Session logs go to docs/sessions/&lt;project&gt;/ in this repo and are
+        committed there, one file per commit.{" "}
+        {data.hq?.visibility === "private"
+          ? "The repo is private, so each commit is pushed."
+          : data.hq
+            ? "Commits stay local: the repo isn't a private GitHub repository."
+            : "It must be a private git repo outside the workspace's projects."}
+      </p>
+    </form>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -6,6 +6,7 @@ import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
 import { McpServersForm } from "./McpServersForm";
+import { HqFolderForm } from "./HqFolderForm";
 import { StallForm } from "./StallForm";
 import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
 import { AwayWindowForm } from "@/components/Away/AwayWindowForm";
@@ -47,6 +48,7 @@ export function WorkspaceSettings() {
           <RulesForm workspaceId={w.id} />
           <WorkspaceModelsForm workspaceId={w.id} />
           <McpServersForm workspace={w} />
+          <HqFolderForm workspaceId={w.id} />
           <SettingToggle
             title="Wake tasks on CI failures and reviews"
             detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."

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,110 @@
+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),
+  });
+}
+
+export interface WorkspaceHq {
+  hq: { folder: string; visibility: "private" | "internal" | "none" } | null;
+}
+
+const hqKey = (workspaceId: string) =>
+  [...sessionLogKeys.all, "hq", workspaceId] as const;
+
+async function hqState(res: Response): Promise<WorkspaceHq> {
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export function useWorkspaceHqQuery(workspaceId: string) {
+  return useQuery({
+    queryKey: hqKey(workspaceId),
+    queryFn: async () =>
+      hqState(await fetch(`/api/workspaces/${workspaceId}/session-logs`)),
+    staleTime: 30_000,
+  });
+}
+
+export function useSetWorkspaceHq(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (folder: string) =>
+      hqState(
+        await fetch(`/api/workspaces/${workspaceId}/session-logs`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ folder }),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(hqKey(workspaceId), 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/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/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/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.",