This is the record of an abcd-managed repository

abcdBetav0.16.2 · 2026-11-06

Development record

Every session keeps a checklist on disk, so no run stalls and no stall spreads

intentplannedminorstandaloneitd-2610170638184486

Press Release

Every abcd session keeps a checklist on disk that says what it may decide, what it is waiting on and what it can do next, so an autonomous run never stalls and one stalled session never holds up the rest. Alice, a solo founder who is also the product thinker, leaves for the evening and tells their sessions to work on until 09:00. abcd records that as a mode with an owner and an end time, and each session's checklist carries it: Alice's design decisions that are signed off, the technical facilitator set to auto, the kinds of choice decided overnight and listed for the morning (security, performance, compatibility), the items waiting and on whom, the session's own promises ('when that pull request merges, do this'), and the work it owns, read from its claims, its pull requests and its branches. The checklist is repeated to the session at every start and after every compaction, so nothing that matters lives only in its context. A session that tries to stop while it has work it can do is handed the next item instead; when everything waits on something outside, it sets its next wake rather than going quiet. Before the run starts, while Alice is still there, each session writes into its checklist what could interrupt its part of the night (a design decision not yet made, a step only Alice's hands can do, work it depends on from another session, a credential it lacks), so the orchestrating session can put them to Alice together and tell them whether the run is likely to stay autonomous. In the morning Alice reads two short lists: the steps only their own hands can do, and the decisions taken while they were away, each with its grounds and how to reverse it.

Why This Matters

Written by the agent on 2026-10-17 from the overnight run of 2026-10-16 and the product thinker's framing that morning; the planning interview confirms or rewrites it.

On the night of 2026-10-16 every session had been told to work autonomously until the morning, and one session sat idle for about ten of eleven and a half hours while it held work it could do alone; the coordinating session held three finished, reviewed steps behind a merge order that only fixed when they land. The record of it is iss-2610170619247185. Everything that mattered lived in the sessions' context: the instruction to work on was relayed by a peer, overridden in one session's reading when the product thinker briefly came back, and dropped from the summary when the context was compacted. A promise ("when that pull request merges, add the wrapper") lived in a watcher that ended after two hours. Nothing in abcd saw the stall, and a Claude Code session runs only when something sends it input.

The product thinker's framing, restated:

  • Their essential design decisions are the ones with real trade-offs and more than one valid answer; obvious answers are decided by the agent and recorded. A session must be able to tell that the essential design work for a feature is truly done.
  • The technical facilitator can be set to auto, in which case the agent takes technical decisions on its own; otherwise genuine trade-offs (security, performance, compatibility) are raised with them and the rest are taken and recorded.
  • Implementation is always autonomous, with its decisions and issues reviewed and recorded.
  • Nothing stalls: while an item waits, the session keeps itself busy with work it can do.
  • One stalled session never holds up the others.

The overnight run added: a standing instruction needs an owner and an end time; a promise tied to a trigger needs to be written down; waiting is per item, never per session, and stacked work proceeds while only its landing order waits; a step only a person's hands can do (creating an App, setting a secret) is a third kind, collected for their return; decisions taken while a person is away are listed for them with grounds and how to reverse; a list cannot help a session that never runs, so stopping needs a check and waiting needs a timed wake; and a coordinator needs to see a stall.

The product thinker added the next morning: before an autonomous run starts, or as it starts, every session raises what may interrupt it and reports to the orchestrating session, so the obvious blockers are raised while the product thinker and the technical facilitator are still present. The orchestrator asks every session for this, takes the answers to them together, and once every session reports nothing left it tells them the run is likely to stay autonomous. On the night of 2026-10-16 every blocker that later stopped work was already known at 20:48, while the product thinker was still at the terminal: the two GitHub Apps and their secrets, and the question about an unowned pull request.

Mechanism

Facilitator-proposed on 2026-10-22; signed off by the product thinker on 2026-10-23 (dcn-2610230805325396).

We expect autonomous sessions to stop stalling and to come back from a compaction with their work intact, because everything a session now keeps only in its context (what it owns, what each item waits on, the promises it made, when it looks again) is written to a file the host re-injects after every start and compaction, and a session that tries to stop is shown that file's next item. Shown wrong if, over a measured run of autonomous sessions across at least one night and three automatic compactions, the share of hours a session sits idle while holding work it could do, and the number of items a session loses or repeats after a compaction, are no lower than in the same run with only the stall fix (itd-2610180912189125).

Scope Conditions

Facilitator-proposed on 2026-10-22; signed off by the product thinker on 2026-10-23 (dcn-2610230805325396).

  • Holds for sessions on a host whose hooks fire at session start (with the compact source), at prompt submission and at stop, and can add text to the model's context; Claude Code is the first such host. On a host without them, the checklist is kept but nothing re-injects it.
  • Holds for a checklist that fits the host's limit on injected text (10,000 characters on Claude Code, 2026-10-22); a longer checklist is cut to its open items, newest first, and says what it left out.
  • Holds for one working copy per checklist on one computer; the copies beyond it are itd-2610222029228127.
  • Holds while the session itself writes the checklist as it works: no hook can make a session act before an automatic compaction, so an item the session never wrote down is not recovered.

Acceptance Criteria

