framework

property agentId

agentId: string;

• Which run this is (#738): a project can have several in flight, one per worktree.

property cwd

cwd: string;

• The agent's own checkout, so its git/file status is read from the worktree it edits (#738).

property intent

intent?: string;

• What the user asked to build (the agent's scope event).

property projectId

projectId: string;

property projectName

projectName: string;

property readyForMerge

readyForMerge?: boolean;

• Whether the agent signalled setReadyForMerge() (#326): drives the building/ready dot.

property scope

scope?: string;

property sessionName

sessionName?: string;

• The session name the agent chose (#326), when it set one.

property status

status: AgentStatus;

property updatedAt

updatedAt?: string;

• ISO timestamp of the agent's last event.

property agentId

agentId: string;

• The agent this is about.

property kind

kind: 'started' | 'finished';

• started = the agent entered running; finished = it reached a terminal status.

property projectId

projectId: string;

property projectName

projectName: string;

property status

status?: AgentStatus;

• The finished agent's terminal status (finished only), so a stop reads differently from a done.

property title

title?: string;

• What the agent is building (its intent), for the notification body; may be absent.

property updatedAt

updatedAt?: string;

• When the agent last changed, ISO, for ordering and the baseline diff.

property detail

detail?: string;

• What it ran and what that said, when the agent wrote any.

property headline

headline: string;

• What is wrong, in one line.

property base

base?: string;

• What the branch is measured against (the repo's default branch), when one was found.

property branch

branch: string;

• The branch the work is on.

property commits

commits: HandoffCommit[];

property deletions

deletions: number;

property empty

empty: boolean;

• The session produced nothing to hand off: the branch exists but carries no commit the base does not already have — or nothing beyond the framework's own bookkeeping (#1291), which is committed for provenance, never as publishable work. Said out loud, rather than shown as an empty branch.

property exists

exists: boolean;

• The branch still exists in the repo (a deleted or never-created one does not).

property files

files: HandoffFile[];

property hasRemote

hasRemote: boolean;

• The repo has a remote to push to at all.

property insertions

insertions: number;

property merged

merged: boolean;

• The branch is already merged into the base.

property pendingFiles

pendingFiles?: string[];

• The files the session changed and never committed, read from its own checkout (#1173).

  The agent is instructed to commit what it *found*, never what it *wrote*, so a settled session can hold its whole output in an uncommitted tree. That work is not on the branch yet, so it is not in commits and it does not make empty false. Paths rather than a count, because a no-diff branch must *name* what is waiting instead of offering an Open PR that GitHub can only refuse. Absent when the caller did not say which checkout the session worked in — "nobody asked" and "asked, tree clean" are different answers.

property pr

pr?: LinkedPr;

• The PR opened for this branch, when there is one.

property prPending

prPending?: boolean;

• The PR is not known yet, rather than absent (#1028): the lookup is still running.

property pushed

pushed: boolean;

• The branch is on the remote and the remote is at the same commit.

property branch

branch?: string;

• The branch the agent's work is on: folded from branch events as the agent observes it (#1277), and corrected at teardown while the worktree still exists (#799).

  Not reliably derivable instead of recorded: a clean agent loses its checkout, and the #326 prompt lets the agent create its own branch, so neither tf-<sessionName> nor the run-id branch is guaranteed to be the one holding the commits.

property browserStreamPort

browserStreamPort?: number;

• The loopback port the agent's browser preview is listening on (#813), or absent when the agent has no browser. What lets the daemon proxy the pane: the port is allocated per agent and the dashboard is a different process, so meta is the only place it can learn it.

property cloudAnchor

cloudAnchor?: string;

• The hand-off anchor a cloud run pushed for its session to clone at (#1601): an empty commit unique to this run, folded from the cloud-anchor event. The session works on a claude/* branch of the cloud's own naming, and this is the ancestor by which the daemon's adoption pass recognizes which of origin's claude/* heads is this run's. Absent on non-web runs and on web runs whose pre-hand-off push failed.

property driver

driver?: string;

• The wrapped agent (from the session event).

property handoff

handoff?: {
    push: boolean;
    pr: boolean;
    merge?: boolean;
};

• What this session's end-of-session handoff is armed to do (#1102): push its branch, and open a draft PR for it. Both start on.

  On the meta because the checkboxes that show it live in a different process from the agent that obeys it, and a tab opened after the agent started has no event history to fold — the same reason browserStreamPort is here. Absent means an older agent, which the reader treats as armed, matching what that agent will actually do.

  merge mirrors the auto-merge arming (#1216, #1382) — display-only, like the rest of this field: the agent merges off its own config, never off the meta. Absent on records from before #1382, which the reader treats as off.

property handoffReport

handoffReport?: 'done' | 'skipped' | 'failed';

• How the end-of-session handoff reported back (#1455), folded from the handoff event.

  What lets a list surface — which reads meta, not the event log — tell "ended, still publishing" from "ended, published": between a clean end and this field, an armed agent's epilogue is still pushing / opening the PR, exactly the window the session pill calls "publishing…" (#1431). Absent until the event lands, which is what a list reads as "still going".

property handoffSkip

handoffSkip?: AutoHandoffSkip;

• Why a skipped handoff skipped (#1583), folded from the same handoff event as handoffReport. What lets the daemon tell "published elsewhere" from "ended with nothing to hand off": a drain that settles with no-commits will never run the PR that lifts its ticket lock, so the sweep releases the claim it minted. On the meta because the sweep reads metas, not event logs. Absent on non-skipped handoffs and on older records.

property host

host?: string;

• The host the owning pid lives on, so a pid probe only trusts a match (#716).

property id

id: string;

• Stable, path-safe id for this agent (derived from startedAt).

property intent

intent?: string;

• What this session was asked for (from the intent event).

property kind

kind?: 'build' | 'prompt';

• The flow this agent started under (#1467): build for the scope→build orchestration, prompt for the direct-prompt path (research and transparent runs record prompt too). Persisted so a continuation (#762) can re-enter the flow its first leg ran — the composer's Resume always arrives as a prompt start, and without this record a resumed build agent ended as a bare prompt session (no synthesize framing, no backlog offer). Absent on records from before this field, which a reader treats as unknown (the continuation then keeps the prompt path).

property mergeOutcome

mergeOutcome?: 'auto-armed' | 'merged' | 'watched' | 'withheld' | 'failed';

• How the handoff's merge half went (#1418), folded from the handoff event's merge field.

  What the daemon's CI watch scans for: watched is a PR waiting for green that *this* side must merge (the repo could not arm GitHub auto-merge), auto-armed one GitHub will land by itself but whose checks going red is still ours to notice. On the meta because the watch reads metas, not event logs, and must survive both the agent's process and the daemon's. Absent on runs from before this field, and on every agent whose handoff had no merge to report.

property model

model?: string;

• The model id the current leg's agent was started with (#1438), folded from each leg's session event — a continuation (#762) may run a different model than the first leg, so the latest leg wins rather than the first pinning it. Absent when the leg left the agent on its own default (and on records from before this field).

property pendingChoice

pendingChoice?: {
    id: string;
    title: string;
};

• The choice gate the agent is currently parked on (#636): set when a choice event fires and cleared when its choice-resolved (or the agent's end) arrives. Present means the agent is paused waiting for the user's answer — the second "needs you" source after open PRs (#624).

property pid

pid?: number;

• The OS pid of the process that owns this agent (the one tailing control.jsonl), on host. Persisted so a reader can tell a live agent from one whose process died without writing end (#716): a running meta whose owning pid is gone is stale and gets flipped to stopped.

property pr

pr?: {
    number: number;
    url: string;
};

• The pull request this session's work is on (E6), recorded when one is opened rather than re-derived from branch names and timestamps by every surface that wants it.

property readyForMerge

readyForMerge?: boolean;

• Whether the agent signalled setReadyForMerge() (#326): building (false/absent) vs ready (true).

property remoteLabel

remoteLabel?: string;

• The connected device a remote agent (#1067) executes on, for the session list + notice after a reload.

property sessionId

sessionId?: string;

• The wrapped agent's real session id, once it reports one.

property sessionLink

sessionLink?: string;

• The link shown to jump into the live agent session.

property sessionName

sessionName?: string;

• The session name the agent chose (#326), also its tf-<name> branch.

property settledAt

settledAt?: string;

• When the agent settled and parked on the user (#785), or absent while the agent is working.

  Deliberately not a AgentStatus value: the agent IS still live while it waits (its process is alive, it still takes messages, it still holds the project), and a dozen readers key "live" off status === 'running'. This is the orthogonal fact — working, or waiting on you — which status cannot carry because it only changes when the agent ends.

property startedAt

startedAt: string;

• ISO timestamp the store was opened (run start).

property status

status: AgentStatus;

property target

target?: 'local' | 'actions' | 'remote' | 'web';

• Where this run executes (#1050/#1053/#610): actions for a GitHub Actions run, web for a Claude Code cloud session, remote when relayed to a connected device (#1067), absent for a local run. Persisted so the agent view can tell a burst-mode Actions run from a stalled live feed, show a cloud agent's session link after a reload, and gate the browser pane off (#1053).

property ticket

ticket?: string;

• The ticket this agent is implementing (#1117), repo-relative (tickets/<file>.md).

  Set only when the framework picked the ticket itself, so the Overview can show a ticket that is being coded right now as implementing instead of inferring it from the plan/spike it left behind. Absent on every agent nobody linked to a ticket.

property updatedAt

updatedAt: string;

• ISO timestamp of the last event written.

property workspace

workspace?: string;

• The workspace the agent builds in (from the session event).

property branch

branch?: string;

• The branch it is on, absent when the path is not a git repo.

property dirty

dirty: boolean;

• Uncommitted changes present in that checkout.

property own

own: boolean;

• True when it is the agent's own worktree; false when it fell back to the project's checkout.

property path

path: string;

• Absolute path of the checkout this agent works in.

property pr

pr?: LinkedPr;

• The PR opened for this checkout's branch (#809), when there is one.

property prPending

prPending?: boolean;

• The PR is not known yet, rather than absent (#1028): the lookup is still running.

property sizeBytes

sizeBytes?: number;

• Size on disk, bytes. Only read once nothing is writing to it, and best-effort even then.

property autoMerge

autoMerge?: boolean;

• Merge this job's PR once its agent opens it (#1216). Set on the drain job: what it implements has already been triaged as consensual, quick-win work a human could have vetoed on the queue, so its PR is the one kind whose review happened before the agent. Declared as data on the job for the same no-name-matching reason as AutoPmJob.drains.

property claim

claim?: PlanAssignment;

• The .lock.md claim the sweep minted for this start (#1420/#1583), on both pinned variants. What lets the sweep free the claim itself when the agent settles with nothing to hand off: the agent's PR is what normally deletes the lock, and an agent that never made a commit is never opening one.

property describe

describe?: string;

• A line saying what the job does, wherever its label does not already: under the label in the routines list, and as the log line's wording. Only the maintenance sweep carries one -- "Maintenance" names its preset rather than the work -- while the other routines' labels read as what they do, so their rows stay one line and their log lines say the label itself rather than the same thing twice. Data on the job rather than a name matched in the dashboard, so a rename cannot quietly move the line around.

property drains

drains?: boolean;

• This job works an entry already on the queue, rather than putting entries on it (#1117).

  Only the draining job has a specific piece of work it is about to pick up, so only it can be told which ticket that is. Declared here rather than matched on AutoPmJob.name at the call site, so the job says what it does and a rename cannot quietly unhook it.

property entry

entry?: string;

• The one queue entry a AutoPmJob.drains job is pinned to (#1204). Set only on the per-start variants pinnedDrainJob builds: the catalog's own drain job carries none, since which entry is next is known only at the moment the sweep starts one.

property fansOut

fansOut?: boolean;

• This rotation job may fan out to several agents pinned one ticket each (#1327). Only [Plan tickets] declares it: unlike the other rotation jobs it writes per-ticket sibling files rather than rewriting the shared queue document, so concurrent copies do disjoint work and land disjoint edits — the exact property that already lets draining fan out. Declared as data on the job for the same no-name-matching reason as AutoPmJob.drains.

property label

label?: string;

• The user-facing name, for a surface that lists the routines (#1159). Read off the preset the job fires rather than written again here, so a relabelled preset relabels its routine.

property name

name: string;

• Stable id: the rotation and the opt-out list (#1209) key on it.

property pinnedBranch

pinnedBranch?: string;

• The branch this job's prompt pins via its constant session name, when it does (#1293). The triage prompts abort when the-framework/<SESSION_NAME> already exists, so a leftover branch whose PR was closed or merged jams the routine forever. Declared as data on the job, like AutoPmJob.drains, so the sweep can release the stale name before firing without matching on AutoPmJob.name at the call site.

property prompt

prompt: string;

• The prompt to run, verbatim.

property ticket

ticket?: string;

• The one ticket a fanned-out job is pinned to (#1327), as its filename inside tickets/. Set only on the per-start variants pinnedPlanJob builds, like AutoPmJob.entry is for drains: which tickets are open is known only at the moment the sweep locks them.

property tooltip

tooltip?: string | undefined;

• The preset's own one-line "what this does" (#1506), for a surface that has to say what a click is about to spend an agent on before it spends it. Read off the preset like AutoPmJob.label, so the sentence the launcher shows for a preset and the sentence the routines list shows for its routine are the same sentence. Absent for a preset without one.

property message

message: string;

• The sentence: what was started, or the reason for standing down.

property path

path: string;

• Its path, which is what the log line names and the panel shows.

property projectId

projectId: string;

• Registry id of the project considered.

property started

started: boolean;

• Whether an agent was started for it.

property enabled

enabled?: boolean;

• Whether the preference was on at the last sweep. undefined before the first one.

property nextSweepAt

nextSweepAt: number;

• When the next sweep is due, epoch ms.

property outcomes

outcomes: AutoPmOutcome[];

• One line per project the last sweep considered, in sweep order.

property sweptAt

sweptAt?: number;

• When the last sweep finished, epoch ms. undefined before the first one.

property id

id: string;

property label

label: string;

property note

note?: string;

property queuedAt

queuedAt: string;

property sessionId

sessionId: string;

property state

state: 'queued' | 'sent' | 'failed';

property receivedAt

receivedAt: string;

property role

role: 'agent' | 'user';

property seq

seq: number;

property sessionId

sessionId: string;

property text

text: string;

property options

options: {
    label: string;
    detail?: string;
}[];

property receivedAt

receivedAt: string;

• When the daemon accepted it. Set here, never by the caller.

property recommended

recommended?: string;

property sessionId

sessionId: string;

• The cloud session that asked, which joins back to an agent through AgentMeta.sessionId.

property title

title: string;

property autoAcceptMs

autoAcceptMs?: number;

• Auto-accept the recommended option after this many ms when autopilot is on. Default 10000.

property file

file?: string;

• The markdown file under approval (e.g. PLAN_<slug>.agent.md); the doc sidebar renders it.

property id

id: string;

• Unique id for this pending choice; the pick is posted back against it.

property multi

multi?: boolean;

• Render as a multi-select checklist (#332): each option is a checkbox pre-checked per its ChoiceOption.default, and the pick resolves to the selected *subset* of ids rather than one. Absent = the single-select gate (#304).

property options

options: readonly ChoiceOption[];

• The options to choose between (at least one).

property recommended

recommended?: string;

• The option id pre-selected as the default (autopilot auto-accepts it). Required for a single-select; omitted for a multi select, where each option's own ChoiceOption.default drives the pre-checked set instead.

property title

title: string;

• The question shown above the options (e.g. "Approve this plan?").

property id

id: string;

property label

label: string;

property prompt

prompt: string;

property active

active: ActiveAgent[];

• Agents going right now, most-recently-updated first (from buildOverview).

property projects

projects: ProjectStat[];

• Every registered project, most-recently-active first.

property queue

queue: ProjectQueue[];

• The per-project open TODO backlog (from collectQueue).

property totals

totals: {
    projects: number;
    openTodos: number;
};

property kind

kind: 'session' | 'week' | 'week-model' | 'unknown';

• Normalized window, so callers can gate without matching on prose. session is Claude's 5-hour window, week its all-models week, and week-model a single model's week (Opus/Sonnet get their own).

  Note there is deliberately no day: Claude measures a 5-hour session and a week, and nothing per day (#519 was specced against a daily limit that does not exist).

property label

label: string;

• The window's name exactly as the agent phrased it, e.g. "Current session".

property percentUsed

percentUsed: number;

• How much of the window is gone, 0-100.

property resetsAtText

resetsAtText?: string;

• When the window resets, as the agent worded it (`"Jul 18 at 7am (Asia/Jerusalem)"`). Prose, not a timestamp: the agent prints no year, so parsing it to an epoch would be guesswork. DriverRateLimit.resetsAt carries the exact epoch for the window it reports on.

property added

added: number;

property binary

binary: boolean;

• Line counts are unavailable (a binary file, or an untracked one too large to count).

property path

path: string;

property removed

removed: number;

property status

status: FileGitStatus;

property binary

binary: boolean;

• Not UTF-8 text, so there is nothing to render.

property path

path: string;

• The repo-relative path asked for.

property text

text: string;

• The file's text, cut at MAX_PREVIEW_LINES. Empty when binary.

property truncated

truncated: boolean;

• The file was longer than the cap and was cut.

property added

added: number;

property binary

binary: boolean;

• Nothing textual to show (git reports a binary change, or the file is not UTF-8 text).

property patch

patch: string;

• Unified diff body, hunks only (git's diff --git / index preamble is dropped).

property path

path: string;

• The repo-relative path asked for.

property removed

removed: number;

property status

status: FileGitStatus;

property truncated

truncated: boolean;

• The patch hit the preview cap and was cut.

property handoff

handoff?: HandoffLevel;

• How far a finished session publishes itself (#1102/#1173/#1216/B5): local, push, pr or merge. Default pr. Whether a session publishes itself is a fact about the repo, so it belongs in the file that travels with it.

  merge has to be asked for out loud: publishing a branch is reversible, landing it on the default branch is not. Meant for work whose review already happened before the session — the quick-win and consensual routines merge what a plan the human could veto already settled.

property transparent

transparent?: boolean;

• Transparent mode (#625): make every agent in this project a raw claude -p — no framework system prompt, no emit protocols, no consumption guard, no dashboard, no TODO loop. The coarse "only-pick-what-you-need" master off-switch, at the per-project tier. Default false.

property vanilla

vanilla?: boolean;

• Remove the built-in #326 system prompt, keeping the session controls. Default false.

  One name for one concept (C3). This key used to be antiLazyPill — the historical name of the prompt's ancestor (#301) — spelled the other way round from the vanilla it mapped to everywhere else, so the file, the preference and the agent option each said the same thing in a different direction and three comments apologised for it.

property branch

branch: string;

property dirty

dirty: boolean;

• Uncommitted changes present.

property pr

pr?: LinkedPr;

property prPending

prPending?: boolean;

• The PR is not known yet, rather than absent (#1028): the lookup is still running.

property merge

merge: boolean;

• Merge the PR once opened (#1216) — armed at launch, no checkbox, never changes mid-run. Unlike the pair above this defaults to off: merging is opt-in, so a stream from before the event carried it (#1382) must not read as an agent that will land on main by itself.

property pr

pr: boolean;

• Open a draft PR on finish. Implies push.

property push

push: boolean;

• Push the branch to origin on finish.

property result

result?:
    | {
          outcome: 'skipped';
          reason: AutoHandoffSkip;
      }
    | {
          outcome: 'done';
          url?: string;
      }
    | {
          outcome: 'failed';
          error: string;
      };

• How the handoff ended, once it has run. Absent while the session is still going.

property agentId

agentId?: string;

• An agent is implementing this ticket right now (#1117): its id, for the card to link into.

  The difference between "someone planned this at some point" and "this is being coded as you look at it", which the plan/spike proxy could not tell apart. Only set for a ticket a live agent actually recorded (AgentMeta.ticket), so absent still means the lane was inferred.

property bucket

bucket: HotBucket;

property projectId

projectId: string;

property projectName

projectName: string;

property ticket

ticket: WorkspaceTicket;

property agentId

agentId?: string;

• Which run this is about (awaiting #738 / unpushed): a project has several agents.

property awaitId

awaitId?: string;

• The parked gate's id (awaiting only) — its stable identity, so it notifies exactly once.

property branch

branch?: string;

• The branch the work is sitting on (unpushed only).

property commits

commits?: number;

• How many commits are waiting (unpushed only).

property createdAt

createdAt?: string;

• When the PR was opened (pr) or the agent last updated (the other two), ISO, for ordering.

property kind

kind: 'pr' | 'awaiting' | 'unpushed';

• pr = an open PR to review/merge or close; awaiting = an agent paused on a choice gate (#636); unpushed = a finished agent whose branch has commits that were never pushed (#860).

property number

number?: number;

• The PR number (pr only).

property projectId

projectId: string;

property projectName

projectName: string;

property title

title: string;

property url

url: string;

• Where to act: the PR on GitHub (pr), or the dashboard (the other two, when the URL is known).

property cwd

cwd: string | null;

• The server's working directory, or null when it cannot be offered.

property cwdProjectId

cwdProjectId: string | null;

• The project id for cwd when it is already registered, else null.

property agentId

agentId: string;

property choice

choice: ChoiceRequest;

property intent

intent?: string;

• What the agent was asked to do, for a card whose session never named itself.

property projectId

projectId: string;

property projectName

projectName: string;

property sessionName

sessionName?: string;

• The session's name (#326) when it chose one — the card's label; else fall back to intent.

property updatedAt

updatedAt?: string;

• When the agent last spoke, ISO: what the longest-waiting-first order sorts on.

property active

active: ActiveAgent[];

• Projects with a running agent, most-recently-updated first.

property queueOpen

queueOpen: number;

• Total open TODO items across every project.

property recent

recent: RecentProject[];

• The most recently active projects (capped).

property autoPm

autoPm?: boolean;

• Auto PM (#685): let the daemon start a PM agent by itself when the agent queue has run dry and there is plenty of budget left, so leftover subscription quota goes on the roadmap instead of expiring. **Absent = off**: it spends the user's allowance without being asked, so it is opt-in like notifyDiscord rather than a baseline.

property autoPmConcurrency

autoPmConcurrency?: number;

• How many agents the routine may keep going at once on one project (#1204). Absent defaults to DEFAULT_AUTO_PM_CONCURRENCY, and the value is clamped to MAX_AUTO_PM_CONCURRENCY.

  Only the draining routine fans out: it takes work *off* the queue, one pinned entry per agent, so several at once do disjoint work. The rotation invents work and each of its jobs rewrites the queue file, so it stays one agent per tick whatever this says.

property autoPmOptOut

autoPmOptOut?: string[];

• The routines autoPm must not fire, by AutoPmJob.name (#1209). Absent or empty = every routine runs, which is what the sweep did before this existed.

  Opted *out* rather than opted in, so the list only ever names exceptions: a routine added in a later version is on for everyone, instead of silently never running for whoever saved the setting before it shipped. It names routines rather than indexing them for the same reason AutoPmJob.drains is a flag — a reorder must not move which one is switched off.

property autoSpendOffset

autoSpendOffset?: number;

• How far the automatic-consumption limit sits from the quota boundary, in percentage points (#960). Absent defaults to DEFAULT_SPEND_OFFSET — a half-day cushion ahead of the boundary — rather than sitting exactly on it (#960 Edit).

  Negative holds unattended work back further; positive lets it borrow into the days still to come. It is an *offset* rather than an absolute percentage so the limit travels with the boundary as the week goes on, instead of being overtaken by it on day two.

property bridge

bridge?: boolean;

• The browser bridge (#1237): let an extension running in the user's own Claude session report the question a Claude web agent is parked on, so it shows in the dashboard rather than only on claude.ai. **Absent = off.** It opens the daemon's one route reachable from another origin, so it is opt-in rather than a baseline, and turning it on is what mints the bridge token.

property browser

browser?: boolean;

• Give the agent a real browser via chrome-devtools-mcp during the agent (#452); maps to --browser.

property customPresets

customPresets?: CustomPreset[];

• User-defined presets (#626): the user's own saved prompts, shown beside the built-in presets.

property driver

driver?: string;

• Which coding agent drives the agent (#650): claude or codex; maps to --agent. Absent = the default (claude).

property editor

editor?: string;

• Preferred editor for "Open in editor" (#727): an editor CLI (e.g. code, cursor, zed). Absent falls back to $FRAMEWORK_EDITOR, then code.

property handoff

handoff?: HandoffLevel;

• How far a finished session publishes itself (#1102/#1216/B5): keep it local, push the branch, open a draft PR, or merge that PR. Absent = DEFAULT_HANDOFF (pr).

  Default-on, unlike most of this file, because it is what makes the handoff zero-config: the old behaviour was a button nobody was obliged to press, and work that stayed on a local branch nobody was told about (#860). A session can still opt out from its action bar.

property model

model?: string;

• The model to run on (#628), e.g. opus / sonnet; maps to an agent's --model. Absent = the driver's default.

property notifyBrowser

notifyBrowser?: boolean;

• Fire a browser notification when a new item lands on the "needs you" queue (#627). Absent = on.

property notifyDiscord

notifyDiscord?: boolean;

• Post a Discord message when a new item lands on the "needs you" queue (#627). Absent = off: unlike the in-browser toggle, Discord reaches you when no dashboard is open, so it is opt-in. Gates the daemon watcher *on top of* a DISCORD_WEBHOOK being set (the webhook is where to post; this is whether to).

property notifyHumanIntervention

notifyHumanIntervention?: boolean;

• The "needs you" category (#627): notify when an agent is awaiting your answer or a PR is ready to review. A *category* toggle, like notifyNewActivity, composing with the method toggles (notifyBrowser / notifyDiscord). **Absent = on**: unlike the other flat opt-in booleans, human-intervention pings are the baseline The Framework leans on, so an unset preference keeps them firing; a user turns them off explicitly.

property notifyNewActivity

notifyNewActivity?: boolean;

• Also notify on plain agent activity — an agent started, an agent finished (#627). The default-off counterpart to the always-on "needs you" notifications: it keeps you loosely informed of the pipeline moving even when nothing needs you. A *category* toggle: it composes with the method toggles (notifyBrowser / notifyDiscord), so activity reaches whichever are on.

property onBeforeMergeableQuality

onBeforeMergeableQuality?: boolean;

• On-before-mergeable prompt (#326): on setReadyForMerge(), queue the quality follow-ups as TODO entries.

property onboardingDismissed

onboardingDismissed?: boolean;

• Whether the Overview's Onboarding checklist has been dismissed (#958). Absent = show it, so a fresh install is walked through setup; dismissing only hides it on the Overview, and the same checklist stays available on the settings page.

property target

target?: AgentLocation;

• Where a run executes (#1050/#610): local (this device, the default), actions (a fresh GitHub Actions runner) or web (a Claude Code cloud session); maps to --run-on. Absent = local.

property theme

theme?: 'system' | 'light' | 'dark';

• Dashboard color theme (#725): system (follow the OS, the default), light, or dark. Absent = system.

property transparent

transparent?: boolean;

• Transparent mode (#625): run the wrapped agent raw — no framework system prompt, emit protocols, consumption guard, dashboard, or TODO loop, so an agent is identical to claude -p. The coarse master off-switch ("only pick what you need"); maps to --transparent. Absent = off.

property vanilla

vanilla?: boolean;

property code

code: ProjectErrorCode;

property message

message: string;

• The detail — what the failing command said, in the words the user would see running it by hand.

property since

since: string;

• ISO timestamp of when the error was first recorded; a re-report of the same code keeps it.

property items

items: T[];

• What was found. Possibly only part of it, when some project could not be read.

property whole

whole: string[];

• The ids of the projects every source answered for, so their share of items is all of it.

property items

items: QueueItem[];

property open

open: number;

• Count of unchecked items (what is still queued).

property projectId

projectId: string;

property projectName

projectName: string;

property total

total: number;

• Count of all parsed items (open + done).

property activated

activated: boolean;

• True when the repo still has its .the-framework/ marker.

property errors

errors?: ProjectError[];

• What the daemon's background jobs currently find wrong with the project (#1500), oldest first — absent when nothing is. Not part of the summary itself: the dashboard's project list attaches it from the daemon's error state.

property fileConfig

fileConfig?: FrameworkFileConfig;

• The repo's committed run defaults from the-framework.yml (#842), so the launcher can show what an agent there will actually resolve to. Read fresh on every summarize, which is what keeps it current after an edit; absent when the repo sets nothing (or the file is malformed, which loadFrameworkConfig reports as empty rather than failing).

property id

id: string;

• Registry id (stable, URL-safe).

property lastActivityAt

lastActivityAt?: string;

• ISO timestamp of the project's newest activity: its most recent session.

property name

name: string;

• Display name (the path's basename).

property path

path: string;

• Absolute repo path.

property projectId

projectId: string;

property projectName

projectName: string;

property tickets

tickets: WorkspaceTicket[];

property boundary

boundary: QuotaBoundary;

property limit

limit: QuotaLimit;

• The line in force, which is the boundary unless the user moved it (#960).

property reached

reached: BoundaryWindow | null;

• The window that has reached the limit, or null while there is room.

property windows

windows: BoundaryWindow[];

• The windows in force: the account's week, plus the selected model's own week when we can tell which it is.

property boundary

boundary?: QuotaBoundaryStatus;

• Where the account stands against its boundary (#879). Absent when there is no reading, or when the week's reset could not be placed — which is "we don't know", not "nothing is allowed".

property readAt

readAt?: number;

• When the reading was taken, epoch ms. Absent when there has never been one.

property unavailable

unavailable?: DriverQuotaUnavailableReason;

• Why there is no reading, when there isn't one. Present alongside stale windows too: the last good reading is kept through a blip, and this says the newest attempt failed, so the UI can mark it stale rather than blank it.

property windows

windows: DriverQuotaWindow[];

• The account's quota windows as the agent reported them (session, week, and a week per model). Empty when we have no reading at all — check unavailable before reading that as "nothing used".

property agent

agent: AgentMeta;

property projectId

projectId: string;

property projectName

projectName: string;

property driver

driver?: string;

property fake

fake?: boolean;

property model

model?: string;

• The model id the current leg's agent was started with (#1438). Folded per leg like the driver/workspace: the latest session event wins, and a leg that recorded none clears it.

property sessionId

sessionId?: string;

property sessionLink

sessionLink?: string;

property workspace

workspace?: string;

• The directory the agent ran in (#1195), from the opening session event.

  Taken from the event rather than the filesystem on purpose: an agent that finishes cleanly has its worktree removed (tearDownWorktree), so the event is the only surviving record of where the session lived — and that path is exactly what claude --resume needs to find it again.

property lastImportedAt

lastImportedAt?: string;

• ISO 8601 UTC, the moment the last import began. Absent when nothing has recorded one.

property content

content: string;

property name

name: string;

property date

date: string;

• ISO 8601 (#1144/#1265). The <DATE>_<SLUG>.md filename's date when it has one — the format every ticket is written in, imports included — else the file's mtime, for the rare ticket that predates the format. Moves forward on an mtime-dated ticket edited in place (the GitHub update, #1208); a filename-dated one keeps the date it was created on, same as the file itself does.

property effort

effort?: number;

• The Effort: its .plan.md preamble records (ticketing_format.md: 0-10, 0 trivial, 10 takes months). Absent when unplanned or the plan names none.

property file

file: string;

• Filename inside tickets/, which is also its identity.

property github

github?: TicketGithubLink;

• The optional GitHub: key (GitHub: [#42](https://github.com/org/repo/issues/42)), split into the link text and the URL it points at.

property locked

locked?: boolean;

• Whether an agent holds this ticket (#1420): a <name>.lock.md claim exists — it is planning the ticket or implementing it directly. Mutually informative with planned rather than exclusive: the lock covers the ticket's whole life, so a locked ticket may also be planned while its agent keeps working.

property lockedBy

lockedBy?: string;

• Who the .lock.md names, from its CLAIMED: <holder> line (#1420) — shown so a human can tell whose claim they are about to release. Absent when the lock is missing or unreadable.

property planned

planned: boolean;

• Whether a <name>.plan.md sits beside it, i.e. #685 already planned it.

property priority

priority?: string;

• The optional priority: key, verbatim (a 0-10 string; 10 acts immediately).

property summary

summary: string;

• The ## TLDR line, else the first prose line. Empty when the ticket has neither.

property title

title: string;

• The # heading, else the filename made readable.

property topics

topics?: string[];

• The optional topics: key (topics: [dx, ui]), as bare tags.

property uncertainty

uncertainty?: number;

• The Uncertainty: its .plan.md preamble records (0-10, 0 an obvious implementation, 10 highly uncertain how). Absent when unplanned or the plan names none.

property content

content: string;

• The ticket's full text, unlike readTickets' head-only read.