Commit Graph
2710 Commits
Author SHA1 Message Date
sam 1b28bba234 feat(workflow): routing and playbook findings carry the key's file:line 2026-09-23 21:41:56 +10:00
sam 36e69724a4 fix(webui): move the live stream to /api/stream so reloading /events serves the page 2026-09-23 21:16:29 +10:00
sam 9de96c1d42 feat(webui): two-section quality gates, sweep the restating card prose
The quality gates card stacked its number and rows across the full row
width -- the rate pinned to the left edge, the counts to the right --
which reads as two places at once. The card now has two internal
sections, left to right: the rate, and the per-workflow rows that
explain it; the row collapses under 720px.

Also swept the restating descriptions: 'Work that passed its quality
gates' under Quality gates, 'Archie needs these before it can work on
its own' under Finish setting up, 'Next 30 days at the current rate'
under Token outlook, 'Last 50, newest first' under Live activity. A
title and a sentence that restate each other are noise; the table or
chart says the thing. CapturesCard's redaction note is a security fact,
not restatement, and stays. The unconfigured versions state is one
quiet line, not a card with a title, a description, and a sentence.
2026-09-23 15:29:28 +10:00
sam 1e8dc3b8a5 feat(webui): compact quality gates card, drop the setup celebration, hover nav
Three dashboard refinements from operator feedback:

The setup panel's completed state was celebration prose -- a full card
saying setup was done, occupying a grid cell until dismissed. A
configured daemon is the absence of a problem: the state machine now
only distinguishes incomplete from omit, the checklist returns on its
own if setup regresses, and the dismissal machinery is deleted with it.

'Gate pulse' led with a donut whose entire payload was one number, and
the name was decoration too. The card is 'Quality gates' now: the pass
rate as the number itself beside its run count, per-workflow rows as
tight hairline rows instead of muted pills, and the parked line is gone
-- Throughput's Needs-you tile already speaks for parked tasks, from the
statuses themselves. base/Gauge.vue had no other consumer and is deleted.

Topbar nav groups open on hover and close on leave, with a short grace
period bridging the trigger-to-content gap; click and keyboard
activation keep working through the same controlled open state.

The live activity feed scrolls within its card (previous commit); the
health row's cards are now compact enough to match it.
2026-09-23 14:53:40 +10:00
sam 43cdff2c03 fix(webui): bound the live activity feed to the card
Group rows multiply with the number of interleaved tasks -- one group
per task per detail shape -- and nothing capped the card's height, so a
live instance rendered the dashboard ~4,700px tall with a void beside
the token outlook card. The feed now scrolls inside a 28rem region with
a sticky header: newest events at the top, the rest in place, and the
RIGHT NOW section's two cards stay comparable in height.
2026-09-23 14:42:43 +10:00
sam 635ae452f1 docs(releasing): record that main and the branch diverge on every release
The release commit lands on main, because tools/release.sh refuses to run
anywhere else, while the working branch keeps advancing. So after every release
neither tip is an ancestor of the other and --ff-only fails in both directions
-- a refusal that reads as "the tree is not ready" when the tree is fine. It
cost confusion on both v1.38.0 and v1.40.0, and both times the correct answer
had to be re-derived from the commit graph.

Documents the order that keeps a conflict off main (merge main into the branch
first, then fast-forward), and the trap that catches people looking for main: a
detached worktree sitting at the same commit accepts --ff-only and moves
nothing, which looks like success.
2026-09-23 14:42:32 +10:00
sam ac4e435e07 chore(release): v1.40.0 2026-09-23 13:30:57 +10:00
sam d5abdbc4f2 merge(release): bring the v1.39.0 release commit into sams-cleanup
The branch and main diverged at 665ab9bc: the release commit was cut on
main while the branch kept advancing with the park-classification wave.
Merging main here first, so main can fast-forward to the branch tip
without a merge on the release side. No content conflicts: the release
commit touches the changelog and news artifacts only.
2026-09-23 13:23:16 +10:00
sam 4e0ba68a82 feat(staterpc,daemon): park classification on the wire and at the park sites
Domain fields ParkClass/RemediationRounds landed in 0d82f3fa; this is
the wire and daemon half. Task gains park_class (32) and
remediation_rounds (33) and maps both directions; the classified park
write crosses the wire as ParkTask on a narrow TaskParker contract
(TaskLifecycle stays under the 8-method cap), with conformance
coverage local + grpc including the stale-guard sentinel and
needs_human normalization. Every daemon park site now states its
class: terminal for a repo that left config and a retired identity,
transient for the environmental parks (worktree, storage, grants,
taskrun), and identityMayAct returns the class beside its reason.
2026-09-23 13:18:08 +10:00
sam 5b56f0adca fix(staterpc): carry park class and remediation rounds across the wire
0d82f3fa added Task.ParkClass and Task.RemediationRounds to the domain
without the wire half; the parity guard went red. Add the two proto
fields (32/33) and map both directions in values.go.
2026-09-23 13:10:31 +10:00
sam bf00b14d5a fix(release): CI owns the release stamp; :latest moves only from a release
Two beads, one root: four sites stamped a version and only two of them were CI.