Draft for the product thinker to walk in the planning interview: derived by the agent on 2026-10-18 from the press release and the decisions below, and revised on 2026-10-22 for the product thinker's answers of that night and iss-2610222026223032; walked and kept in full by the product thinker on 2026-10-23 (dcn-2610230805325396). The away mode, the stop check and the question reroute are criteria of itd-2610180912189125, the slice that builds on this draft, and are not repeated here. The three criteria for the shared copies and the phone moved to itd-2610222029228127 on 2026-10-22 (dcn-2610222025212338).

  • Given Alice, the product thinker, has said the sessions work on until 09:00, when a session writes its checklist, then the file in its working copy's local tier holds the design decisions signed off, whether the technical facilitator is set to auto, the kinds of choice still raised with a person, each item waiting and on whom, its trigger promises, and the work it owns, read from its reservations, its pull requests and its branches.
  • Given a session with a checklist, when it starts or its context is compacted, then the last complete checklist is added to its context by the session-start hook, the compact source included.
  • Given an autonomous session partway through a multi-step plan (lanes dispatched, pull requests it watches, a promise to a peer, its next step), when the host compacts its context automatically, then the session resumes from the checklist it wrote before the compaction, naming the same next step and the same open items, with nothing it had written down lost (iss-2610222026223032).
  • Given a session that owns a reservation, pull request or branch its checklist does not list, or whose owned work changed after the checklist was last written, when it ends a turn while the person is away, or the person next writes to it while present, then it is told its checklist is behind and which of those it does not list, so the file is current before any compaction can come. A step that left no such trace cannot be seen, and the scope conditions say so.
  • Given a session killed while writing its checklist, or a reboot, when the next session starts in that working copy, then it reads and is given the last complete checklist, never a truncated or empty one, and an unreadable file falls back to the last good copy and says so.
  • Given a checklist promise "when pull request 42 merges, add the wrapper", when the session next looks (at a start, a wake or a stop check) after 42 has merged, then the promise is named as its next item, with no watcher process kept running.
  • Given a session whose items all wait on something outside, when it records the wait, then its checklist names what each item waits for and when it looks again, sooner than half its reservations' lease, and its state reads waiting, never stopped.
  • Given Alice says she is away until 09:00, when the away mode is set, then the blocker sweep runs at once: every session writes into its checklist any undecided design decision, step only a person's hands can do, work it depends on from another session, and credential missing or expiring; the orchestrator puts them to Alice together; and the unattended run starts only once she has answered them (dcn-2610222025217495).
  • Given the sweep finds a credential that expires before the window ends, when the session records it, then the checklist holds its kind, its scope and its expiry, and never its value or anything that retrieves it; a write that carries a secret is refused, naming the field without echoing it (adr-2610222026265719, brief invariant 24).
  • Given Alice comes back, when they read what the sessions left them, then they see two short lists across every session: the steps only their own hands can do, and the decisions taken while they were away, each with its grounds and how to reverse it.
  • Given Nia, the technical facilitator, is set to auto, when a session meets a technical trade-off, then it decides and records it; and given Nia is set to a person and is present, when the trade-off is one of security, performance or compatibility, then it is raised with them, and any other is decided and recorded; and given the person is away, when a session meets such a trade-off, then it decides it and lists it, with its grounds and how to undo it, for the person's return (dcn-2610222025225277).
  • Given a feature whose design trade-offs are listed in its checklist, when a session asks whether the human design work for it is done, then the answer is yes only when every genuine trade-off has a recorded answer from the product thinker.
  • Given a session's state shown to a person, when what the session wrote about itself disagrees with what the machine can see (its claim renewal, its process, its last commit), then the state shown follows the machine, with the session's own words beside it as a hint.

Scope Split

