AGENT-EYE

eye board API

JSON over HTTP on 127.0.0.1:<port> (default 7420, [board] port in config). The board shows sessions of every enabled agent (Claude Code by default; see agents.md). The web board is optional and off by default: eye board on turns it on ([board] enabled = true in config; the daemon then serves it), eye board off turns it off, and eye serve runs it once in the foreground. The face in face/ uses only these routes; a different front end can do the same.

Access#

  • The token is in $EYE_HOME/board.token (default ~/.agent-eye) (created once, mode 0600). eye board (when the board is on) prints http://127.0.0.1:<port>/?t=<token>.
  • GET /?t=<token> sets the cookie eye_token (HttpOnly, SameSite=Strict, Path=/) and redirects to /, keeping any other query parameters (/?t=<token>&look=ink → /?look=ink).
  • EYE_FACE_DIR=<dir> makes the server read the face from that folder on every request (for development: npm run watch in face/). If it has no index.html, / serves a plain page saying the board was not built in.
  • Every other request needs that cookie or the header X-Eye-Token: <token>; otherwise 401.
  • Host must be 127.0.0.1:<port>, localhost:<port> or [::1]:<port> (any case); otherwise 403, whatever the token says. This stops a web page on another name that was pointed at 127.0.0.1 (DNS rebinding).
  • A non-GET request must carry an Origin header that is same-origin (http://127.0.0.1:<port>, http://localhost:<port> or http://[::1]:<port>); otherwise 403.
  • Errors are {"error": "<message>"} with a 4xx/5xx status. Times are Unix milliseconds.

Routes#

Route Does
GET / the board (the TypeScript face built from face/, embedded in the binary). Without an embedded face it serves a plain page saying the board was not built into this binary (run npm run build in face/ and rebuild).
GET /assets/* and other face files the face's built files. Hashed names under /assets/ are immutable; the HTML is no-cache. Responses carry a CSP: 'self' only, plus data: images and fonts and inline styles. Unknown paths are 404.
GET /api/board[?all=1] {columns:[{id,title,cards:[Card]}], archive_count, generated_at}. Columns, in order: ideas, running, needs_you, waiting, paused, done. Archive is not included. Cards are newest activity first. A done session idle for more than [board] done_days (default 7, 0 = no limit) leaves the board and is counted in archive_count.
GET /api/prefs, POST /api/prefs Board settings shared by every browser and the installed app (eye.theme, eye.accent, eye.ink.layout, eye.ink.fold, eye.ink.panel: the folded panel sections kept open, comma-separated), kept in ~/.agent-eye/ui.json. POST merges {key: "value"}; other keys are refused. eye.accent is the ink look's signal colour, chosen from the button in the board's header: vermilion (the default), cobalt, teal, moss, amber, magenta, violet or graphite; a missing or unknown value is vermilion. Each preset has a light and a dark pair, set as data-accent on <html>. The terminal picker keeps your terminal's colours.
GET /api/archive?offset=0&limit=50[&all=1] {cards:[Card], total, offset}; archived and history-only sessions, plus done sessions that aged off the board ([board] done_days), newest first (limit 1..200)
GET /api/cards/:id Detail Card. :id is a session id, a unique prefix of 6+ chars, or idea:<n>. resume_mode (iterm, terminal or copy) and resume_terminal (the Linux terminal's name or null) say what Resume will do on this machine.
POST /api/cards/:id/column body {column}: a column id (running, needs_you, waiting, paused, done), archive (archives the session), or "auto" (clears the manual column and un-archives); ideas is a 400. Returns the Card. Moving a session to a column sets column_manual until the session has new activity. Idea cards accept only archive.
POST /api/cards/:id/hidden body {hidden: true|false}: same as eye hide / eye unhide (sets the manual override in session.hidden; see Hidden sessions). The session leaves /api/board on the next fetch (or comes back). Returns the Card. Idea cards are a 400.
POST /api/cards/:id/remind body {when, note?} or {clear: true}: set or remove a "check on this" reminder, same as eye remind. :id is a session id, a prefix, or idea:<n>. when is read by the engine in local time: tomorrow, mon..sun (the next such day), 30m, 4h, 3d, 1w, 2026-11-20, 2026-11-20 14:00 (a day alone is 9:00); a time that has passed or words it cannot read are a 400 that lists the forms. A new time replaces the old one (a snooze). 404: no such session or idea. Returns the Card. See Reminders below.
GET /api/remind/settings, POST /api/remind/settings Whether a due reminder shows a desktop notice ([remind] notify, off by default). GET returns {notify, available}; available is true when this machine has a program to show one (macOS: osascript; Linux: notify-send on the PATH). POST takes {notify: true|false} (a missing notify is a 400), writes the key into config.toml keeping its comments and other keys, and returns the same object. The daemon uses the new value on its next pass, without a restart.
GET /api/night The night shift: {enabled, window, parallel, isolation, quiet_minutes, in_window, planned, open:[Run], recent:[Run]}. open is planned and running runs, recent the last 20 that ended. The config file is read again, so a change made elsewhere shows at once. A Run is {id, kind: "idea"|"session", idea_id, session_id, agent, switch, folder, prompt, night, status, why, limit: {kind, value, text}|null, run_session_id, worktree, branch, base_ref, started_at, ended_at, duration_ms, report, diff_stat, created_at, isolation: "worktree"|"copy"}; status is planned, running, done, failed, stopped or skipped. report is untrusted output: show it as text.
POST /api/night/settings body {enabled?, window?, parallel?}: writes [night] in config.toml and answers with the state. window must be HH:MM-HH:MM with different ends, parallel 1 to 8; otherwise 400 and nothing changes.
POST /api/night/plan body {idea_id} or {session_id, prompt}, plus optional limit (30%, 2M, 500k, 90m, 2h), agent, switch (ideas only), isolation (worktree or copy; default [night] isolation). Returns the Run. 400 with the reason when an idea has no folder or no prompt, a session has no prompt, a plain folder is over 100 MB, or a limit cannot be checked (a weekly limit without plan data).
POST /api/night/:id/cancel Cancels a planned run (409 for any other status). Answers with the state.
POST /api/night/:id/limit body {limit} (empty removes it): changes the limit of a planned run, with the same checks as planning. Answers with the state.
POST /api/night/:id/discard body {confirm: true, lose_changes?}: removes the run's worktree and branch (or copy). 400 without confirm; 409 when the run is still going, the worktree has uncommitted changes and lose_changes is not true, or the folder is not inside eye's night folder. Never uses --force. Returns {ok, note}.
POST /api/night/:id/bring body {confirm: true}: for the copy of a git repo, fetches its night branch into the original repo (git fetch <copy> b:b). 400 without confirm; 409 when the run is not a repo copy, the copy is gone, or the original already has the branch. Returns {ok, note}.
POST /api/night/:id/open Opens the run's folder with the system's opener (open, xdg-open).
GET /api/night/session/:id The run that made a session ({run}, null for any other session), with tokens and uncommitted.
GET /api/loose[?session=<id>] What sessions left behind, as stored by the last scan (the daemon scans every 5 minutes and after a session stops; eye loose scans at once): {items:[LooseEnd], ignored, summary}. Ignored items are left out and counted in ignored; summary is the picker's line (Leftovers: 2 servers (ports 4321, 4350), 3 commits not pushed) or null. A LooseEnd is {key, session_id, kind, line, detail, what, since_ms, action, confirm, command}: kind is process, container, worktree, unpushed or uncommitted; action is stop, remove, push or commit; confirm is the question to ask before a stop or remove (Stop node (pid 38090, port 4321)?), null for the others; command is the git command to copy for push and commit, which eye never runs. See Loose ends below.
POST /api/loose/stop, POST /api/loose/remove body {key, confirm: true} (without confirm: true the answer is 400 and nothing is looked at, as for night discard): stop a process or container (SIGTERM, or docker stop), or remove a worktree (git worktree remove, never --force). Only a key a scan stored is accepted (404 otherwise). Stop re-reads the process and acts only when its pid and start time still match the key and it is yours; remove acts only when git still lists the worktree. A refusal, git's own words included, is a 409 {error, code: "not_done"} and nothing was done. Returns {ok, note, session_id}.
POST /api/loose/ignore body {key}: stop listing an item (it stays ignored across scans). 404 for a key no scan stored.
POST /api/loose/send body {session, dry_run} (dry_run defaults to true): the same as Resume, with a first message that lists what the session left behind. Returns the plan like /resume; 400 when nothing is left.
POST /api/cards/:id/resume body {dry_run, fork} (dry_run defaults to true, fork to false). Returns {dry_run, mode, terminal, command, applescript}. With fork:true the command resumes the session as a new one that branches from it (for Claude Code cd '<cwd>' && claude --resume <id> --fork-session), the original stays untouched (a live session can be forked). An agent that cannot fork gives a 400. The command is built by the session's own agent; a session of an agent that is switched off gives a 400. With dry_run:false it also puts the transcript back from eye's archive when the agent has deleted it, then runs the plan: opens an iTerm2 tab (mode: iterm, macOS only), opens a new terminal window (terminal) or copies the command (copy), and adds note. mode is what [board] resume comes to on this machine, worked out once per request (auto is never returned): the same answer as resume_mode in the card detail. terminal is the name of the Linux terminal program that opens the window (xdg-terminal-exec, a name like gnome-terminal, $TERMINAL), or null. When no clipboard tool took the command, note says so and holds the command (the background process may have no display). applescript is set in iterm mode only. A failure, a terminal that does not open included, is a 400 with the reason.
GET /api/cards/:id/conversation?limit=10&before=<i> The conversation of a session, read from its transcript by its agent (or eye's archive copy when the transcript is gone): {messages:[{role,text,ts,tools,truncated}], more, next_before}. Messages are numbered 0..N-1, oldest first. The response holds the limit messages just before index before (default N, so the newest), still oldest first; limit defaults to 10, max 50. more says older messages exist; next_before is the before to ask for next (null when more is false). role is user (a real prompt: paste tags removed, slash commands, tool results and injected lines left out) or assistant (the text blocks of the agent's replies between two prompts, joined with a blank line; text can be empty when the turn was only tool calls); tools = tool calls the agent made in that turn (0 for user messages); ts = Unix ms or null. text is cut at 4000 characters (truncated:true) and secrets are masked. Sub-agent lines are left out. 404: unknown id, or no transcript and no archive copy; 400: an idea.
POST /api/sessions/:id/forget body {confirm: true, transcript?: bool}: same as eye forget <id> --yes [--transcript]. Takes a manual snapshot of the database, then removes the session from eye (its row, search text, other rows and archive copy) and, with transcript, the agent's own copy. 400 without confirm: true (nothing is touched) and for an idea; 409 open_now when the session is open in its agent, and 409 not_done when the agent's copy could not be removed (the session is then still in eye). Answers {ok, id, agent_copy: kept|removed|unsupported|failed, detail:[…]}. Cannot be undone.
GET /api/sessions/:id/export?format=html One session as a download: text/html (default) or, with format=md, text/markdown, sent as an attachment (eye-<id>-<title>.html). A self-contained page with no network use: title, folder, dates, state, the conversation (tool calls folded to one line per turn) and outputs, secrets masked. Read from the archive copy when the agent deleted the transcript; a session with neither gets a page that says so. 404: unknown id; 400: an idea or another format; the same token as the rest of /api.
GET /api/search?q=words&limit=30[&all=1] {results:[{card, snippet, score, relevance}]}; searches everything, archive included. Ordered like the picker (see terminal.md) by relevance, higher is better; archived sessions come last. score is the same number negated, so lower is better, as in 0.2. A session whose id starts with the query (4+ hex digits) comes first, with the top result's relevance + 1 (1.0 when nothing else matched), so both are always finite numbers. At most the first 20 words (units) of the query are used.
GET /api/agents {agents: [{id, name, short, default}]}: the enabled agents in config order, e.g. {id:"claude", name:"Claude Code", short:"Claude", default:true}. The first one is the default. Empty when none is enabled.
GET /api/usage?days=7&by=project What the sessions used over the last days local days (default 7, 1..366), with an API-equivalent cost estimate, not a bill (see usage.md). by is project (default), folder, agent, model or session and picks rows. project rows are named like the board's project bar (the last segment of the repository or folder, home for the home folder); temp and scratch folders (when [exclude] temp = false lets them in), sessions with no folder and projects under 1% of the cost (or under $0.10) are folded into one last row, other (N); folder keeps one row per folder; a bad days or by is a 400. Returns {estimate, days, from, to, by, rows, totals, by_project, by_agent, by_model, top_sessions, weeks, limits, backfill_left}. A row is {name, input, output, cache_write, cache_read, total, cost_usd, unpriced_tokens} (session rows add id and agent). cost_usd is null when no token of the row has a known price; unpriced_tokens are counted in the tokens but not in the cost. top_sessions is the ten with the highest cost. weeks is the last four 7-day periods ending today, oldest first, each with from, to and the same fields. limits is [{agent, name, seen_at, plan, windows:[{label, used_percent, window_minutes, resets_at, reset}], lines}], the newest limits each agent reported (Unix ms; reset is true when the window has reset since); an agent that reported none is left out. backfill_left is the number of older sessions not counted yet.
GET /api/ideas {ideas:[Idea]} (not archived, and not started, or started but its session never showed up)
POST /api/ideas body {title, notes?, prompt?, folder?, agent?} (a leading ~ is expanded). notes are never sent to the agent; prompt is the first message when the idea starts; agent is the id of an enabled agent (empty or left out: the default agent; an agent that is not enabled is a 400). Returns the idea Card.
POST /api/ideas/:id Edit: body with any of {title, notes, prompt, folder, agent}; a field left out stays, an empty string clears notes, prompt, folder or agent (an empty title is a 400). Returns the idea Card. 404: no such idea.
GET /api/folder?path=<p> What a typed folder is, for the idea form: {state, creatable, note}. state is ok (a folder is there), missing, not_a_folder (a file is in the way) or unusable (empty, not an absolute path, a control character, not readable); creatable is true only for a missing folder that eye may make; note is one plain line, null when state is ok. A leading ~ is the home folder. Read-only: nothing is created.
POST /api/ideas/:id/start body {background, dry_run, create_folder} (dry_run defaults to true; create_folder to false). Returns {dry_run, mode, terminal, command, applescript, session_id, job, note, creates_folder} (mode and terminal as for resume; a background start reports copy). The command is the idea's agent's (the default agent when none is set) and sends the idea's prompt as the first message; without one, foreground opens the agent with nothing sent and background is a 400. session_id is null when the agent does not let eye choose it. With dry_run:false: foreground stores session_id on the idea and opens iTerm2 or a terminal window (or copies, and note says which); until that session shows up the idea stays in Ideas and a new start reuses the same id; background runs the agent's background command (claude --bg) and returns its job short id (session_id is null until the daemon links the job; the idea leaves the Ideas column then). The agent's own message (e.g. Claude Code's "Workspace not trusted. Run claude in once...") comes back as a 400 error. A folder that does not exist is never started in: without create_folder the answer is 409 {error, code: "folder_missing"}; with it the start makes the folder (and the folders above it) first and creates_folder is true (a dry run only says so and creates nothing). Eye makes folders only inside the account's home folder, never through a .. or a link that leaves it; any other missing folder, a file in the way or an unusable name is a 400 whose error says why, even with create_folder.
GET /api/events Server-sent events. Event board-changed when the database changed (checked every 2 s via PRAGMA data_version). Reload /api/board on it.

Config#

docs/config.md lists every key. The ones that change what the API returns:

[board]
enabled = false
port = 7420
resume = "auto"    # or "iterm", "terminal", "copy"
done_days = 7      # Done sessions older than this leave the board for the archive view; 0 = keep them

[agents]
enabled = ["claude"]   # the agents eye follows; the first is the default

[user]
name = ""              # a stored next line "<name>: ..." is served as "You: ..."

done_days only affects /api/board and /api/archive; the picker, eye ls and the column rules are unchanged. Sessions and ideas of an agent that is not in [agents] enabled are left out of every list (they stay in the database and come back when the agent is enabled again).

Jira keys in outputs get a url of https://<site>/browse/<KEY>. The site is the one that project's keys were seen linked on in your transcripts (...atlassian.net/browse/KEY-1); [outputs] jira_url covers projects never seen in a link.

Hidden sessions#

Throw-away sessions ("/clear", "exit", "cd ..") are left out of /api/board (and its archive_count), /api/archive, /api/search, eye find and eye ls. Add ?all=1 (CLI: --all) to include them. GET /api/cards/:id still returns a hidden session. Summaries skip hidden sessions; the archive copy of the transcript still happens.

A session is trivial when all of these hold: prompt_count <= max_prompts, no outputs and no sub-agents, the last reply is at most max_reply_chars, it is not busy, and the first prompt starts with /, starts with a word from commands (case-insensitive), or is a single word of at most 10 characters. Config, on by default, in config.toml:

[hide]
trivial = true
max_prompts = 1
max_reply_chars = 200
commands = ["exit", "quit", "resume", "usage", "clear", "cd", "help"]

eye hide <id> and eye unhide <id> set a manual override stored in session.hidden (1 hidden, 0 shown, NULL the rule decides). An unhide beats the rule; a hide beats a session that looks real. eye doctor prints how many sessions are hidden.

Card#

{id, agent, agent_name, title, folder, repo, branch, column, auto_column, manual, last_activity_at, started_at,
 state, state_source, next, ai_status, recap, live_status, kind, streams, outputs, output_counts,
 topics, topics_more, resume_cmd, resumable, parent_id, child_count, child_done, prompt_count, tokens,
 remind_at, remind_note, remind_due, activity, background, loops, remote_url, loose, night, origin, origin_raw}
  • agent: the id of the agent that ran the session (claude); agent_name: its short name for sentences (Claude; the id when the agent is switched off). Ideas carry the agent they start in, or null for the default agent.
  • column: where it is shown. auto_column: where the rules would put it. manual: a hand-placed column is in effect.
  • next: who acts next and what, <owner>: <action>, e.g. You: review the PR. The owner is You for the user, the agent's short name for the agent (Claude: fix the failing test) or another person's name. Lines stored with the user's configured name ([user] name) are served as You:. While a session is open, not working and waiting on you (a PermissionRequest, a permission Notification, or a reply ending in a question; the "waiting for your input" notification that follows every finished reply does not count), it is what the agent's hook says is asked instead: You: answer: <question>, You: allow Bash: <command> (secrets masked, at most 240 characters), You: approve or change the plan. Otherwise it is the written summary's next step, or null.
  • activity: one line of what an open session does on its own, or null: background: npm run dev · 4 min (+2 more when there are several tasks), else ↻ every 10 min · next 14:20, ↻ next 14:20 or ↻ goal: <objective>. The board shows it on cards in Running.
  • background: the open session's background tasks, {id, kind, label, started_at, line} with kind shell, agent or monitor. A shell's label is the Bash call's own description when it has one, else its command from the program on (set-up such as VAR=value, cd ... && and exec left out, long paths cut to their last part). loops: its loops, {kind, schedule, next_at, prompt, line} with kind interval, self_paced or goal. Both are empty for a session that is not open, and leave out tasks older than 12 hours (a notice that never came) and loops that ended.
  • remote_url: the web link of the session while its remote control is on (an https:// URL), else null. The board shows a Remote Control box on the card's top edge and a link in the panel.
  • When the live status says the session waits on a prompt (permission prompt, input needed, ...), the card is in Needs you and next says You: Permission prompt. A dialog open the user started is not an ask.
  • blocked: true while a prompt in the open session (a permission, a question dialog, a plan to approve) stops the agent mid-task until you answer it; the board pulses the card's border and makes the panel's YOU chip blink. A finished reply that ends in a question waits on you but is not blocked.
  • state_source: summary (the written summary, whichever agent wrote it), recap (the agent's own recap, first 220 chars, used until a summary exists), idea (notes) or none.
  • origin is where the session was started: terminal, headless (claude -p, codex exec), app (an app that drives the agent through its SDK, such as T3 Code or Conductor), desktop, ide, web (a remote or web session), night (one of eye's own night runs) or null when unknown. origin_raw is what the agent wrote (sdk-ts, codex-tui/vscode). eye ls --json has both fields too, and eye ls --origin <word> filters by them.
  • folder, repo have ~ for the home directory. branch is null for detached HEAD.
  • kind: interactive, bg, history_only, or idea. resumable is false for history-only sessions and ideas.
  • child_count, child_done: sub-agents and background children. Board cards do not list them.
  • topics: [{key,title,status,next}], at most 5 on board cards, topics_more = how many were cut. Status is done|active|paused|waiting_on_others|needs_you.
  • Board cards: streams holds topics only, and outputs is the card face selection, ordered PR, artifact, Jira (at most 3; keys that also appear in the title, branch or a PR first), one folder. output_counts gives the true totals per kind.
  • Detail card (GET /api/cards/:id): all streams ({kind,title,key,status,detail,link}), all outputs ({kind,value,url,title}; title is set for artifacts when one is known, else null), all topics, plus prompts (up to the last 10 readable ones, oldest first, from the search index; <pasted_content> tags are removed, paste-only prompts read "[pasted] …", slash commands are skipped), first_prompt (the first readable prompt), last_assistant_text, resume_mode, and idea ({id, title, notes, prompt} of the idea the session was started from, or null). Idea detail adds notes and prompt.
  • worked (detail card only): the days the session was worked on, or null while they are not counted yet (a session read before eye kept them is counted in the background by the daemon, a few sessions per tick, newest first; eye scan counts all of them). {first_day, last_day, days, days_count, span_days, active_ms, last_at, more_days}: days lists the days with work inside the strip, [{day: "2026-11-10", prompts, active_ms}], oldest first; the strip runs from first_day to last_day (local calendar days, at most the last 60); days_count is the days with work over the whole session, span_days the calendar days from its first to its last, more_days the calendar days before the strip, active_ms the active time over the whole session and last_at the time of its last message (Unix ms). Active time is the sum of the gaps between messages (a prompt, a reply, a tool result) of at most 15 minutes; a longer gap is time away. The hours are stored in UTC and the days are worked out in the time zone of the machine eye runs on.
  • usage (detail card only): {input, output, cache_write, cache_read, total, cost_usd, unpriced_tokens, estimate} over the whole life of the session, sub-agents included, or null while it is not counted yet (see usage.md). cost_usd is an API-equivalent estimate, null when the model has no price.
  • resume_cmd: the command that resumes the session, built by its agent, e.g. cd '<cwd>' && claude --resume <id>. Null when the folder is unknown, the id is not one eye will put in a command, or the agent is switched off.
  • tokens: {input, output, cache_write, cache_read, total, subagents_total} or null (ideas, and sessions whose transcript was not read yet). Counted from the usage of the assistant messages in the transcript, each message once (Claude Code writes one line per content block with the same usage; another agent's adapter counts its own way). subagents_total is the sum of the four counts over the session's sub-agent transcripts; total = input + output + cache_write + cache_read of the main transcript + subagents_total. A full rescan (eye scan --full) recomputes it.

Night shift#

A card made by a night run has night: {id, status} (a crescent mark on the card's top edge); the detail card also has night_run, the full Run with tokens (input, output, cache writes and sub-agents) and uncommitted (whether its worktree has changes no commit holds). Both are absent or null for any other session. The reports and diff stats are text from an agent: the face renders them as text.

Leftovers#

A scan finds, for sessions active in the last [loose] days: processes of your user that listen on a TCP port or run from inside the session's folder or scratchpad (never the agent CLIs, eye, shells, editors, browsers); running containers whose compose folder or bind mount is in a session's folder; worktrees in a scratchpad or whose folder is gone; commits on no remote (only in repos that have a remote); modified tracked files. A process is the session's by the session id in its working folder, else by the session whose folder holds it and that worked in the hour the process started. Git leftovers belong to the most recently active session of the repo, and only while it is not open. The card carries loose (the count, ignored items left out) and the detail card also loose_ends and loose_summary (what is left, by kind, in one line: 2 servers (ports 4321, 4350), 3 commits not pushed; null when nothing is). The board calls them leftovers; the API keeps the loose names. The keys are proc:<pid>:<start>, box:<id>:<created>, worktree:<path>, unpushed:<repo>:<newest commit>, uncommitted:<folder>. Nothing here pushes, commits or force-removes, and stop never sends SIGKILL.

Reminders#

A reminder is a date on a session or an idea that brings it back. remind_at is its time (Unix ms) and remind_note the words you gave, both null when none is set; remind_due is true when the time has come. A session's reminder is answered, and the fields go back to null, once the session has activity after the time (you went back to it); putting the session in a column by hand answers a due one, and Done or Archive end any. A card that is due is in needs_you (column), first in the lane and above a hand-placed column, but never above the archive; auto_column says the same. The board shows the reason on its → YOU line: check on this: <note>, or you asked to check on this <when> without a note. An idea whose reminder is due is in the needs_you column of /api/board and is still an idea Card (kind: "idea", id: "idea:<n>", Start and edit work). On the board a card with a reminder, due or not, carries a clock mark on its top edge whose tooltip says when. With [remind] notify switched on (it is off by default; /api/remind/settings) the daemon shows one desktop notice when a reminder falls due (see config.md). GET /api/ideas and eye ls --json carry the same fields.

Idea#

{id, agent, title, notes, prompt, folder, created_at, from_session_id, session_id, sort, archived, remind_at, remind_note, remind_notified_at}; the idea Card has id: "idea:<id>", idea_id, state = notes, has_prompt, and, when the idea has a folder, folder_state (ok, missing, not_a_folder or unusable, as in /api/folder), folder_creatable and folder_note.

Edit this page on GitHub