`Taskfile.yml`'s build and `install.sh` derived GATEWAY_VERSION/RUNTIME_VERSION
from `git describe`, so a from-source build claimed a release it was not
running, and the stamp became a function of the commit graph -- the one input a
content-checksum build cache cannot see. An empty commit moved `git describe`
while `task build` reported "up to date" and shipped the previous stamp
(archie-core-pdq2). Both sites now stamp `dev`: a source build says so, and the
version a release carries is written into the artifact CI publishes. That
removes the non-file input rather than caching it, and traceability for a local
build is the checkout it came from.

`deploy.yml` published `:latest` from any push to main, so a release's own
stamping survived only until the next ordinary commit -- minutes, in an active
repo -- and a host deploying :latest reported dev, leaving the update path
unable to tell current from stale (archie-core-i5nb). `:latest` now moves only
from a commit that IS a release; every other build publishes `:edge` (mutable,
newest main) and `sha-<commit>` (immutable). A host that runs releases follows
`:latest`; a host that tracks main follows `:edge`, which RELEASING.md now says.

Verified: `task build` reports `archied dev`; the new workflow test fails
against the old workflow on all five guards and passes after; deploy.yml
parses; install.sh passes `bash -n`.

Gated with `task check` (exit 0) at 665ab9bc -- the v1.39.0 base, CI-green --
with these five files applied. It is NOT gated at HEAD: HEAD carries an
unrelated red, `TestTaskProtoCarriesEveryDomainField`, because 0d82f3fa added
ParkClass and RemediationRounds without the proto mapping. This change neither
causes nor fixes that.
2026-09-23 13:09:01 +10:00
sam 05ee734168 feat(webui): show the park class beside the Parked badge
The classification rides the API for free (taskView embeds task.Task),
so this is the read side only: a parked row shows what kind of
intervention it needs -- needs you, transient, terminal -- as a chip
with the answer in its tooltip, instead of a bare Parked every time.
Non-parked rows render nothing.
2026-09-23 12:57:27 +10:00
sam 0d82f3fa66 feat(workflow): typed park classification and split remediation budgets
The F2+F3 schema wave from the auto-fix/resume investigation, sequenced
together as one migration. Every failure funneled to one parked status
with free-text ParkReason, and Task.RetryCount doubled as the
operator-retry budget and the review-remediation round budget -- so N
operator retries ate the remediation budget, a repo-level round cap
could re-park a task an operator had just legally retried, and no
surface could answer what a park needed from an operator.

Park class (F2): a producer-recorded vocabulary in taskstate --
needs_human (the default, so an unclassified park always reads as
operator-actionable), transient (environmental; a requeue can succeed),
terminal (retrying is pointless). Recorded at the park site, never
inferred from reason text; NormalizeParkClass makes unknown values
persist as needs_human. Transition-to-parked defaults the class, so
every existing unclassified park site reads correctly with no call-site
churn; the classified ParkTask write follows for parks that know
better. Requeue, RetryTask and BeginRemediation clear the class back to
the default with the reason.

Split budgets (F3): Task.RemediationRounds is the remediation's own
budget; RetryCount stays the operator's. The round-cap stage counts and
caps rounds; operator retry keeps counting RetryCount and can drive a
task to dead without touching rounds. remediation_rounds is a
presence-gated migrator column written through Update.

Known state: proto fields, the ParkTask RPC, the staterpc mapping and
the daemon-side park-site classification follow in the wire half of
this wave (the proto parity test is intentionally red until then).
2026-09-23 12:55:03 +10:00
sam c347a2b80e chore(release): v1.39.0 2026-09-23 12:53:48 +10:00
sam 665ab9bce7 feat(daemon,forge): the review-reaction producers
Sequencing steps 6 and 7 of pr-review-remediation.md: the consumer
landed in e8d79b38, and these are the two sources that feed it.