Agreed with the session drafting the coordination intent ("Headless agents in parallel coordinate through the shared remote, not conversation", on branch draft/conductor-intent until it lands; each record links the other once both are on the default branch), and settled by the product thinker in that session's interview on 2026-10-17:

  • This intent (one session's own state): the checklist on disk and its re-injection at start and after compaction, the modes, the waits, the trigger promises, the stop check, the timed wake, the lists for the person's return, and the pre-run blocker sweep, which asks each session by message what could interrupt it (the product thinker chose this over moving the sweep into the coordination pass).
  • The coordination intent (state shared across sessions on the remote): owned work with leases and take-over, so leases live in one place; the central view, one short status line per session (what it holds, its state in one line, what it waits on, when it was last seen), published only when it changes and only after the session has written its checklist; and each autonomous session's own credential.
  • The first slice (itd-2610180912189125, which builds on this draft): the away mode held by abcd and repeated at start, compaction and prompt, the stop check, and the question reroute, carved out on 2026-10-18 as the fix for iss-2610170619247185 so the security and bug-fix release waits on it alone (dcn-2610180913379049, dcn-2610180913388445). Its away mode grants no rights; the person's standing instruction decides what is pushed (dcn-2610181016510153). This draft keeps the rest and reuses the slice's away record and hook path.
  • Moved back from the first slice by its review round 1 (2026-10-18, dcn-2610180937181929), named remaining work of this draft:
    • the report shown once on the first prompt after the away mode ends: the queued steps, the decisions recorded in the window and the stops the host forced, with who ended the mode and from which working copy;
    • the window's decisions gathered from every working copy, by abcd decide appending each decision's id to the away record under its lock while the window is open, since sibling worktrees hold their own decision records;
    • the status line naming the away mode and its end;
    • a bare abcd mode printing the away record, the queue and the owed items with no plugin host;
    • the brief's surface text for these.

The slice keeps abcd mode back printing the queue and the recorded stops, one plain line each, so nothing queued goes unread meanwhile.

  • Moved back from the first slice by its trim after review round 2 (2026-10-18, dcn-2610181016510153 and dcn-2610181017056307, on the release orchestrator's ruling), named remaining work of this draft:
    • making the away mode the person's act alone, should a later design give it rights worth guarding: the guard entry refusing an agent's abcd mode autonomous (the binary on PATH and the plugin root's), and its routes through sh -c and a script file a shell runs; the shell-write refusal on the away store under ~/.abcd.noindex/away/; the file-tool refusal, with the PreToolUse matcher gaining Edit, Write, MultiEdit and NotebookEdit; the refused attempts recorded in the store, shown on the person's next prompt and listed by abcd mode back; and the live checks that the person's ! command reaches no pre-tool hook and that a message relayed from another session starting with ! is not run as a shell command. The slice's away mode grants no push rights, and the person's standing instruction decides what is sent, so none of this holds up the stall fix; and since the OS fence (spc-2610161751056096) covers only runner-launched agents, it stays a mistake filter in the person's own sessions;
    • the guard reading go run ./cmd/abcd (go's flags stepped over, an @<version> allowed) and a built abcd-<goos>-<arch> as abcd, for every entry that names the program, abcd-source-ledger-flip included, which commands/guard.md today names as unseen. It widens what every entry matches, so it gets its own security review here rather than riding on the cut;
    • a reuse cache for the away stop check's forge listing (a listing younger than ten minutes reused, and on a failed read a cached listing younger than half the default lease used with its age named), so a run of blocks costs one call; the slice makes one uncached listing per check under a ten-second deadline;
    • anything abcd mode back prints beyond one plain line per queued step and recorded stop: grouping, formatting or a summary of the window.
  • The shared copies and the phone (itd-2610222029228127, split out on 2026-10-22): the private shared option, the public option and the phone app, with the decisions about them below, which now bind that draft (dcn-2610222025212338).
  • Moved out to itd-2610240850336695 (the person's grant, 2026-10-24). The parked person-only work above (the guard refusing a session's own abcd mode autonomous by every route, the shell and file-tool refusals on the away store, the wider PreToolUse matcher, the recorded attempts and the two live checks) is that intent's Decision 5, because it gives the away mode the rights worth guarding. That intent builds_on this one: when this draft's pre-run blocker sweep ships, it runs before an away grant takes effect, so the person is asked every undecided design decision first (its Decision 16).

Decisions

The product thinker's answers of 2026-10-17, restated, and the agent's technical decisions on state-of-the-art grounds, each marked. The first five bullets now bind itd-2610222029228127, where they are carried.

  • Where the checklist lives: on this computer only for now. A published option on GitHub (public) and a private shared option (for example through abcdev.app) are part of this work (product thinker).
  • What the private shared option shares: everything by default, configurable later (product thinker).
  • The phone surface is part of this work. An installable web app on the private shared option, rather than a native app, reusing the live brief session's relay and GitHub sign-in; a native app only if lock-screen answers or widgets prove necessary. An answer from the phone only chooses among the options offered or adds a note. Its look is chosen in design rounds in lab-261017071130-6fd3032 (product thinker for scope; agent for the form).
  • Who answers from the phone: each person by their role: product questions to the product thinker, technical trade-offs to the technical facilitator (product thinker).
  • When the phone notifies: configurable; by default only when a session's work would otherwise stop (product thinker).
  • The stop check: a session that tries to stop while it has work it can do is refused and handed its next item only while the product thinker is recorded as away; while they are present the stop is allowed and flagged. The refusal is always made plain to them, so it never surprises them. A session genuinely waiting on something outside records what it waits for and when it will look again, and is never kept spinning (product thinker).
  • How a session learns the product thinker is away: they say so, or set it in the app, either until a set time or open-ended; open-ended, they say when they are back. The state is always shown plainly, so they never wrongly believe agents are waiting or working (product thinker). Their stated goal, which the design must make possible: almost all work runs autonomously once the human design work is done.
  • The release: this intent and the coordination intent form the autonomous-agents bundle, built as the next big release once current work settles; dashboard work joins later (product thinker).
  • The bundle gains a third member (product thinker, 2026-10-24). The person's grant, itd-2610240850336695, joins the autonomous-agents bundle, so the grant, the checklist and the coordination intent are planned together. Its Decision 14 narrows "they say so" above: the person sets the away mode and the grant by the explicit command, never by a sentence in chat.
  • Credentials: autonomous sessions never use the product thinker's own forge login; each runs under its own weaker credential, owned by the coordination intent. The checklist records the credential's kind, scope and expiry, never its value or anything that retrieves it; a missing or expiring credential is a blocker-sweep question and owed work (product thinker, with the coordination session).
  • Crash safety: the checklist survives a session killed mid-write, a host or terminal restart and a reboot, leaving the last complete checklist readable and re-injected, never truncated or empty (captured by the product thinker on the coordination session's branch; linked once it lands). The claim is confirmed only after a state-of-the-art pass and a lab that kills a session mid-write and reboots.
  • Format and re-injection (agent, on state-of-the-art grounds): the checklist is JSON, not Markdown, because long-running agent harnesses find models overwrite Markdown state more readily; it is re-injected through the session-start hook's compact event, which the host re-reads after compaction. Writes use a temporary file, fsync, rename and a directory fsync, keep a last-good copy, and validate on read.
  • A session's state (agent, matched with the coordination intent's central-view line): one of working; waiting, with what it waits on and when it looks again; or stopped, which is allowed only while the product thinker is present and is flagged. While the product thinker is away a session is never stopped with work it can do, so a waiting session never reads as idle.
  • The timed wake keeps reservations alive (agent, with the coordination session): a waiting session's next wake comes sooner than half the lease of the reservations it holds (under an hour for the two-hour lease), so an idle waiter's holds are renewed rather than lapsing and being taken over.
  • A public upload passes the embargo check (agent, on brief invariant 22): if the public GitHub option is kept, nothing it publishes may carry the id of an advisory not yet published, the same check announcements apply (itd-2609151838312703).
  • What the product thinker sees (agent): a session's state shown to a person is derived from what the machine can see (its claim renewal, its process, its last commit); what the agent writes about itself is a hint, since agent-written status lags.

The product thinker's answers of 2026-10-22, restated, each a decision record:

  • The phone and the shared copies are their own intent (dcn-2610222025212338): not asked, because the answer that full uploads come later (dcn-2610222025114805) settled it.
  • The blocker sweep runs when the person says they are away, and the run starts after they answer (dcn-2610222025217495).
  • Overnight trade-offs of security, speed and compatibility are decided and listed with how to undo each (dcn-2610222025225277).
  • A checklist never holds a credential's value (dcn-2610222025224993), written up as adr-2610222026265719 and brief invariant 24.
  • Waiting holds up one item, never a whole session (dcn-2610222025230680), written up as the principle waiting-holds-one-item-never-a-session.

The facilitator's decisions of 2026-10-22, on state-of-the-art grounds:

  • No hook makes a session write its checklist before a compaction (Claude Code's hooks reference, read 2026-10-22: the PreCompact hook can run a command or block the compaction but cannot make the model act, and PostCompact has no decision control). iss-2610222026223032's remedy asks the PreCompact hook to make the session bring its list up to date; that is not available, so the checklist is kept current as the session works, the stop check tells a session at each turn's end when its checklist is behind, and the session-start hook's compact source re-injects it.

The product thinker's walk and sign-off of 2026-10-23 (dcn-2610230805325396):

  • Signed off as written, with one wording fix. The eleven stories stand, the technical list is accepted, and the press release, grounds, scope conditions and build order are signed off. The press release's second part now names the kinds of choice decided overnight and listed for the morning, not those still raised with a person, matching the product thinker's ruling of 2026-10-22 that such trade-offs are decided and listed; the product thinker signed off the corrected text.

SOTA

Surveyed on 2026-10-23; sources, evidence tiers and the local fit risks are in the autonomous-loops SOTA note. The format and re-injection were surveyed on 2026-10-18 for the first slice (itd-2610180912189125, its ## SOTA) and the central view on 2026-10-17; this pass covers crash safety, the wake, the state vocabulary and the away report.

  • Crash safety is file-system dependent, not a sequence. Pillai and colleagues found 60 crash vulnerabilities across eleven widely used systems because application protocols "depend on subtle behaviors of the underlying file system" that differ across file systems (OSDI 2014). The practitioner summary: POSIX's rename atomicity "only applies to normal operation, not to crashes", the parent directory needs its own fsync, and macOS needs F_FULLFSYNC to reach the disk (Dan Luu). The decision's sequence is the right floor; the lab the decision names is what confirms it.
  • The host's stop refusal has a cap and a blind spot. A Stop hook's block continues the turn at most eight times in a row, reset by each tool call and adjustable with CLAUDE_CODE_STOP_HOOK_BLOCK_CAP; StopFailure fires instead of Stop on an API error (rate limit, overload, authentication) and its output is ignored; the Stop input lists pending session_crons and background_tasks (Claude Code hooks).
  • The host's wakes die with the process. Session-scoped tasks fire only while the session runs and is idle, run late by up to half their gap, expire after seven days, and a self-paced loop whose wake comes due while the process is down does not fire (Claude Code scheduled tasks). A wake written to the checklist as a time is the record; the host's cron is only the device.
  • A state vocabulary to key on, many to one. A2A's task states (working; input-required and auth-required as interrupted, non-terminal states; completed, failed, canceled, rejected as terminal) can be mapped onto the record's decided states: working to working, waiting to input-required or auth-required (though abcd's waiting also covers waiting on something outside, not only a person), and stopped to nothing, since abcd's stopped is not terminal; the mapping is lossy, and whether to rename is the first question below; the host's claude agents --json reports working, blocked, done, failed, stopped and is the supported read, while its state file "is not a stable interface" (A2A 1.0; Claude Code agent view).
  • The pre-run sweep and the morning lists have precedents. The host's cloud projects advise sending "one small piece of the real work" before a batch and group threads as "Waiting on you"; Temporal's pause (pre-release: invite-only on Temporal Cloud, Server v1.30.0 behind a flag self-hosted) records identity, reason and request id; GitHub's deployment gate holds a job in "Waiting" until a run is cancelled at the 35-day workflow-run limit, which includes "time spent on waiting and approval" (the 30-day failure is the Enterprise Server 3.5 page's; the current cloud pages do not state a limit) (host, Temporal and GitHub docs).
  • The phone can be reached by standards. Web Push stores a message for a TTL with a 4096-byte payload floor (RFC 8030), and iOS 16.4 delivers it to home-screen web apps without a developer account (WebKit blog): the push carries the stop's id, the page fetches the options.

Path 2: the checklist as decided (JSON, temp-fsync-rename-dir-fsync, last-good copy, validate on read), written by the canonical fsutil writer with an F_FULLFSYNC option on macOS and proved by the kill-and-reboot lab; a proposal, against the recorded state decision (working; waiting; stopped), to map the checklist's states onto A2A's where they fit (working to working, waiting to input-required or auth-required, stopped with no A2A equivalent) so the checklist line, the central-view line and a later bridge share words, the renaming itself being the first question at the end of this section; the host's claude agents --json as the instant local tier where it exists, never its state file; a wake recorded as a time in the checklist with the host's cron as the device. The Web Push sender is a Go dependency in the relay, not the binary, and needs explicit sign-off; a relay-notified phone sits against the local-only stance on agent messaging, and the fit-challenge before the build must say where that stance ends. The independent fit-challenge is still owed before the build, and the questions below are kept for it.

Questions this pass raised for the fit-challenge before the build. They are kept here, not under Open Questions, so they do not hold a build the record already rules ready:

  • Whether the checklist's state names adopt A2A's task-state vocabulary where it fits (working; input-required or auth-required for waiting; no A2A state for stopped) so the central view and a later host or protocol bridge share one set of words, which revisits the recorded state decision, or keep the decided names and map at the bridge.
  • Whether the canonical writer gains an F_FULLFSYNC option on macOS for the checklist and the away record, and whether the kill-mid-write lab also pulls power rather than only killing the process.

Open Questions

All resolved at the product thinker's walk and sign-off of 2026-10-23 (dcn-2610230805325396).

  • Delivery in two specs: settled. The checklist on disk, its crash-safe write and its re-injection come first, resolving iss-2610222026223032; the waits, trigger promises, timed wakes, the blocker sweep, the return lists, the facilitator's mode and the design-done answer follow. abcd mints one spec per plan, so the second half is carried as the first spec's remainder and split off with spec close --remainder when the first lands.

Audit Notes

Empty. Populated by intent-auditor when intent moves to shipped/.

Grounds

  • pursued: autonomous sessions stop stalling and come back from a compaction with their work intact once what they own, what each item waits on, their promises and their next look live in a file re-injected at every start and compaction; shown wrong if, over a measured run across at least one night and three automatic compactions, the idle hours while holding doable work and the items lost or repeated after a compaction are no lower than with only the stall fix. Occasioned by the night of 2026-10-16, about ten hours idle in one session with promises lost to compaction, and by iss-2610222026223032.

Frontmatter

iditd-2610170638184486
typeintent
lifecycleplanned
kindstandalone
severityminor

.abcd/development/intents/planned/itd-2610170638184486-every-abcd-session-keeps-a-checklist-on.md
open on GitHub ↗ · commit history ↗

References2

Referenced by12

  • adr-2610222026265719A session's checklist names a credential by its kind, scope and expiry, never its value or anything that retrieves itrelated
  • adr-2610240850193281A human-set autonomy grant permits, separately from the agent-written waiting-on badgerelated
  • iss-2610170619247185An agent session told to work autonomously overnight sat idle for about ten of the eleven and a half hours between 20:48 BST on 2026-10-16 and 07:13 BST on 2026-10-17, while it held owed work it could have done alone.related
  • iss-2610222026223032Autonomous work does not reliably survive the host's automatic compaction: after a compaction a long-running session keeps only a summary, and the work it was in the middle of (which lanes it dispatched, which PRs it is watching, what it promised a peer, the next step of a multi-step plan) survives only if the session happened to write it down. The person wants every autonomous session's work to survive auto-compaction, for example through a to-do list kept in the checkout's local tier (.abcd/.work.local) that the session reads back after a compaction. Related: the draft intent every abcd session keeps a checklist (itd-2610170638184486), being planned on 2026-10-22.related
  • iss-2610262036224651itd-2610170638184486 lets the person set away open-ended, ending only when they say they are back; the mode chapter caps every away record at seven days.related
  • iss-2610262041043651The glossary forbids 'release' for a plan of what ships together; the checklist draft plans its bundle as 'the next big release'.related
  • iss-2610262044279216The checklist draft allows an open-ended away state, but the shipped away mode is capped at seven daysrelated
  • itd-2610170634394993Headless agents in parallel coordinate through the shared remote, not conversationrelated
  • itd-2610180912189125A session left to work on never stops while it has workbuilt on by
  • itd-2610222029228127Every session's checklist reaches a shared copy and the phonebuilt on by
  • itd-2610240850336695The person grants their sessions what they may do alone, until a timebuilt on by
  • spc-2610230805429429every-abcd-session-keeps-a-checklist-onimplemented by

mentions35

  • adr-2610181003541997The away mode's stop check reads the forge once, as its documented meaning
  • dcn-26101807203896282026-10-18 — Registering the App takes one step in the browser (facilitator-on-delegation, itd-2610170634394993 planning prep): creating a GitHub App needs the person on the website once, through the manifest flow, so the draft states it as a step only the person can take, as the checklist draft already lists it, and never promises setup without manual steps (grounds: docs.github.com registering-a-github-app-from-a-manifest; itd-2610170638184486)
  • dcn-26101807204274372026-10-18 — The coordination stance has a bound (facilitator-on-delegation, itd-2610170634394993 planning prep): the principle that coordination never lives only in conversation governs facts one agent relies on from another (holds, waits, turns, budgets); a question put to a person, such as the pre-run blocker sweep the product thinker placed in the checklist draft, may travel by message and lands in each session's checklist (grounds: the draft's decision 2; itd-2610170638184486 scope split)
  • dcn-26101807205412062026-10-18 — A session's mode shows on its central-view line (facilitator-on-delegation, itd-2610170634394993 planning prep): the line carries the session's state from the checklist draft's fixed set: working; waiting, with what it waits on and when it next looks; or stopped, which is allowed only while the person is present and is flagged. While the person is away a session with work never stops, and one with nothing it can do is waiting with its next look, so no session reads as idle. This follows the product thinker's ruling that the person must never wrongly believe agents are working or waiting (grounds: the draft's decision 6; itd-2610170638184486 modes)
  • dcn-26101807205480662026-10-18 — A waiting session wakes before half its lease (facilitator-on-delegation, itd-2610170634394993 planning prep): since no process stays alive and a branch is rebuilt only when its agent asks to land, a session waiting on a dependency wakes, through the checklist draft's timed wake, at an interval shorter than half its reservations' lease, so an idle waiter's reservations are renewed rather than lapsing after two hours and being taken over (grounds: itd-2609091034175565 two-hour lease, renewed at half; itd-2610170638184486 timed wake; the draft's take-over criterion)
  • dcn-26101809052838062026-10-18 — The overnight-stall fix ships first, ahead of the coordination intent (facilitator-on-delegation, itd-2610170634394993 planning prep): the fix for the critical overnight stall (an autonomous mode abcd holds, and a stop check that refuses to end a turn with owed work) sits in the checklist draft, which owns a session's modes, waits and stop check; it needs nothing on the shared remote, so it ships as the bundle's first slice, without waiting on this intent, and the security and bug-fix cut waits on that slice alone; this intent then adds what the stall's record asks for across sessions, the idle time a coordinator sees, through the central view's derived state and last-seen time in abcd status rather than in abcd peers as the record's remedy words it, per the decision naming abcd status as the central view (grounds: iss-2610170619247185 remedy; itd-2610170638184486 scope split; the draft's decisions 3 and 6)
  • dcn-26101809133790492026-10-18 — The overnight stall is fixed first, not deferred (facilitator-on-delegation, iss-2610170619247185 and itd-2610170638184486 planning prep): the critical record of the session that sat idle overnight is not given a one-cycle deferral; the security and bug-fix release waits for the smallest slice that removes its core cause, filed as itd-2610180912189125. This rests on the product thinker's standing rulings, restated: of 2026-10-11, that a major finding is fixed before a cut, never deferred, and building carries on; of 2026-10-12, that when a deferred question is all that stands between an intent and its plan, the facilitator decides it on delegation and plans it; of 2026-10-17, that in an autonomous run the agent decides and records rather than ending on a wait for the person. The stop check itself is the product thinker's settled design, in the checklist draft's decisions of 2026-10-17: a stop with work owed is refused only while they are recorded as away, and while they are present it is allowed and pointed out. It agrees with the coordination prep's decision that this fix ships as the bundle's first slice without waiting on the coordination intent (grounds: iss-2610170619247185 remedy; itd-2610170638184486 decisions; the coordination prep's ship-first decision of 2026-10-18)
  • dcn-26101809133884452026-10-18 — The stall fix is its own intent, not a spec of the checklist draft (facilitator-on-delegation, itd-2610180912189125 planning): the slice (the away mode held by abcd, the stop check, and the question reroute) is filed as itd-2610180912189125, which builds on itd-2610170638184486, rather than planned as a first spec of that draft closed with a remainder; planning the draft would move it to planned before the product thinker has walked its criteria on Thursday, and its open trade-offs (the phone, the shared options) would then sit inside a planned record. A separate intent keeps the split with the coordination intent unchanged, since the slice touches nothing on the shared remote, and follows the precedent of itd-2610150602547271, filed as the first slice of itd-97. The idle time a coordinator sees stays out of the slice and comes with the coordination intent's central view (grounds: brief invariant 17; itd-2610150602547271; itd-2610170638184486 scope split; the coordination prep's ship-first decision)
  • dcn-26101809133990422026-10-18 — The away mode is a record of the person's absence, set by a verb and ended only by its time or by their word (facilitator-on-delegation, itd-2610180912189125 planning): abcd mode autonomous [--until <time>] records who set it (the holder name reservations already resolve from caller-local facts), when, and when it ends, where --until takes a clock time (its next occurrence, local time) or a full timestamp and a time already past is refused; without --until it is open-ended until abcd mode back. It sits beside the waiting-on badge, whose three words stay a closed set, and is not a fourth word. A human prompt during the window does not end it, since a brief return overrode the instruction on 2026-10-16 and a prompt from a peer looks the same. An agent sets it on the person's word in its session, and one set covers every working copy, so no peer has to relay it. This restates the product thinker's 2026-10-17 ruling that they say they are away, until a set time or open-ended, and say when they are back (grounds: itd-2610170638184486 decisions; iss-2610170619247185; brief invariant 10; internal/core/mode)
  • dcn-26101809134131372026-10-18 — The stop check refuses only while the person is away and is bounded so it never spins (facilitator-on-delegation, itd-2610180912189125 planning): a plugin Stop hook asks abcd, which blocks the stop with the host's decision block and a reason naming the next owed item and how many remain, only while the away mode holds and owed work exists. While the person is present the stop is allowed and, with work owed, pointed out in one line through the host's systemMessage. If the host says the session is already continuing because of a stop hook and the owed set is unchanged since this session's last block, the stop is allowed and recorded as stopped with work owed, shown on the person's return; the host's own cap of eight consecutive continuations, reset by each tool call, is the outer bound. The host documents stop_hook_active as the field to check so a hook never blocks on a condition that will not resolve. The session states are the bundle's: working, waiting, stopped. This restates the product thinker's 2026-10-17 stop-check ruling (grounds: code.claude.com/docs/en/hooks Stop input and Stop decision control; itd-2610170638184486 decisions)
  • dcn-26101809134211092026-10-18 — A session with nothing owed stops only with its next look scheduled (facilitator-on-delegation, itd-2610180912189125 planning): while the away mode holds, a stop with no owed work is allowed when the host reports a scheduled wake for the session or a background task in flight, and is then waiting; otherwise it is blocked once, asking the session to schedule its next look sooner than half its reservations' lease (under an hour for the two-hour lease) through the host's own scheduling, and the bound in the stop-check decision applies. The host documents that its Stop input carries session_crons (wakes from CronCreate, ScheduleWakeup and /loop) and background_tasks so a hook can tell a finished session from one paused for work that will wake it. abcd starts no process of its own and schedules nothing itself. The check covers the overnight gap after the two-hour watcher ended; the checklist draft's own timed wakes and trigger promises stay there. It matches the coordination prep's decision that a waiting session wakes before half its lease, and the product thinker's ruling that a waiting session records when it looks again and is never kept spinning (grounds: code.claude.com/docs/en/hooks Stop input; itd-2610170638184486 decisions; iss-2610170619247185 idle spans)
  • dcn-26101809134314932026-10-18 — While the person is away no question waits for them (facilitator-on-delegation, itd-2610180912189125 planning): while the away mode holds, the guard refuses every question on the host's question tool, abcd's or another tool's, because a question nobody is there to answer stalls the session. A product or technical question is refused with a reason telling the agent to decide it, record it with abcd decide marked as decided on delegation with its grounds and how to reverse it, and carry on; a step only the person's hands can do (a browser step, a secret, a new App) is refused with a reason telling the agent to queue it with abcd mode queue "<step>" and carry on with other work. abcd mode product-thinker or facilitator is refused the same way. Decisions in the window are not asked first, technical trade-offs included, since the product thinker ruled on 2026-10-17 that in an autonomous run the agent decides and records and only steps that need them on the website wait (grounds: iss-2610170619247185 remedy; itd-2610170638184486 framing; internal/surface/cli guard question check)
  • dcn-26101809134319852026-10-18 — The person's return shows two lists derived from what already exists (facilitator-on-delegation, itd-2610180912189125 planning): when the away mode ends, by its time passing or abcd mode back, the next prompt shows once the steps queued for the person's hands and the decisions recorded in the window, each with its text, which the reroute asks to carry its grounds and how to reverse it, plus any stop recorded with work owed. The decisions are the decision records whose time-ordered ids fall inside the window, so no second store of decisions is kept; the queue is the only new list and lives in the away record. The draft's richer lists for the person's return stay in itd-2610170638184486 (grounds: principle one-canonical-primitive; adr-45 time-ordered ids; itd-2610170638184486 press release)
  • dcn-26101809134449712026-10-18 — A session's checklist is one JSON file per working copy in its local tier (facilitator-on-delegation, itd-2610170638184486 planning prep): the checklist the draft describes is kept per working copy, since the checkout is the unit of isolation and the coordination prep keys one central-view line per working copy, in that copy's local tier, never in a tracked folder, and its re-injection reuses the slice's session-start and prompt-hook path; the away mode itself is not copied into it but read from the repository's one away record (grounds: AGENTS.md concurrent sessions and working-tree layout; the draft's format decision; the coordination prep's per-working-copy decision; itd-2610180912189125)
  • dcn-26101809134452722026-10-18 — The slice keeps the core host-agnostic and is reachable without a host (facilitator-on-delegation, itd-2610180912189125 planning): the away record, the owed-work reading and the stop verdict are a core package returning data, and the front doors format it: abcd hook stop maps the host's Stop payload and answers in its decision format, and a bare abcd mode prints the away record, the queue and the owed items, so the check runs with no plugin host present. The plugin's hook manifest gains a Stop entry with the same bootstrap and home checks as its other hooks, and the status line names the away mode and its end, so the person never wrongly believes agents are working or waiting. Nothing is written under the host's own settings directory (grounds: brief invariant 3; AGENTS.md transport-agnostic core and wired or it isn't done; the product thinker's ruling of 2026-10-05 that nothing in the host's settings calls abcd beyond the consented status line; itd-2610170638184486 decisions)
  • dcn-26101809134558282026-10-18 — A promise tied to a trigger is a checklist entry checked when the session looks, never a watcher (facilitator-on-delegation, itd-2610170638184486 planning prep): a promise such as 'when that pull request merges, add the wrapper' is written into the checklist with its trigger, read by the session at each start, wake and stop check, and its wake is the host's scheduled wake that the slice's stop check already reads; abcd keeps no process alive for it. The two-hour watcher of 2026-10-16 ended with the promise unkept, and the coordination prep settled that every deadline is derived when records are read, with no process that must stay alive (grounds: iss-2610170619247185; the coordination prep's on-demand pass decision; code.claude.com/docs/en/hooks Stop input session_crons)
  • dcn-26101809134664362026-10-18 — The pre-run blocker sweep asks four fixed kinds and reports the run likely autonomous only when none is open (facilitator-on-delegation, itd-2610170638184486 planning prep): before or as an autonomous run starts, the orchestrating session asks each session by message, as the product thinker chose, for (1) a design decision not yet made, (2) a step only a person's hands can do, (3) work it depends on from another session, and (4) a credential missing or expiring within the window; each session writes its answers into its checklist, the orchestrator puts them to the person together, and says the run is likely to stay autonomous only once every session reports none open. The kinds are the four the draft's press release names; the message route stays within the coordination prep's bound that a question put to a person may travel by message (grounds: itd-2610170638184486 press release and scope split; the coordination prep's stance-bound decision; iss-2610170619247185, every blocker known at 20:48)
  • dcn-26101809365777202026-10-18 — While the person is away a session is only working or waiting, and abcd never allows a stop with work owed (facilitator-on-delegation, itd-2610180912189125 review round 1; supersedes the bound in dcn-2610180913413137 and refines dcn-2610180913421109): while away a stop is allowed only when the session has a qualifying wake and either nothing is owed or the owed set is unchanged since this session's last block; it then reads waiting, and the wake's next fire time is kept as its next look in the session's own state file in the local tier, beside the owed-set fingerprint and a count of consecutive blocks. Every other stop while away is blocked, whatever stop_hook_active says, naming the next item, or with nothing owed asking the session to take the next ready item first and only then schedule its next look. The host's cap of eight consecutive continuations, or the cap its documented environment variable sets, is the outer bound, and the block abcd counts as reaching it records stopped with work owed in the away record. The old row that allowed an unchanged owed set once stop_hook_active was true reproduced the stall, since a reply of awaiting the person with no tool call ended the turn until morning. This matches the coordination prep's decision that while the person is away a session with work never stops and one with nothing it can do is waiting with its next look, and the draft's ruling that stopped is allowed only while the person is present (grounds: the plan review of 2026-10-18, findings 2, 5 and 12; code.claude.com/docs/en/hooks Stop input and continuation cap; itd-2610170638184486 decisions)
  • dcn-26101809371819292026-10-18 — The person's return report, the status line and the bare abcd mode print move from the slice back to the checklist draft (facilitator-on-delegation, itd-2610180912189125 review round 1; supersedes dcn-2610180913431985 for the slice, and the status-line and bare-print halves of dcn-2610180913445272): both reviewers of 2026-10-18 recommended the split, so the security and bug-fix cut waits only on the away record, the stop check and the question reroute. The spec's step 6 and the return half of its step 5 leave the slice: the report shown once on the first prompt after the window ends (the queue, the window's decisions and the recorded stops); the window's decisions gathered from every working copy by abcd decide appending each id to the away record under its lock (review finding 8); showing on return who ended the mode (finding 13); the status line naming the away mode and its end; a bare abcd mode printing the record, the queue and the owed items; and the brief's surface text for them. They become named remaining work in the scope of itd-2610170638184486. The slice keeps what its own behaviour needs: abcd mode back prints the queue and the recorded stops as it ends the record, so a queued step is never unread; brief invariant 7 gains the away mode's forge listing; and the plugin page and the brief's surface chapters describe the verbs and hooks the slice ships, so nothing it ships is undocumented. The slice is re-estimated at five working days (grounds: the plan review of 2026-10-18, size and split; the coordination prep's decision that the cut waits on this slice alone; AGENTS.md wired or it isn't done; brief invariant 7)
  • dcn-26101810165101532026-10-18 — The away mode grants no push rights: the person's own standing instruction stays the authority to commit, push, and open or merge a pull request, exactly as before the mode existed (facilitator-on-delegation on the release orchestrator's ruling, itd-2610180912189125 after plan review round 2; supersedes dcn-2610181003456444, round 2's choice (a), and with it the guard entries that made setting the mode the person's act alone). The OS sandbox of spc-2610161751056096 fences only the agents abcd's runner launches, never the person's own interactive sessions, so for the sessions that actually stalled on 2026-10-16 the guard entries would never become a boundary, and their two days would buy a trust claim the plan cannot make. The fallback dcn-2610181003456444 already named is taken now, not on the live capture's evidence. Where the stop check finds owed work that needs a push (an unpushed branch, a reservation whose work no pull request carries, a behind or failing pull request once its local fix is committed), its reason tells the session to push if its standing instruction allows, and otherwise to queue the push with abcd mode queue for the person's return; a queued step that names the item's branch or record id, on word boundaries, hands that item back to the person for the rest of the window (a branch only while it holds commits its upstream lacks, so only the push waits), and the stop check stops naming it. The away mode is never treated as permission. The person-only acts gain pushing, opening or merging a pull request without a standing instruction that allows it. Who sets the mode returns to dcn-2610180913399042: the person, or a session on their word in that session; since the mode grants nothing, a mode set on a relayed word only keeps sessions working and deciding instead of asking, and the person sees who set it, from which working copy, and the literal abcd mode back on their next prompt. Making the mode the person's act alone moves to itd-2610170638184486 as named remaining work: the guard entry refusing an agent's abcd mode autonomous, its other routes (sh -c and script files), the shell-write and file-tool refusals on the away store, the refused attempts recorded and shown, the capture's checks of the person's ! command and of a relayed !, and the guard reading go run ./cmd/abcd and built abcd-<goos>-<arch> binaries as abcd for every entry, the ledger flip included, a security-relevant widening that gets its own review there (grounds: the release orchestrator's ruling of 2026-10-18 and the reviewer's addendum, both recommending the fallback; spc-2610161751056096 and adr-2610161621415708, which fence launched agents only; iss-2610170619247185, whose standing instruction already allowed pushes and auto-merge; the fallback clause of dcn-2610181003456444)
  • dcn-26101810170563072026-10-18 — The overnight-stall slice is trimmed to what closes iss-2610170619247185 and nothing else (facilitator-on-delegation on the release orchestrator's ruling, itd-2610180912189125 after plan review round 2; refines dcn-2610180937181929): it keeps (i) a session with owed work cannot end its turn silently, through the Stop hook stop check with the ownership rules, the qualifying wake and the cap handling the reviews required; (ii) questions rerouted by the act, every other question decided with abcd decide and the person-only acts queued; and (iii) the away record set, ended, lapsing after at most seven days, re-injected at start, compaction and every prompt, under its lock. Moved to itd-2610170638184486 as named remaining work: the person-only guard step (dcn-2610181016510153), with the guard's reading of go run ./cmd/abcd and built binaries as abcd; the ten-minute reuse cache of the away forge listing and its stale-cache fallback, so each away check makes at most one listing under its ten-second deadline and a failed read judges from disk naming the pull requests as not read (adr-2610181003541997, still proposed, amended to match); abcd mode back printing more than one plain line per queued step and per recorded stop (any grouping, formatting or window summary); and the refused-attempt lines on the prompt. Kept despite the trim, because a review finding's fix rests on each: the created-branch list recorded in any mode (round-2 blocker 3, the drain's stacked branches, instance 2 of the issue); the Refs rule and word-boundary matching (blocker 4); the stale-ownership bounds (blocker 5); the wake deadline with the host's lateness and the cron cases (blocker 1); the forge's merge state for behind, with the one bounded listing and invariant 7's clause (blocker 2); the person-only acts list (blocker 6); the every-prompt line and the lapsed-window line naming abcd mode back (blocker 7); the block count and its possibly-forced label (round-2 (b)); the clearing rule's review and receipt terms (round-2 minors); the record's lock, ownership checks and seven-day cap (round-1 findings 6 and 7); the recorded ender (round-1 finding 13); the StopFailure record and the prose-question block (round-1 finding 11); and the badge verbs refused while away, which keeps a question from waiting on the person through the badge (dcn-2610180913431493). Re-estimated at 5.75 working days over seven steps, down from eight; about four is not reachable without reopening blockers 1 to 5, since the owed-work reading and the stop verdict with its cron parser carry 3.5 days between them and every rule in them answers a finding; the verdict is pure over the owed set, so two lanes could bring the elapsed time to about four days if the release orchestrator chooses (grounds: the release orchestrator's ruling of 2026-10-18 and the reviewer's addendum listing what stays; the spec's review rounds 1 and 2; AGENTS.md wired or it isn't done)
  • dcn-26102220251148052026-10-22 — Only the short status line is shared for now; full checklist uploads come later (product thinker's ruling of 2026-10-22, itd-2610170634394993 C2): this intent publishes one short line per session and no full checklist, public or private; uploading a session's whole checklist so another computer could resume it is later work. This settles the two rulings of 2026-10-17 that disagreed, in favour of later, and keeps the intent's decision 3 as written
  • dcn-26102220252123382026-10-22 — The phone and the shared copies of each checklist become their own intent in the bundle, and no question was put (facilitator, recorded on the product thinker's 2026-10-22 ruling C2, itd-2610170638184486 K1): once the product thinker chose to upload full checklists later, the shared copies are wanted later, and the phone needs them, so keeping them inside the checklist intent would hold its sooner parts back for nothing; splitting them off is the only answer consistent with the record, so asking would have offered a choice already made. The checklist intent keeps the on-disk checklist, waits, wakes and the blocker check
  • dcn-26102220252174952026-10-22 — Sessions list what could stop them overnight when the person says they are away, and the unattended run starts once the person has answered the list (product thinker's ruling of 2026-10-22, itd-2610170638184486 K2): the person has nothing to remember to say beforehand, at the cost of a few minutes' wait before leaving; chosen over a warning ahead of leaving and over every session keeping its list current all day
  • dcn-26102220252249932026-10-22 — A checklist never holds a password, token or anything that retrieves one, only its kind, scope and expiry, and this is written up as its own trust rule (product thinker's ruling of 2026-10-22, itd-2610170638184486 K-split i): routed through the decomposition table as a trust rule, so it becomes an ADR and a clause of the brief's invariants rather than a line inside the checklist intent
  • dcn-26102220252252772026-10-22 — While the person is away, sessions keep deciding trade-offs of security, speed and compatibility, and list each with how to undo it (product thinker's ruling of 2026-10-22, itd-2610170638184486 K-confirm): this confirms the 2026-10-17 ruling that nothing waits on the person overnight over the earlier framing that such trade-offs are raised with the technical facilitator; the list is shown on the person's return
  • dcn-26102220252306802026-10-22 — Waiting holds up one item, never a whole session, and this is written up as a standing principle (product thinker's ruling of 2026-10-22, itd-2610170638184486 K-split ii): routed through the decomposition table as a stance, so it becomes a principle under .abcd/development/principles/; the principle states the stance behind dcn-2610180905291297, that a declared dependency holds only the landing
  • dcn-26102308053253962026-10-23 — The product thinker's walk and sign-off of itd-2610170638184486 on 2026-10-23 (about 10:05 BST, in abcd-ae's session), restated. The eleven person-visible stories are kept and the technical list is accepted in full. The press release is signed off in its four parts with one wording fix, shown to the product thinker before they signed: the kinds of choice the checklist carries are those decided overnight and listed for the morning (security, performance, compatibility), not those still raised with a person, matching their ruling of 2026-10-22 that such trade-offs are decided and listed. The grounds, the scope conditions, and the reason for doing it now with its build order (the checklist file first, from the compaction issue iss-2610222026223032, then the waits, promises, wakes, blocker sweep and return lists) are signed off. The intent is planned on this sign-off; abcd mints one spec per plan, so the second half is carried in the first spec as its remainder and split off with spec close --remainder when the first lands.
  • dcn-26102719260705232026-10-27 — Ruling by the product thinker on 2026-10-27, relayed by the coordinating session abcd-f5 and restated: the 23 Oct plans for the coordination intent itd-2610170634394993 and the terminal-drain intent itd-2610222215485265 land now, together with the checklist intent itd-2610170638184486 and its built steps 1 to 3 (spc-2610230805429429). This settles the overlap with the 24 Oct note in #1130 that the autonomy grant itd-2610240850336695, the checklist and the coordination intent are planned together as one bundle: that joint planning still happens, and it builds on what lands here rather than re-planning it. The rebase keeps every addition #1130 and the 25 Oct edits made to the three drafts.
  • iss-2610311225001256abcd build itd-2610170638184486 is refused at the peers check because the worktree sota-open-intents, on branch research/sota-open-intents, holds the intent in drafts/ with its own edits, while this checkout has it in planned/. The branch's last commit is 2026-10-23 and it is not merged, so the hold is a research copy a week stale, and the refusal gives neither its age nor a way past it (merge it, or rebase it onto the planned record; removing the worktree is the person's act alone, since it deletes the copy's local tier); an unattended build cannot tell an abandoned peer from live work and is blocked indefinitely.
  • iss-2610311514162877On 2026-10-31 abcd build itd-2610170638184486 was refused at the peers check by backup/sota-open-intents-pre-rebase, a local branch an agent made as a safety copy before rebasing research/sota-open-intents onto main; it held the intent's old drafts/ copy, while main and the rebased branch held it in planned/. The peers check reads every local branch under refs/heads/ (internal/core/peers/read.go) and cannot tell a safety copy from live work, and the guard then refused the branch's deletion (git-delete-unproven) because a rebase that squashed and resolved conflicts leaves no ancestry or patch-equivalence for it to prove, so the build stayed blocked until the person allowed the delete by hand. abcd teaches no safe form of the backup: a tag, or a ref outside refs/heads/, would have kept the copy and blocked nothing.
  • itd-2609151838312703Sessions under any account, on any machine or in the cloud announce what they are doing through short fixed-form announcements on the shared remote, a person reads everyone's status with one command, and what is really a hold stays a reservation
  • spc-2610161751056096a-person-who-leaves-abcd-to-run-on-its
  • spc-2610180914469489A session left to work on never stops while it has work
  • waiting-holds-one-item-never-a-sessionWaiting holds one item, never a session