Webhook (decision 2, low latency): the GitHub receiver decodes
pull_request_review and pull_request_review_comment events behind the
existing HMAC verification and publishes the same typed reaction the
poller produces, keyed source-independently so PublishUnique collapses
the two sources. Only submitted/created carry a verdict to remediate;
edited and dismissed are acknowledged. Reaction deliveries are
rate-limited per source (decision 6's 'add when the receiver gains a
second event family'), and the reaction path carries no dispatch
predicate -- eligibility is the consumer's owned-PR lookup.

Poll (both forges, the no-webhook backstop): one shared scan over all
pr_open tasks, each with the forge client its own identity owns
(reconcilePRs's shape), listing reviews and comments since per-task
persisted high-water marks and skipping the owning identity's bot user
(decision 5's own-comment exclusion, which the poll is positioned to
make identity-correct).

The cursors are two, not one: review IDs and comment IDs are independent
forge sequences, and a combined high-water mark would silently skip
reviews once a larger comment ID landed. watch_comment_id -- dead since
the comment-watch design it was created for never shipped -- carries the
comment cursor; review_cursor is a new presence-gated migrator column,
and SetReviewCursors is its guarded RPC (pr_open only, so cursors never
move under a run that owns the task). forge.ReviewComment gains ReviewID
so a comment is collectable into its review's unit (decision 5) on both
forges, and forge.Review gains Body so poll-delivered reviews carry
their summary.

Note: the store/proto/facade half of this work landed early in d296484a
under a release session's message -- a shared-checkout collision, kept
rather than rewritten; that commit carries the review_cursor migration
and the SetReviewCursors contract, this one carries the producers.
2026-09-23 12:41:53 +10:00
sam 46fd243b7f style(update): adopt the formatter's alignment in the watchdog test
task check's fmt pass rewrites this literal; the version committed with
the readiness-wait change predated that pass.
2026-09-23 12:30:10 +10:00
sam 6419adee14 fix(docs): derive the docsite artifact from the commit, not the working tree
docs:artifact:check regenerated the artifact from a directory walk of
docs/, which also sees an UNTRACKED page. The committed artifact then
looked stale and the gate demanded a regeneration that was already
correct -- one that would have committed a page belonging to no commit.
It cost two sessions in one day: a migration branch, and an unrelated
writer adding a PRD.

Enumerate through `git ls-files --cached` instead, so a page the commit
carries is required in the artifact and a working-tree scratch file is
not. The index counts as well as HEAD, deliberately: a page staged for
this commit is about to be carried by it. Outside a git work tree there
is no commit to disagree with, so the walk is kept and says so on stderr
rather than passing as the stronger guarantee.

Test fails against the walk with the gate's own message ("is stale;
regenerate it by running ...") and passes against the enumeration.
2026-09-23 12:29:29 +10:00
sam d296484a2f docs(agents): a bead never carries production instance detail
Beads sync to a Dolt remote, so anything written into one is published.
Two beads filed earlier today named an operator host, its internal
address and its filesystem paths -- the tracker was treated as a private
store, which it is not.

The rule is stated where the tracker is described, next to the existing
one about .beads/ never reaching a commit, because it is the same class:
the tracker is not a private store. Host-specific facts belong in the
operator's memos instance, which a bead may point at.
2026-09-23 12:29:29 +10:00
sam e8d79b3884 feat(daemon): wire the review-reaction consumer to remediate runs
The remediate workflow was registered but had no trigger: the reaction
stream was provisioned, the envelope, resolver and owned-PR lookup all
landed, yet nothing consumed the stream (pr-review-remediation.md's
sequencing left the consumer for this step). The daemon now drains the
reaction stream each cycle, before the task drain, so a reaction can be
claimed in the same pass that carried it.

Per decision 3, the store's owned-PR lookup is the authorization
boundary: an unmatched, merged or closed PR drops with a counter, and a
public reaction can never start an agent against a foreign repository.
Per decision 5, a review is the unit of remediation -- its comment
events are appended to the unit while it is queued and dropped once the
run is claimed (the round cap bounds the exchange); a standalone comment
is its own unit of one; approved reviews never remediate; and archie's
own comments, matched on the owning identity's bot user, are excluded so
its replies cannot retrigger it.

The guarded BeginRemediation/UpdateReviewPayload store methods are the
dedup: the pr_open -> queued transition carries the review unit in the
same write, so re-delivered reactions fail the status guard instead of
starting a second round. Both are new StateStoreService RPCs following
the Requeue shape, covered by the local/grpc conformance battery.
2026-09-23 12:08:44 +10:00
sam 5b30b92d46 docs(prds): approve the master-detail run page PRD
The maintainer approved task-run-master-detail.md after the
adversarial-review round; its status moves Draft -> Approved while the
work it describes is completed and verified.
2026-09-23 11:36:16 +10:00
sam 89839c3cb7 fix(webui): reset the stage filter on an attempt switch
A stage filter is a command scoped to the attempt it was made on: the
rail set it against that attempt's stage list. selectAttempt and
performRetry left filters untouched, so a stage selected on attempt 2
carried into attempt 1 -- a same-named stage there rendered as selected
without ever being commanded, or the log stayed narrowed to a stage the
new attempt does not have. The stage filter now resets when the selected
attempt changes; the level filter is attempt-agnostic and survives.

The master-detail PRD absorbs the adversarial review's verified findings:
the reload claim is narrowed to the URL contract (filters are not in the
URL), the unimplemented scroll and pinned claims are dropped, the
unnamed-stage and level-filter contracts are stated, the rail inventory
is corrected, and the acceptance list gains criteria for the
command-not-binding rule, attempt-switch reset, and keyboard selection.
2026-09-23 11:31:58 +10:00
sam d16b31d41e fix(webui): group live activity by payload, not by event kind
The first cut grouped consecutive same-kind events, but the real noise
shape is an interleave: one background cycle emits curator_run,
session-memory and curator_action events carrying the same payload, and
kind-keyed grouping left them all visible. The grouping key is now the
rendered detail plus the task, so one cycle of noise collapses to one
row regardless of which internal kind emitted each event, while events
carrying different information never merge. Verified against a live
daemon: 50 background events collapse to one expandable row.
2026-09-23 11:20:45 +10:00
sam 84947b260c feat(webui): split the task run page into a master-detail pane
The five tabs gave the stage rail less than a third of the screen and
disconnected the log stream from the stage that produced it. The stage
rail is now the page's master pane, always visible; the four context
panels are the inspector and own the tab bar. Selecting a stage commands
the inspector to the log tab with that stage's filter set; clicking the
selected stage clears it. Selection is a command, not a binding -- the
operator can change the filter afterwards.

No endpoint, RPC or contract changed. tab=stages still resolves, to the
log tab; every inspector tab and attempt deep-link survives a reload.
Below the shell's 900px frame breakpoint the rail stacks above the
inspector. Design of record: docs/prds/task-run-master-detail.md (Draft,
per-run panel contracts unchanged from task-run-detail.md).
2026-09-23 11:20:45 +10:00
sam de4ef19164 feat(webui): collapse runs of background telemetry in live activity
The feed's 50 raw events were dominated by consecutive same-shape
background rows (session-memory cycles, runner calls), which buried the
milestones the dashboard exists to surface. Consecutive events sharing
one label and one task now collapse into a group row with an xN badge;
expanding it reveals its events in place. The grouping is consecutive,
not global, so interleaved kinds keep their order and a milestone is
never merged with an event that merely shares its kind.

The projection is a pure view over the store's raw stream (activity-group.ts,
table-tested); the store keeps every event. Group rows keep ActivityRow's
link contract, and the disclosure button is stop-propagated inside the
first cell so it never fights the row-level link.
2026-09-23 11:07:14 +10:00
sam f90a1d6fe5 docs(skills): add archie-web-ui guidance for dashboard work
Carries the stack facts agents must not fight (token file, ui/dist as a
generated LAW asset, feature layout, UI gates), the operational-tool
design rules, the WCAG AA bar, and the rule that external design
prototypes are specs to translate, never code to port.
2026-09-23 11:05:58 +10:00
sam fde454d168 fix(webui): clear WCAG AA on info and subtle text tokens
The info token doubled as badge text on info-soft and as the log-level
label, and failed 4.5:1 there (4.29:1 dark over card, 4.45:1 over glass;
light theme 4.11:1 on canvas, 3.58:1 on its soft). Dark --info moves to
#B08BF8, light --info to #6F47A6, both clearing 4.5:1 on every surface
they land on. Light --fg-subtle moves to #675E6F for the wash-composited
canvas where the old value measured 4.44:1. Measured pairs recorded at
the token definitions.
2026-09-23 11:05:56 +10:00
sam fc52b09796 test(release): the runtime image is published for a tagged release, not only an archie/v* tag
TestDeployWorkflowOnlyPublishesRuntimeImageForRuntimeTag pinned the
per-component contract: the agent image builds only when an archie/v* tag is
at HEAD. One-stream releases create only a v* tag -- release.sh has no
archie/v* arm any more -- so that selector can never fire again, and the
agent image would never be rebuilt. `docker compose pull agent` would fetch
an ancient image forever.

The test's own subject is still right and is kept: the gateway build stays
unconditional and the runtime build stays guarded. The guard now names both
selectors, and the comment says why the legacy arm remains (history is not
re-tagged). Caught by CI, not by me: I changed the workflow and pushed
without re-running the gate on that tree.
2026-09-23 04:01:16 +10:00
sam 5a442b8eeb fix(release): teach the image job the one-stream tag
The one-stream change updated the changelog gate, release.sh and the docs,
but missed the image job. Measured on the v1.37.1 run: `gate` resolved
1.37.1 from the `v*` tag and then warned "No release tags at HEAD", while
`build-and-push` read only `archied/v*`/`archie/v*`, found neither, and fell
back to `dev+<sha>` for both components. It also skipped the archie-agent
image entirely, because that step was gated on an `archie/v*` tag being
present -- so a one-stream release would have published a dev-stamped
gateway and never rebuilt the runtime.

Three changes:
- version resolution falls back to the one-stream `v*` tag, so both
  components are stamped with the release version;
- the runtime image builds on a `v*` release as well, since one version
  covers the release; a legacy gateway-only release still skips it, which
  is what release_tag exists to distinguish;
- the "no release tags at HEAD" warning recognises `v*`, so a real release
  stops being told it is not one.
2026-09-23 03:51:36 +10:00
sam 8b5e71b15e fix(build): ship the one-stream changelog in the archied image
Dockerfile.archied still copied CHANGELOG.archied.md and CHANGELOG.archie.md,
which the one-stream release deleted. The image build therefore failed at
the COPY stage, so no images and no GitHub Release have been published
since the stream merged -- v1.37.1 failed the same way, and this release
failed with it.

Copy the single CHANGELOG.md the streams merged into. Verified by building
the image: the build completes and /usr/share/archie/CHANGELOG.md is
present and readable in the result.
2026-09-23 03:50:41 +10:00
sam 8c83f7d322 chore(release): v1.38.0 2026-09-23 03:36:31 +10:00
sam 0aa03811d5 merge(sams-cleanup): the PocketBase event-capture migration and its follow-ups
Moves event capture, mappings and bindings onto PocketBase-owned collections
in internal/infrastructure/edastore, and adds the read-only stateadmin
surface over the task database. Follow-ups included:

- the event feed cursor becomes a total order over a fixed-width timestamp
  with an opaque string cursor, so it no longer depends on rowid
  monotonicity;
- cron schedules get next-run arithmetic, so a cron job fires instead of
  returning ErrScheduleUnsupported;
- binding and mapping edits announce on the activity stream, so a dashboard
  edit is visible without a manual refresh;
- an unresolvable task identity fails closed rather than falling back to the
  root forge's credential;
- tool_call events project into the tool_calls collection, which had a
  schema and no writer.

Also: the branch is brought back to a passing task check, which it had not
been for the whole migration -- two pre-existing failures, an unrecorded
int64-to-string proto break and a stale generated docs artifact.
2026-09-23 03:33:49 +10:00
sam c963b8871b chore(fmt): adopt go fix's range-over-int in two loops
task check's fmt pass rewrites both, so the committed tree was not
fmt-canonical. Adopted verbatim, per the repository's rule that formatting
changes from the configured formatter are law.
2026-09-23 03:33:32 +10:00
sam fc9123aa9a merge(run/pb-toolcalls): project tool_call events into the tool_calls collection
Lane D. The collection existed in the event-capture schema with nothing
writing it; tool calls reached only the on-disk task log, readable as text
and never queryable.

The projection is a decorator on the State Store's task store, wired in
stateStoreDeps. InsertEvent persists the event first and only then, for a
tool_call event, writes one row. A projection failure is counted and logged
but never returned: event persistence is load-bearing, the transcript is
observability, and failing a task write because its shadow failed trades
the fact for the record of it. With no event-capture store the task store
passes through unwrapped.

The event adapts to the existing collection rather than the collection to
the event; args and duration_ms stay reserved. InsertToolCall stays silent
on the notify hook, matching the dispatch tables rather than the
operator-editable ones -- tool calls are high-frequency telemetry, not
dashboard activity.
2026-09-23 03:28:39 +10:00
sam 438a2c39ae feat(edastore): project tool_call events into the tool_calls collection
The tool_calls collection existed in the event-capture schema but nothing
wrote it. Give it its write path:

- edastore gains InsertToolCall and the minimal TaskToolCalls read, writing
  only the existing collection. No new index: the collection is an
  append-only transcript and the SQLite predecessor had no unique index.
- internal/app/archied composes toolCallProjectingTaskStore, a decorator on
  the task store that persists the event first, then -- only for tool_call
  events -- writes one row. A projection failure is counted and logged but
  never returned from InsertEvent: event persistence is load-bearing,
  tool_calls is observability.
- stateStoreDeps wires the decorator around deps.Tasks when both stores are
  open, and passes Tasks through untouched otherwise.

The event adapts to the existing schema, not the other way round: the tool
name comes from data, a succeeded call's detail is the row's result, a
failed call's detail its error; args and duration_ms stay reserved for a
producer that reports them.
2026-09-23 03:26:14 +10:00
sam dbbd918baa merge(run/pb-ident): fail closed on an unresolvable task identity
Lane B. A task naming a non-empty identity this daemon no longer knows --
renamed, retired or deleted in the control plane -- used to fall back to the
root forge's credential. It now parks, and a NATS intake carrying one is
rejected before it is enqueued. An empty identity is the single-identity
root and still resolves to root.

Validation lives at the intake producer rather than in a foreign key:
tasks.identity uses '' as the valid root sentinel, so an FK would have to
admit '' as well as a real id, and turning on PRAGMA foreign_keys to make it
bite would also start enforcing the identity_aliases/identity_subjects FKs
that are decorative today -- wider than this change.
2026-09-23 03:24:41 +10:00
sam 3ef409cda7 fix(daemon): fail closed on unresolvable task identity 2026-09-23 03:23:51 +10:00
sam 509402044f chore(docs): regenerate dev-docs.json for the artifact-sender PRD
04829b75 added docs/prds/artifact-sender.md without regenerating the
artifact, so docs:artifact:check failed at that commit. Generated from a
clean worktree at 04829b75.
2026-09-23 03:16:35 +10:00
sam 04829b75e2 feat(artifacts): publish the completed PR review to the collaborative editor
Implements docs/prds/artifact-sender.md (Approved). archie-core now sends
generated artifacts to the offloaded.dev collaborative editor, whose
POST /api/artifacts route, bearer service token, PocketBase-backed
versions and idempotency semantics are the receiving contract.

- [artifacts] config section: base_url + token SecretRef with a
  token_env fallback naming WORKSPACE_INGEST_TOKEN. An empty base_url
  disables the sender entirely; a base_url with an unresolvable token
  disables it with a warning, because a missing credential disables a
  capability rather than stopping the daemon.
- internal/infrastructure/artifactsync: one-method Publish seam in the
  Courier posture, full source per publish (versions of record are
  snapshots), 503 retried three times with backoff, 401/400 surfaced
  immediately with the field reason, deterministic request ids
  (artifact:pr-review:<owner>/<repo>#<n>).
- ReviewReport gains a pure markdown renderer in internal/domain/workflow:
  summary, one subsection per finding with the failure scenario and
  disposition when present, verified properties as a checked-clean list.
- The daemon's PR reviewer publishes after a completed review when the
  sender is configured, records the editor deep link on the result, and
  degrades a failed publish to a log line -- publishing never fails the
  producing work.
2026-09-23 03:15:27 +10:00
sam 8599fd627e fix(proto): keep EventsSinceRequest.since_id's wire name
The cursor change renamed the field to 'cursor' as well as widening its
type, which buf breaking flags as FIELD_SAME_NAME and FIELD_SAME_JSON_NAME
on top of the type change. The name buys nothing: the field is already
documented as an opaque cursor, and the number and name are the wire
identity. Adopt the gate's verdict and change only the type, keeping the
break confined to the one rule already recorded in proto/buf.yaml.
2026-09-23 03:12:48 +10:00
sam 7e0cb6675b merge(run/pb-cursor): generalise the event feed cursor to a total order
Lane A. EventsSince no longer relies on events.id being monotonic: it
orders by (at, id), where at is written in a fixed-width layout so
lexicographic order is chronological order, and id is only a
deterministic tie-break. The cursor crosses the wire as an opaque string
and rides the SSE id: field, so EventSource's own Last-Event-ID resume
keeps working untouched. A malformed or legacy cursor degrades to
"from the beginning" rather than failing the feed.

events.id keeps its int64 type and row-identity meaning; no
push/subscribe RPC is added.
2026-09-23 03:11:46 +10:00
sam 7530ec4231 feat(store): generalise the event feed cursor to a total order
EventsSince no longer depends on events.id being monotonic. The feed now
pages a total order over (at, id): at is a fixed-width, lexicographically
sortable UTC timestamp (storecontract.EventCursorLayout) and id is only a
deterministic tie-break for rows sharing one timestamp. The cursor is an
opaque string on the wire (EventsSinceRequest.cursor), carried verbatim as
the SSE id: field and echoed back via Last-Event-ID, so EventSource resume
needs no client change.

A new idempotent migration normalises pre-existing RFC3339Nano at values to
the fixed-width layout before finishTaskMigration, and idx_events_at backs
the new query. Legacy integer and garbage cursors degrade to "from the
beginning", preserving the old failed-ParseInt-yields-0 behaviour.

Amends the "Dashboard live event delivery" decision's cursor-cannot-skip
justification, which previously rested on commit-order id assignment.
2026-09-23 03:10:30 +10:00
sam 5ca499b366 merge(run/pb-eda-realtime): announce binding and mapping edits on the activity stream
Lane C. A successful binding or mapping write on the State Store's
PocketBase tables now emits one activity event on the same task-DB path
capture arrival already uses, so a dashboard edit is visible on the
activity stream without a manual refresh.

The event is an invalidation signal, not a payload: it carries the record
id and the action, and consumers refetch through the authenticated API. A
nil notifier is a silent no-op, so stores composed without one (tests,
tooling) are unchanged.
2026-09-23 03:02:41 +10:00
sam fa79e0f83c chore(docs): regenerate dev-docs.json after the architecture doc move
docs:artifact:check has failed on this branch since 0c8ba2a0 deleted
ARCHITECTURE.md and moved its normative content into docs/architecture;
the generated dev-docs artifact was never regenerated, so task check could
not pass. Regenerated from a clean tree (no untracked docs present).
2026-09-23 02:59:35 +10:00
sam 1b883f6e4b fix(proto): record the deliberate int64->string break from the PocketBase migration
The event-capture contract moved its record ids from the SQLite rowid
(int64) to PocketBase's string record ids in place, on the same field
numbers: 16 fields across CapturedEvent, Mapping, Binding,
RecordDispatchRequest, EnqueueBindingTaskRequest, Task.binding_id and the
Id-bearing request/response messages. buf breaking has flagged them since
that commit landed, so task check has never passed on this branch.

Both halves of the State Store contract ship from this repository
together, so they cannot be versioned apart. Record the break narrowly:
only FIELD_SAME_TYPE is relaxed, and only for state/v1/state.proto. Every
other FILE rule still applies to that file and no other contract is
affected.
2026-09-23 02:59:03 +10:00
sam 627b686a5d feat(edastore): announce binding and mapping edits on the activity stream
Each successful write on the State Store's PocketBase bindings/mappings
tables emits one event (binding_changed / mapping_changed) through a
nil-safe Notify func injected at composition, so a dashboard edit is
visible without a manual refresh -- the same task-DB event path capture
arrival uses. Nil notifier keeps every existing constructor silent.
2026-09-23 02:57:45 +10:00
sam dba811dfb2 docs(scheduling): pin the pocketbase AND of day-of-month and day-of-week
tools/cron ANDs the two day fields where Vixie cron ORs them, so
0 0 1 * 1 means Monday the 1st, not the 1st or any Monday. State the
deviation in the ScheduleCron comment and pin it with a test.
2026-09-23 02:56:27 +10:00
sam f46117b3e1 feat(scheduling): implement cron next-run arithmetic via pocketbase tools/cron 2026-09-23 02:53:39 +10:00
sam 89c074d213 feat(edastore)!: move event capture and bindings onto PocketBase collections
The event-capture tables (captures, mappings, bindings, binding_dispatches,
playbook_dispatches) now live in PocketBase-owned collections and their ids
are opaque record ids rather than autoincrement integers. The task lifecycle
stays on SQLite: tasks/transitions/events carry FIFO claim ordering, id-cursor
pagination and the task-grant map, none of which gain anything from being
hand-editable. binding_dispatches.task_id is the single seam and stays an
integer addressing that store.

BREAKING: CapturedEvent.Id, Mapping.Id, Binding.Id and Binding.MappingId are
strings on the wire, as are the ids in the capture/mapping/binding requests.
RecordDispatchRequest.task_id is deliberately unchanged.

What the collections buy, beyond storage: a payload nobody has modelled yet is
inspectable, a mapping is editable at runtime, and a binding's relation to its
mapping is enforced. The old schema declared no FOREIGN KEY on that link, so a
dangling mapping_id was previously possible and is now refused.

Behaviour preserved deliberately, each recovered from the SQLite version
rather than reimplemented from memory:
  - draft -> pending_approval -> armed, with approval only from
    pending_approval and an edit always returning a binding for re-approval
  - one binding per source, guarded on insert, update and approve
  - an empty secret on update keeps the stored one, so an edit form that does
    not echo it back cannot silently disarm a binding
  - ErrMappingNotFound / ErrBindingNotFound on a missing delete target
  - sentinels are re-exported from storecontract, never redefined: staterpc
    matches on exact canonical message to rehydrate them, so a second
    definition would break errors.Is across the wire invisibly

Two implementation notes worth keeping:
  - at-most-once dispatch is now a unique index rather than INSERT OR IGNORE.
    Only the unique-violation maps to ErrAlreadyDispatched; any other save
    error is returned, because treating them all as "already recorded" would
    turn the ledger into a silent at-least-once dispatcher.
  - captures store received_at themselves at nanosecond precision in a
    fixed-width layout. PocketBase autodates are millisecond and record ids
    are random, so same-millisecond captures would otherwise order
    arbitrarily; the old store got insertion order free from autoincrement.
  - ListUndispatchedCaptures is raw SQL: the anti-join is a subquery and
    PocketBase's filter DSL is not SQL. A read fires no hooks either way.

Adds tool_calls, which had no persistence at all: tool calls only ever reached
the on-disk task log, readable as text but never queryable or watchable.
Nothing writes it yet.

The binding secret cipher moves with the bindings it protects.
2026-09-23 02:19:28 +10:00
sam 42d87eefb9 refactor(scheduling): delete the legacy file-backed cronstore
The schedules feature no longer runs on it: jobs live in the state store
as the schedules control-plane document, read and written through the
control-plane client (scheduleResourceStore), and the legacy jobs.json
migration into that document has run its course. What remained of
internal/infrastructure/cronstore was 1,600 lines of file store, OS-level
cross-process locking and schema-versioned JSON envelope -- plus the
schedule vocabulary held hostage inside it.

The vocabulary moves to internal/domain/scheduling, which is where
migration-decisions already said a schedules vocabulary belongs: a domain
vocabulary package must not import infrastructure. JobSpec, Target,
Payload, the kind constants, Schedule and Duration move unchanged -- same
wire shape, same JSON tags -- with the two sentinel errors callers
matched outside the package (ErrJobNotFound, ErrScheduleUnsupported) and
ErrInvalidSpec, which the schedule arithmetic itself raises. The store's
own sentinels die with the store.

The legacy migration path (migrateLegacySchedules, readLegacyJobs) goes
with it: its only dependency was cronstore.Open, and its work is done.

crondelivery keeps its consumer-owned contracts; the compile-time
assertions that pinned *cronstore.Store move to the production
implementation, scheduleResourceStore, in internal/app/archied. The
package's fixtures swap the real file store for an in-memory one with
the same Get/MarkRun/Due semantics, so the run-recording acceptance test
still asserts against real schedule arithmetic.

A future storage backend (PocketBase) implements the same vocabulary.
2026-09-23 01:40:22 +10:00
sam 88bb707e7b feat(edastore): PocketBase-owned collections for event capture and bindings
First slice of the persistence migration, taking the event-capture tables
rather than the task lifecycle. These five tables hold no production rows and
their feature (archie-core-t2db) is unfinished, so they migrate at zero data
risk and the remaining work lands natively instead of being written against
hand-rolled SQL and ported later. They are also the tables that actually want
what PocketBase gives: inspecting a payload nobody has modelled yet, mapping
fields against it, and editing a binding at runtime are the epic's acceptance
criteria, not incidental conveniences.

The task lifecycle deliberately stays on SQLite. tasks/transitions/events
carry FIFO claim ordering, id-cursor pagination and the task-grant map, none
of which gain anything from being hand-editable. binding_dispatches.task_id
is the single seam and stays a plain integer addressing that store.

Idempotency moves from INSERT OR IGNORE on a composite primary key to unique
indexes, so the at-most-once ledgers are enforced by the schema rather than by
each caller remembering the pattern. A save that fails for any other reason is
returned rather than swallowed: treating every error as "already recorded"
would turn a broken ledger into a silent at-least-once dispatcher.

Adds tool_calls, which had no persistence at all. Tool calls were only written
to the on-disk task log (internal/logging), readable as text but never
queryable, filterable or watchable.
2026-09-23 01:27:34 +10:00