4f90b97a8642ce245e08d4513d9bbd7c6b93e708
228
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
6046aaf4c6
|
feat(daemon,forge): the review-reaction producers
Sequencing steps 6 and 7 of pr-review-remediation.md: the consumer landed in |
||
|
|
aac31b69ad
|
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. |
||
|
|
33e915c5be
|
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. |
||
|
|
b995eac1e1
|
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. |
||
|
|
a0d6cfbb28
|
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. |
||
|
|
e0becd525c
|
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. |
||
|
|
ba52a34d83
|
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.
|
||
|
|
2e1960dfe0
|
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. |
||
|
|
97f55793c4
|
feat(stateadmin): read-only operator dashboard over the State Store
Serve an optional PocketBase surface over archie.db from the process that already owns it, behind archie-state-store -admin-addr. It co-tenants on <db_path>-tasks.sqlite via PocketBase's DBConnect hook rather than opening a database of its own, so the single-owner ownership claim covers it and PRAGMA user_version stays archie's. Every archie table is exposed as a view collection, which is read-only by construction. Views alone do not hold that line: PocketBase also ships POST /api/sql, which executes write statements as well as reads, and /api/backups, which would put a second snapshot and restore semantics beside store.Backup's VACUUM INTO. Both routes are refused rather than left behind a superuser check, because a superuser writing task state is still a second writer. The gRPC contract remains the only writer. apis.NewRouter binds the JSON API but not the dashboard (apis.Serve mounts the embedded UI itself), so /_/ is mounted here and the caller keeps the listener. The dependency pin and the Taskfile/README changes for this landed with the preceding commit, which swept up the staged files. |
||
|
|
2a4e764718
|
refactor(indexing): delete the workspace codesearch indexer
The index built google/codesearch over the chat workspace on every daemon start, for the process lifetime, through a child-process helper and a SQLite metadata DB -- and grep consulted it only for searches confined to the workspace root, which the analysed sessions showed was a small fraction of searches. The compute was continuous; the benefit was not. Removes internal/indexing, the workspace-codesearch helper subcommand, the [indexing] config section, and the GrepIndex accelerator seam from the grep tool, which returns to its direct walk. google/codesearch leaves go.mod with it. |
||
|
|
5fa43b7e87
|
fix(messaging): render a tool call as one line with its own icon
A tool call rendered as a label line plus a ```text fence. Telegram draws a fenced block as a full code widget (language header bar, copy button, panel), and the block parser inserts a spacer paragraph before every block, so one call cost four rendered elements. Three calls filled the screen to show three word counts. Every toolPreview path already summarises to a single line, so the fence was never wrapping more than one. Drop it and put the preview on the header line. Tool lines now join with a hard break rather than a bare newline: a soft break would space-join them into one run-on paragraph, and a blank line would put the spacer back. Three calls are now three consecutive blocks. Two hardcoded values go with it. The status word is printed only when the outcome is not success, since every line otherwise read "done" and distinguished nothing. The icon is no longer a literal in the renderer: each builtin declares its own on tools.Tool (not on Schema, which is the model's contract), the provider carries it into ToolEntry, and the turn snapshots the registry's icons alongside its tool set. A tool that declares none renders without one rather than borrowing a generic wrench. Carries a dependency upgrade (go.mod, go.sum, tools/go.mod, tools/go.sum). |
||
|
|
60f04a351a
|
feat(curator): definition-driven engine with tool-carrying passes
Phase 1 of dynamic curator definitions (archie-core-trnd.1): - ToolBuilder implementation resolves declared tool names from the daemon's process-wide tool registry, returning exactly the declared set and failing closed on an unknown name. - curatorLLMRunner now carries ChatRequest.Tools and MaxSteps into core.GenerateOptions and widens ChatResult with the executed tool calls so a pass can attribute its actions. - One generic DefinitionEngine interprets a Definition (Manifest + name/enabled/instructions): its pass composes instructions with the built declared tool set, runs the model loop, and records an action per tool invocation. - [[curators]] config definitions carry the Manifest shape verbatim plus name/enabled/instructions; a definition missing interval is refused, never defaulted. - Idle curators are observable: the runtime logs a debug line when Check reports not-due. |
||
|
|
79f521b65b
|
feat(webui): let a person sign in and act as themselves
The last gap in the identity boundary: enabling a provider used to lock browsers out, because nothing could turn a sign-in into the credential the dashboard already verifies. Now a browser completes the authorization code flow with PKCE and the identity reaching the request context is the person who signed in. The audience is requested AT THE AUTHORIZATION ENDPOINT, not only at the token endpoint. Infra measured that a provider asked otherwise returns the audience empty, and this dashboard then refuses a perfectly valid token -- a failure that reads as a signing fault and is actually a missing query parameter. A test asserts the parameter is present, so it cannot quietly go missing. The flow is the libraries': discovery, the code exchange, PKCE generation and the challenge transformation are go-oidc and x/oauth2, so archie writes no protocol. The token returned by the exchange is verified through the SAME Verifier a presented token goes through, and the identity is then resolved through the same rule -- one Resolve now shared by Authenticate and the callback, so a browser sign-in cannot be accepted on terms a presented token would be refused on. Archie still issues no session. The callback stores the PROVIDER's token in an HttpOnly cookie and every later request re-verifies it, so what archie holds cannot outlive the provider's own decision. The callback checks the state it issued, and expires the state and PKCE verifier cookies on use. The sign-in routes mount on the bypass mux because they are how a caller becomes authenticated; gating them behind the credential they obtain would make signing in impossible. The client secret is never a flag: -oidc-client-secret-env names the environment variable holding it, so it cannot reach a process listing or a log line. No client id means no sign-in route and token verification is unaffected, which is what an agent-only deployment wants. Evidence, produced by driv·ng the flow rather than the seam: internal/webui/api_tasks_actor_test.go's TestBrowserSignInRecordsTheSignedInPerson walks sign-in -> callback -> cookie -> action and asserts the recorded actor is the signed-in person with human_approved. TestCallbackRefusesAMismatchedState asserts a replayed state is refused before any credential is verified. internal/infrastructure/oidc/flow_test.go runs the real flow against a test provider's own authorize and token endpoints, asserting the audience parameter, the PKCE challenge, a successful exchange, and a refused wrong verifier. Verified: task check exit 0 on this tree. |
||
|
|
8e4e353805
|
feat(identity): attribute a task action to the identity that acted
The transport could carry an actor and nothing filled it. It does now, so a dashboard approval is recorded as the person whose credential verified, and an agent's token is recorded as the agent's action -- for an agent, agent_approved; for a person, human_approved; and for a caller whose identity archie could not verify, task_approved, which claims nothing about who did it. The actor travels the path the action takes: webui reads it from the request context the middleware resolved, carries it in the gateway request, the daemon passes it through the in-process adapter, and the NATS request body carries it to the service that records it. Scope stays separate from actor at every hop, because scope is which task a caller may touch and the actor is who touched it. A chat channel's bound identity is an actor too: a bot acting on its own channel's task is recorded as an agent's action rather than a person's, via ActorFromScope, whose empty kind is what keeps it out of human_approved. The agent-facing task_action tool passes that identity and never input["identity"]. The UI process's credential check is now filled by endpoint references rather than by configuration: -oidc-issuer and -oidc-audience on archie-ui, two URLs the process already understands the shape of, with the verifier built in Run because cmd/ parses flags and nothing else. The UI package still never reads config, and a configured provider that cannot be reached fails boot rather than falling back to the gate that names nobody. Evidence for this change, stated as measured: go build ./... and go vet ./... are clean, and every package this touches passes -- webui, domain/taskactions, infrastructure/taskactions, infrastructure/gatewayrpc, gateway, app/archieui, app/archied, domain/messaging, channels/telegram, cmd/archie-ui. task check could not be run to completion: it fails in cmd/archie-messaging on an untracked internal/buildinfo package another lane has in flight, which is not this change and was left untouched. The end-to-end flip is covered in internal/webui/api_tasks_actor_test.go: a person's credential produces a record naming that person with human_approved, an agent's produces agent_approved, an unverified request produces task_approved with no actor, and a request carrying forged actor fields cannot name one. |
||
|
|
9dc1a085c8
|
feat(webui): verify a provider credential on a request path
The verifier was a library nothing called. A request now carries a credential or is refused: webui.Server.Authenticate resolves a presented bearer token to the identity that may act, and requireIdentity attaches it to the request context. With a provider configured that check replaces the shared token, so every request resolves to a named identity or is refused; with none, the shared-token gate stays for a loopback instance. Nothing about the caller is read from the request. The subject comes from the credential the provider signed and the identity is the record that subject is bound to, which is what makes attribution possible at all: a caller cannot assert who it is, it can only present what the provider gave it. A test sends an X-Archie-Identity header and an actor field in the body alongside a valid token and asserts the resolved identity is still the credential's. Refusals follow HTTP's own distinction: absent or unverifiable credentials are 401 and name the scheme, while a credential that verified for an identity that may not act is 403. Each is covered, because a refusal path with no test is a path nobody has watched refuse. The two state-store RPCs the dashboard needs to resolve a subject exist: ResolveIdentitySubject and BindIdentitySubject, with the client implementing identity.SubjectBinding (a narrower contract than Repository, so the administrative facade keeps its shape) and the server answering Unavailable rather than pretending when a process has no binding store. chat.proto carries the actor for the next step: actor_id, actor_kind and principal_id on ApplyOperatorTaskActionRequest, regenerated here. The transport can now carry an attribution and nothing fills it yet, which is why the dashboard still records task_approved rather than a human attribution. Not wired in production yet, and worth stating plainly: dep.Authenticate is a seam nothing sets, because the dashboard is served only by the UI process and that process is documented to take endpoint references only -- there is deliberately no config.Config in it. OIDC settings must therefore arrive as flags there, which is an existing design boundary I did not want to cross unilaterally. config.Oidc exists so the daemon-side wiring has somewhere to read from. Verified: task check exit 0 after this commit; focused webui run records the resolution and all four refusals. |
||
|
|
a7d6f71d5a
|
feat(identity): verify provider tokens and attribute task actions to their actor
Two halves of one boundary: a credential resolves to an identity, and an action records which identity acted and whose authority it used. resource server. internal/infrastructure/oidc verifies a provider-issued bearer token against the provider's published keys, using an OSS OIDC library: archie compares no signature, validates no claim and rotates no key itself, holds no client secret and issues no session, so a compromised archie cannot mint an identity. Audience is required rather than optional -- a token minted for another service must not authenticate here -- and discovery happens at construction, so an unreachable provider is a startup failure rather than a request-time surprise. identity.Authenticate is the single place a credential becomes an identity, and it refuses in four distinguishable ways: no credential presented, a credential that did not verify (wrong key, expired, wrong issuer, wrong audience, malformed), a verified subject with no identity bound to it, and an identity that may not act. The order is deliberate: verification happens before any field of the token is used, so nothing an unverified token carries can select an identity. A suspended identity is refused even though its credential verified, because suspension is archie's decision and must not depend on the provider withdrawing a token. The binding is the second bridge beside the legacy-name alias: identity_subjects keys (issuer, subject) so the same subject string from another issuer is a different caller, and rebinding moves a subject so two identities can never claim one provider subject. The contract Authenticate needs is SubjectResolver, narrower than Repository, so a consumer that only authenticates does not take the whole identity CRUD surface -- and staterpc.Client, which asserts Repository, does not need a new RPC to satisfy it. attribution. taskactions now records two identities per action: the acting identity and the authorising principal, both on the event row as new columns added through the existing migration table. The rule that the bug turned on is enforced by the event kind describing the actor: a person's approval is human_approved, an agent's is agent_approved, and an action with no verified actor is task_approved, a task-level event that credits nobody. An agent acting under a person's standing approval records itself as the actor and that person as the principal, so "approved by came from me" is answerable from the record rather than asserted. Scope and actor are separated: scope decides which task a caller may touch and is never promoted into an actor, because the dashboard's credential is a shared token and possession of it is not evidence that a person was at the keyboard. That last point is a deliberate fidelity trade, and the reason the transport is not wired: the dashboard action path passes no actor yet, so dashboard approvals are now recorded as task_approved rather than claimed as a human's. Recording nothing false is the requirement; naming the human verifiably needs the dashboard to authenticate a token and resolve it, which needs two new state-store RPCs (ResolveIdentitySubject, BindIdentitySubject) -- the next piece, not a rewrite: the verifier is a one-method interface, so introspection would be a second implementation of it. Verified: task check exit 0; focused runs recorded in the handoff. Opaque authelia_at_ tokens were inspected rather than assumed and cannot be verified against public keys; infra is configuring access_token_signed_response_alg RS256 on the archie client, with audience https://archie.catlow.cloud and issuer https://auth.catlow.cloud. |
||
|
|
85a671491f
|
fix(eda): tie module results to checker and tighten action ids | ||
|
|
826f87e414
|
feat(eda): wire action playbooks through loader and module schemas
Pass 2 of archie-core-nx30. Pass 1 typed each prior action's result in
the CEL env; this pass wires that typing through the loader, module
schemas, and daemon, and removes the now-redundant id classifier.
Loader shape (D2): one playbook is exactly one workflow action
(unchanged) OR one or more module actions; the shapes never mix. Mixed,
unsupported, or zero actions fail the load naming the playbook.
playbook.Load now takes a KindSchemas source (a small interface this
package defines, satisfied by *module.ModuleRegistry) so playbook grows
no module import. Callers: bootstrap.loadEDAPlaybooks passes b.modules;
daemon and playbook tests pass module.New().
Per-playbook env (D3): each action's when and args values compile against
an env built from the PRIOR actions' ids typed by their kinds' Result
structs (expr.NewEnv(DeclaredResult{ID,Type})). event stays dyn. An
undeclared id, a forward reference, or a field the kind's Result lacks is
a compile-time undefined-field error.
Args schema (D4): an args key the kind's Args struct does not define
fails the load. An args VALUE whose compiled type mismatches the field
type is left as a named gap (not cheap without leaking cel-go type kinds
into playbook and handling dyn reads); a wrong-typed value still surfaces
at module invoke, not load.
D1: Store.Dispatch routes workflow playbooks only, so an action playbook
cannot hijack the definition pin. bootstrap.loadEDAPlaybooks logs a
visible Warn (not debug) for each loaded action playbook naming it and
stating it does not execute yet.
D5: ModuleRegistry.Invoke is deliberately schema-agnostic (the stored
invoker is type-erased and returns map[string]any). The map-to-Result
marshalling belongs in the coordinator named by the doc, which is the
t2db.31 run path and out of scope here.
Classifier enumeration (E) and verdict, all proven for a typed action
playbook via CEL (expr.NewEnv with a declared log.Result id):
unknown id CEL compile (undefined field) -> delete unknownActionReference
literal map index actions["x"] CEL compile (no _[_] overload) -> covered
computed index actions[key] CEL compile (undeclared 'key') -> covered
dynamic index actions[event.name] CEL compile (no _[_] overload) -> covered
"x" in actions CEL compile (no @in overload) -> covered
size(actions) CEL compile (no size overload) -> covered
actions.all(...) CEL compile (not a range) -> covered
actions == {} CEL compile (no _==_ overload) -> covered
bare actions compiles; KEPT classifier -> retained resolvable check
unknownActionReference is deleted; actionReferences/ActionReferences are
kept solely for the bare-actions spelling CEL does not reject.
|
||
|
|
b703c3663b
|
feat(messaging): route a channel reload, and refuse one that cannot reload
archie-core-np7l's service half -- the reload action and its truthful refusal. The request surface that carries the instruction from the dashboard is its own change, because it is its own object with its own lifetime (the reasoning is recorded in docs/architecture/migration-decisions.md). Service.ReloadChannel routes to the channel's own seam rather than reimplementing it: the telegram front-end re-reads its token and allowlist, which is what its own /restart path calls. A channel that cannot reload is refused with a reason instead of accepted and ignored, because the dashboard offers the action on the strength of the capability the descriptor declares, and an accepted-then-nothing reload is a lie the operator cannot see through. The capability and the action now come from one source. Before this a descriptor declared ReloadSupported by NAME, so a channel could announce reload support and have nothing behind it; reloadable() decides both, and the descriptor test builds a real gateway with a seam rather than a fake named "telegram". Verified: task check exit 0. Coverage: the refusal names the reason for a channel that declares no support and for an unknown channel; the service reaches telegram's own reload seam and the re-read config lands; and the declaration and the action cannot drift, which is asserted by reloading every composed channel and requiring the refusal specifically to be "does not support reload" -- a declared reload may still fail on the configuration it re-reads, and that is a different fact. |
||
|
|
96aa05c470
|
fix(archieui): let the boundary guard permit a contract-backed channel reader
The UI boundary test forbade wiring Server.Channels, and it was right about what the field used to hold: a live *status.Manager is a runtime handle this process has no business owning. It now holds a reader over the State Store's channel-status contract, which is the same shape as the Mappings, Bindings and ApplyStatus fields the guard already expects to be wired. The distinction it draws is the handle, not the name, so the assertion moves with the field and says why. Also adopts task fmt's rewrite of the reader's status construction: go fix drops the explicit embedded Descriptor, and formatter output is law here. |
||
|
|
d6f526ce4f
|
feat(state): carry channel lifecycle from the Messaging Service to the dashboard
archie-core-8cda.6.8's carrier. The service now records channel lifecycle and has nowhere to put it: /api/channels answered with nothing because webui.Server.Channels had no production source, and reload answered 501 for the same reason. This adds the surface the register decided on, following the split archie-core-ymut established for config snapshots -- a pair of administrative RPCs whose writer is one process and whose reader is the UI -- and wires both ends. Wire and store: PutChannelStatus / ListChannelStatus, with ChannelStatus carrying id, name, state, detail, configured, reload_supported and observed_at. The store holds one row per channel and replaces the reported set, so a channel the reporter no longer mentions is deleted rather than left standing as a stale "running"; an empty report clears the table, because hosting no channels is a fact worth reporting. A row without an id is refused: it could never be replaced or removed by a later report. Writer: the service publishes on every lifecycle transition through a coalescing signal -- a burst of transitions is one write, since a reader only wants the latest state of every channel -- plus a start-up report and a final report after shutdown, so a stopped service leaves the store honest. A failed write is logged and retried on the next signal; the dashboard losing channel state is worth a warning and never worth failing a channel start over. Reader: webui.Server.Channels becomes a source rather than a concrete manager, and webui.RemoteChannelStatus reads the store the way RemoteConfigView reads the config snapshot. A store it cannot reach reports nothing rather than a stale "running", and a state the reader does not recognise is carried through rather than dropped. The contract's own index gains the group in the same change that adds the RPCs -- a surface the grouped table does not list is one nobody finds -- and the count moves to 51. The register records why the surface is the State Store rather than a resource kind, and why reload gets its own surface rather than a field here: reading status must not be able to retrigger an action, a transient request is not distinguishable from state once anything polls it, and it would invert the writer/reader relationship the precedent establishes. Verified: task check exit 0. New coverage: the store's replace-the-set semantics and its refusal of an id-less row, the reader's mapping including an unknown state, and the publisher's start-up, transition and final reports. |
||
|
|
fb265f2ad0
|
feat(messaging): record channel lifecycle, and decide its surface
archie-core-8cda.6.8's producer half. The service handed every channel an empty
channels.Lifecycle{}, so starting, running, failed and stopped were recorded
nowhere and internal/channels/status.Manager -- which has had MarkStarting,
MarkRunning, MarkDegraded, MarkFailed, MarkStopped and Snapshot all along -- had no
production writer at all. The channels have always reported: all three call
ReportStarting and ReportRunning on whichever lifecycle they are given.
Each composed channel now gets its own report into a manager keyed by channel, so
one channel's failure marks only itself; a channel that cannot start is marked
failed with its reason rather than only logged, and a channel that returns is
marked stopped. Service.ChannelStatus is the producer a dashboard surface reads.
Left open deliberately: the cross-process carrier, and reload's direction.
docs/architecture/migration-decisions.md records the shape by the precedent the
contract already establishes -- archie-core-ymut's config snapshot is "the one
surface whose writer is the daemon and whose reader is the UI process", a pair of
administrative RPCs deny-by-default under authorizesTaskScopedCall -- and names
what that settles: channel state is runtime state rather than a settings document,
so it does not belong among the ControlPlaneService's validated resource kinds; the
UI already dials the State Store and pumps its cursor, so no new transport is
needed; and the contract PRD's grouped table gains a group in the same change that
adds the RPCs. Reload runs the other way and is left as a named open question
rather than decided by analogy with a status report, because a request queue and a
status report do not have the same lifetime. It also records that 8cda.6.9's
component self-report is the same shape, so the two do not become two homes for
"what a component reports about itself".
Red-proofed: restoring the empty lifecycle fails TestServiceRecordsChannelLifecycle
with "channel webhook never reached running; last report State:configured", so the
test pins the fix rather than the manager's existence.
Verified: task check exit 0.
|
||
|
|
fa1840e646
|
test(messaging): add the end-to-end channel smoke verification
archie-core-8cda.6.5's remaining half. The gate landed in a7d6cc8c; what was
missing is the verification that the extracted service actually carries a message.
It drives the deployed path -- compose, the real webhook adapter, a real listener,
a real signed HTTP request -- and asserts on what crossed the chat contract as well
as on the reply the caller receives back, which DeliverTo=origin routes through
that contract. The envelope assertions are the three transport facts this channel
must carry, each of which has a reason recorded elsewhere: platform "webhook" is
how the Gateway learns which channel it serves (archie-core-c1qx); SenderID stays
empty because a route path is a source and never a person (archie-core-oyna); and
the route survives as the budget key, so the inbound limit still applies.
Webhook is the only channel a test can own. Telegram needs a bot token and the
Telegram API, email needs SMTP, so neither can be exercised here. The PRD's fourth
criterion asks for a live Telegram round trip "or equivalent channel smoke test",
and this is that equivalent: every step between the POST and the contract is the
deployed code path. The gRPC hop beyond the contract is covered by
internal/infrastructure/gatewayrpc's conformance tests, which run the same client
and server in both local and remote mode.
Red-proofed rather than assumed: signing the request with the wrong secret fails it
with "status = 401, want 200", so the signed path is genuinely exercised rather
than bypassed.
Also carries
|
||
|
|
a7d6cc8c9d
|
refactor(messaging): sever the Messaging Service from the store and workflow runtime
The PRD's deletion gate for the Messaging Service could not pass: go list -deps ./cmd/archie-messaging linked modernc.org/sqlite, internal/store, internal/domain/workflow and internal/agentexec -- all through one import, archiemessaging/run.go -> internal/app/controlplane, from which the service used three symbols. The decision was to sever rather than amend the gate, because a boundary you whitelist around is no longer a boundary (archie-core-1ng1, recorded in docs/architecture/migration-decisions.md). Measured before touching anything: internal/app/controlplane was the ONLY direct import of the service that dragged those runtimes -- every other one was clean -- so severing this one dependency is sufficient for the gate. Moved into the new internal/infrastructure/controlplanerpc: the generic resource client (NewRPCClient, Query), the RuntimeChatConfig projection, the reader interface (now the exported ResourceReader), the wire sentinels, the status mapping (now ClientError), and the channel-settings document with its decode -- ChannelSettings, TelegramSettings, WebhookChannelSettings, EmailSettings, RateLimitSettings, ChannelDuration, DecodeRenamingLegacyKeys. internal/app/controlplane keeps the store-backed server, the Definition registry, every kind's seed/validator/Normalize, the schema derivation, and its resource-specific reads and watches. Its Client embeds the new one, so the read path has one implementation while the workflow, persona and cronstore reads stay with the processes that already link those engines. The documents are type-aliased back into this package so the store-backed side reads them by the names it has always used: one definition, not a copy on each side of the boundary. The gate is now enforced by cmd/archie-messaging/architecture_test.go, measuring the linked binary against the PRD's banned list, with one exception checked in both directions: internal/domain/workflow/task, the Task status and view vocabulary whose own dependency set holds none of the banned runtimes. The UI gate carries the same entry for the same reason, and the fleet skill names it as the precedent. Verified: task check exit 0. The gate was red-proofed twice -- banning internal/channels fails it, and removing the workflow/task exception fails it -- so neither the loop nor the exception is decorative. |
||
|
|
e10a05933a
|
feat(eda): evaluate action args as CEL expressions (J2) | ||
|
|
39ba283e47
|
test(eda): pin playbook dispatch ledger docs and regression gaps | ||
|
|
3be7e4cdb0
|
fix(eda): wire playbook dispatch ledger and validate its key | ||
|
|
3cdaba2509
|
fix(gateway): stamp the session platform from the channel that carried the message
One Router serves every channel and named itself "web", so Source.Platform -- the FIRST component of the session natural key, and the platform GetByChannel filters on -- was a constant, true of no channel but the dashboard. Two consequences followed: the per-user identity policy was real code that no production call site reached with a real channel name, and a curator pass's write to agent-user memory could not be read back by the turn that wrote it, because that turn resolved no UserID. The channel now travels with the message. Frontends name the channel they carry (pb.Message.platform: telegram, email, webhook, web), and the Gateway stamps the session from it, falling back to its own name when a sender names none -- which is what every existing row holds and what a frontend that does not participate keeps doing. Identity resolution reads the platform off the inbound rather than closing over a channel name, so carriesPersonIdentity finally decides something in production: telegram and email resolve a person, the dashboard and a webhook resolve nothing, and an unknown platform fails closed. Deliberately NOT changed, because it is where this could quietly widen scope: TurnRunnerConfig.Channel still keys tool availability, so no channel gains or loses a tool here. Only session lookup and identity follow the message's platform. Consequence the maintainer accepted: a chat whose active session came from /new or /branch re-resolves once, since GetByChannel now filters on the channel's name. A chat with no /new re-resolves onto the same deterministic session id and heals silently. Verified: gateway, archied, gatewayrpc, messaging, webui, channels and cmd suites, go vet ./..., go build ./..., golangci-lint run ./... (0 issues), docs:check. New contracts: TestResolveSessionKeyStampsTheMessagesPlatform, the per-platform identity table, and the transport-context wire round trip. |
||
|
|
84450ac96c
|
fix(cronstore): write a schedule interval as a duration, not nanoseconds
The schedules document stored interval as a bare time.Duration, so its JSON was
the nanosecond count -- 1800000000000 for thirty minutes -- and the Web UI, which
now derives field metadata from the document type, correctly rendered a number
input. Same defect 02rm fixed for rate_limit.window, in the second stored time
this tree has. Nobody should be asked for a count of nanoseconds to configure a
schedule.
cronstore.Duration writes the string time.ParseDuration reads and reads that, a
nanosecond count, and nothing else: every schedule stored before this shape
existed carries a count, in both the control plane's schedules resource and this
package's own jobs table, which persists the spec as JSON. A value that parses as
neither is refused rather than decoding as zero, because a zero interval is a job
that never fires.
The derived schema needed no change and gets it for free -- which exposed a fix
the derivation itself needed: it classified durations by NAME, so cronstore.Duration
derived as an integer. durationLike now asks the type instead -- does it expose the
standard duration, and does it marshal as a quoted string -- so the next duration
type is classified correctly rather than silently rendering as a number box. That
failure mode was invisible until a live daemon showed it.
normalizeSchedules already re-marshals, so a stored document converges on its next
write while reads keep tolerating the count.
Verified: cronstore, crondelivery, controlplane, scheduling, webui and archied
suites, go vet ./..., go build ./..., golangci-lint run ./... (0 issues),
docs:check. Against a live daemon (8484): the catalog serves schedule.interval as
{type: string, format: duration}.
|
||
|
|
7a8bb8e47b
|
docs: drop one host's service names from port guidance
Five files named a specific host's service and the port it holds as the reason a deployment might move the state store's listen address, including config.example.toml, which ships to every operator. The guidance keeps its point -- move the listen/target pair together when a port is already taken on the host -- without naming a service the reader may not run, or have heard of. Also corrects the Taskfile's dev-stack summary, which still described the state store as binding 127.0.0.1:9090. deployments/dev.toml pairs it with 9091, and has since the pair became configurable, so the comment described a stack that does not start. |
||
|
|
b5050c7560
|
test(controlplane): pin a bare time.Duration as an integer, not a duration
schemaFixture covered config.Duration and channelDuration, both of which marshal as the string time.ParseDuration reads, but not a bare time.Duration, which marshals as its nanosecond count. The derivation already distinguishes them by named type rather than by kind; this pins it, because the failure mode is a client rendering a text box for a number, and the schedules document has exactly that field (cronstore.Schedule.Interval). |
||
|
|
a86b41f3ee
|
chore(controlplane): adopt go fix's rewrites in schema.go
task fmt is not a formatter: it runs go fix to a fixpoint and then
golangci-lint's formatters, so a package can be gofmt-clean and still
go-fix-dirty. The merge train's full gate on
|
||
|
|
a19cd24b83
|
feat(controlplane): derive resource schemas from the documents they describe
Twelve definitions each advertised a bare {"type":"object"} or {"type":"array"},
so no resource descriptor carried a single field: the Web UI had nothing to
label, describe or format a field with, and the one component that parsed a
schema was dead code. The constants could not be kept honest either -- a schema
written beside a struct drifts the moment a field is added, and nothing compares
the two.
Definition now names its document type and Descriptor derives the schema from it.
json tags give the keys, falling back to the Go field name because that is what
encoding/json stores; the Go type gives type and format; and a field's own
title, format and doc tags override. A duration is a string with format
"duration", which is how every duration field in the catalogue -- poll_interval,
max_uptime, rate_limit.window -- gets a client-side affordance from one rule
instead of twelve hand-written ones.
Deliberately structural: it emits no prose of its own. Field descriptions already
have one home (internal/webui/config_schema.go, keyed by dotted config path), and
a second would be two places to keep the same fact true. It also never emits
"required", because an empty string is legitimate for nearly every field here --
a blank workspace, a disabled rate limit -- so requiring most of them would
invite a client to enforce something the document does not mean.
Guarded by TestEveryResourceDescriptorDerivesProperties, which walks the catalogue
the production constructor builds and fails if any kind describes no fields --
the assertion that would have caught all twelve. It accepts a keyed collection's
additionalProperties as described, because a map document has no fixed keys.
Verified: controlplane, workflow, webui, archieui and staterpc suites, go vet,
go build ./..., golangci-lint run ./... (0 issues), docs:check.
|
||
|
|
ca433865b0
|
fix(archied): build the Gateway's worktree manager so it serves review_pr
boot.prReviewer returns nil without a worktree manager, and a nil reviewer omits review_pr from every channel's tool set. RunGateway never called buildTreesAndIdentities, so the Gateway resolved a nil reviewer and no channel could review a PR. Extract the manager's construction into boot.buildWorktreeManager, called by buildTreesAndIdentities (daemon, unchanged field-for-field) and by startGatewayRuntime before setupGatewayChat. The Gateway does not call buildTreesAndIdentities: that also registers daemon identity runners the Gateway must not own, and PR review only needs a clone of the PR head, which worktree.Manager.CheckoutPR does from the forge. Pin the ordering by source position in composition_order_test.go, alongside the memory-engine ordering the same function already carries, and pin both compositions behaviourally in worktree_manager_composition_test.go: the Gateway's step must yield a reviewer that advertises review_pr, and the daemon must still build its root manager plus one runner per identity with a distinct WorkDir. Correct docs/prds/operator-pr-review.md, which still asserted the daemon supplies ChatPRReviewer and holds the review in-flight set. |
||
|
|
092194cd5d
|
fix(controlplane): give the channel document its own shape
The channel-settings resource embedded internal/config types directly, so the document the Web UI edits was a JSON projection of TOML-tagged structs: encoding/json fell back to Go field names, and rate_limit.window was a bare time.Duration. An operator saw "Window" over a field expecting a nanosecond count -- 60000000000 for the window = "1m" the file example writes -- and "ListenAddr" over the email addresses, while every sibling resource in the same registry is snake_case. Define the shape here instead: emailSettings and rateLimitSettings with explicit tags, and channelDuration, which writes the string the file accepts and reads that, a nanosecond count, and the Go-cased keys an existing store holds. Reading a legacy document is deliberate, so it stays strict about everything else. decodeRenamingLegacyKeys renames the four known legacy keys and keeps DisallowUnknownFields, because swallowing an unknown key decodes as "unset", and an unset rate limit is off -- the failure this shape exists to end. A misspelling is refused. normalizeChannels, through the Definition.Normalize hook schedules already uses, rewrites a legacy document into the current shape on write, so a stored document converges the next time it is saved. Reads tolerate it until then, so no deployment has to re-save before the document can be read. Verified: the controlplane, messaging and configuration suites, archied (the loadRuntimeConfig consumer), go vet, go build ./..., golangci-lint run ./..., and docs:check. The full task check is the merge train's, on this tip. The same audit found container-runtime-policies embedding config.ContainerConfig (seven fields, no json tags); tracked separately rather than folded in here. |
||
|
|
2eeef60b31
|
feat(archied): report systemd readiness and loop-driven watchdog heartbeats
archied now speaks sd_notify(3): READY=1 at the moment the process declares itself serving, and WATCHDOG=1 heartbeats while the run loop's own progress marker is fresh. The heartbeat is licensed by that marker (daemon.LastPollAt, stamped at the start of every poll pass) rather than by an independent ticker, so a loop wedged inside a pass stops being reported as alive and trips the unit's watchdog. The protocol is three environment variables and one datagram per state, so it is spoken directly with net.DialUnix instead of through a new dependency. Without NOTIFY_SOCKET nothing is sent, nothing is logged, and startup is unaffected. |
||
|
|
1fe4691bd6
|
fix(webhook): keep a route path out of the sender identity
A webhook set SenderID to its configured route path. The turn path reads that field through a per-channel resolver which refuses webhook, but the session curator derives its participant from the raw field with no channel filter, so a webhook session with exactly one distinct sender and one extracted fact wrote agent-user memory addressed to User: "/hooks/...". Nothing reads it, and every pass added more, because the facts are identical strings with no dedup. docs/prds/memory-engine-unification.md criterion 7 requires that a route path never become a user identity. Clear it at the producer rather than teaching every consumer which channels are lying: a route path is a source, not a person, so it no longer enters SenderID. It still keys the inbound rate limit, where it is the documented per-source budget for webhooks (config.RateLimitConfig), so it travels in the new transport-only Inbound.BudgetKey -- carried on the wire beside Page, never persisted, and never read as an identity. pb.Message gains budget_key (field 9) for the same reason page (field 7) exists: transport context that rides with an inbound message and is deliberately absent from storedProto's rendering of a canonical record. The curator needs no change. An empty SenderID already fails closed as an unidentified user message, which is the path a dashboard session takes, and sessionParticipant's existing skip covers it; the test name now says so. |
||
|
|
a4e7bccaba
|
docs(archied): correct the watch loop's claims and pin the boundaries
Three claims the reconnect loop records were false, and one boundary was unpinned either way. The claim that a store which "stalls until its read times out" is charged and climbs the ladder described a timeout this code does not impose: nextUpdate waits on the stream and the loop's context, and never on a clock, so a peer that accepts the stream and then never answers it ends nothing here and is charged by nothing here -- a probe held the read open for 2s with no retry logged at all, and the attempt that finally ended was read as healthy. What ends that stream is the transport's client keepalive on internal/infrastructure/staterpc/dial.go (Time 10s, Timeout 5s), which the watch rides because bootstrap takes its control-plane client off the *staterpc.Client that dial returned. The comment now states that, names the file, and states this loop's own boundary: it charges only attempts that END. "The rule reaches every shape" was false for the shape it was argued from. The window is derived from the delay the attempt would be charged (four times the minimum at the minimum rung), so a stall at or past it -- 1s and 1.1s were measured -- is read as a store that answered on every attempt and pins the ladder at 250ms, against [250ms 500ms 1s 2s] at a 500ms stall. The comment now says the reach stops at the window, and why that is deliberate rather than a gap to close: the stalled attempt lasts the window, so those reopens are under one a second against the four a second the rule exists to charge. TestKeepWatchTreatsAStallPastTheWindowAsAStoreThatAnswered pins it, at a five-minimum stall against the four-minimum window (widening the window past the stall fails it). The rule's sentence said "outlived a window", which the operator (>=) does not mean, and a verification pass confirmed >= -> > survived the whole package. The comparison stays inclusive and the sentence now says so: an attempt still open when the window closes is a store that answered. The load-bearing inequality is the other one -- the window is a strictly wider multiple of the charge, so a store that fails as slowly as the charge is still charged -- and TestAttemptHealthyAtTheWindowBoundary pins both edges at every rung: equal to the window is healthy, a nanosecond inside it is charged. TestKeepWatchChargesAnAttemptThatEndedWithNothing's window case now stands open past the window rather than for exactly it: its sleep starts before the loop's attempt does, so an attempt measured against it could be judged a hair early, and the exact edge is pinned without a clock by the new unit test. TestBothWatchStreamsRunThroughTheReconnectLoop asserted only that the name keepWatch appeared, so a launch site handing the loop a wait of its own was invisible -- the persona site's wait has no behavioural test at all. It now reads the wait argument of each keepWatch call (changing it fails the test, and nothing else in the package does). No upper bound was added for the wait itself: the injection seam replaces the wait in every test that drives the loop, so a bound on waitFor's own duration would have to be a wall-clock one, and the correct code overshot a 25ms timer to 65ms on a saturated 16-CPU box (169/200 samples over 1.5x, 8/200 over 2x), which is exactly the flake a bound tight enough to catch the 2x mutation buys. The wait doc states what the injected wait can and cannot show. |
||
|
|
b8ec491dd3
|
fix(archied): re-establish the control-plane watch streams after they end
The settings and persona watches were launched once, at boot, and ended on the
first stream failure: the goroutine returned, so every later stored change for
that kind was silently never applied and the process recovered only by
restarting (archie-core-yrmr).
Both watches now run one keepWatch goroutine per kind, which re-establishes the
stream in place after a bounded backoff, resuming after the last version an
update carried and stopping on ctx cancellation -- which the loop watches for
itself, so a stream that never closes cannot hold up shutdown. A first open that
fails still fails the boot that asked for it.
The reconnect delay is decided by the attempt that just ended, and only by that
(attemptHealthy, retryDelay): an attempt is healthy iff it delivered an update
this watch had not handled, or it outlived a window that is a strict multiple of
the delay it would otherwise be charged. A healthy attempt returns the delay to
the minimum, a failed one doubles it up to the cap, and the window moves with
the ladder instead of sitting at its floor. The acceptance of a reopen is the
wrong unit: gRPC takes the stream before the handler reads anything, and
controlplane.Server.Watch answers a store it cannot read by ending the stream,
so during the outage this reconnect exists for every reopen is accepted and
every stream ends carrying nothing -- measured with the real server and client
over bufconn, 4.0 watch RPCs a second across 2s of store outage with retry_in
pinned at 250ms when that acceptance is read as health. A window fixed at the
minimum is the same defect for the likelier shape of outage: a store that has
stopped answering does not error at once, it stalls until its read times out,
and an attempt that takes longer to fail than the minimum outlives that window
on every attempt -- measured in the end-to-end outage test before the change, a
300ms stall left the ladder flat at 250ms/250ms/250ms/250ms while the store
never answered a read. Both shapes are charged now, and the outage test drives
three of them (an immediate error, a 300ms stall, and a stall as long as the
delay that rung would be charged) up four rungs of the ladder, each logged retry
held to the delay actually waited.
The wait is injected (wait, production passes waitFor), because the ladder was
only ever asserted through the retry_in attribute: a loop that logged one delay
and waited another would have reported a growing ladder and reopened on a
schedule of its own. TestKeepWatchWaitsTheDelayItCharged reads the delays back
as values and asserts the ladder, and the outage test's gaps catch a wait that
returns without waiting. The retargeted reset test is joined by
TestKeepWatchChargesAReopenTheStoreMerelyAccepted: a delay reset by the
acceptance of a reopen charges every attempt of the outage from the minimum, and
nothing pinned that before.
The watch returns on cancellation without draining what the producer left for
it, so controlplane.Client's producers stop on the same context instead of
parking on a send no reader will ever take -- reproduced 40/40 times as a
goroutine still blocked on an undelivered send after keepWatch returned, one
goroutine and one channel leaked per kind at every exit. That cross-package
coupling is load-bearing in both directions and is stated as such; the two
producers now share the one stream reader that carries it.
A Recv failure is the store being unreachable, not a document this process
refused, and docs/prds/control-plane-apply-status.md ("What can be reported, and
what cannot") is what forbids reporting it as a failure of the process it
affected. The record is now written only for an update that carries a version,
which is what controlplane.Client emits for a document that would not validate
and never for a transport failure. Reporting the transport failure would also
overwrite the text of a standing refusal, replacing the one message that says
what to fix with "control-plane unavailable". The record is not un-clearable of
itself -- Report overwrites it on the next applied version -- but a store that
never changes again leaves the one stamp standing, and the process must not
write it at all. That emission is the whole of the failure path and now has the
test it lacked, from the producer's side:
TestWatchClientsDeliverARecvFailureAsAVersionlessUpdate pins that a Recv failure
is handed over carrying the mapped error and no version, and that a stream the
server closed and one that ended with the watch's context are not updates at all.
The refused version is deliberately not re-offered: the resume point moves past
it, so an edit only a newer build can decode cannot become a hot loop. Both ends
of that contract are pinned now: the watch stub filters its scripted stream by
AfterVersion as the server does, and controlplane.Server.Watch's own filter has
a test for the first time. The apply-status reporter's 30s re-stamp is unchanged
(TestRestampKeepsAReportedFailure).
|
||
|
|
2e6540a838
|
fix(archied): serve only the health facts a /status reply can carry
setupGatewayChat is the only production constructor of a Router and it runs in the Gateway, which owns no container pool, no poll loop and no channel manager. The producers wired to those three built report sections no reply could carry, and /status' own description of itself claimed all five fields. The health source now carries the broker connection and the chat-model outcome, the two facts the answering process holds. The tests for the deleted producers go with them, replaced by one that pins the served shape with a pool and a daemon present in the boot. Corrects docs/prds/status-health-surface.md, where the intro, the Phase 2 summary and the rendering bullet all claimed the five-line surface. |
||
|
|
a88380e37d
|
fix(controlplane): carry parallel_tool_calls through the tool-settings projection
mcpServerSettings mirrors config.MCPServer field by field, and runtimeToolConfigFrom rebuilds cfg.Tools from that mirror wholesale. The parallel-tool-calls flag had no home in it, so on any deployment with a control plane the file document's parallel_tool_calls = true was dropped and every MCP server stayed serialized. The field is now carried through both conversions -- the seed that writes the resource and the layering that reads it back -- and the resource accepts it, so an operator can set it there too. The field-by-field mirror is what let the field fall through, so the test populates every MCPServer field by reflection and requires each one to be projected and handed back, with an explicit allowlist for the fields the projection deliberately leaves to the file document. |
||
|
|
59cc831ff7
|
feat(tools): add per-server parallel_tool_calls to the MCP client
MCPServer gains ParallelToolCalls (default false). The client's per-server callMu is now nil for a server that opted in, so CallTool stops serializing that server's calls and the caller's own concurrency decides; every other server keeps exactly one tools/call in flight. The flag is threaded from config through the provider constructor - the only place MCPServer configs become Client instances - into NewClient, in both the daemon and the agent worker. |
||
|
|
d033c3ac65
|
test(archied): fail a state store keepalive revert in milliseconds
The keepalive agreement was guarded only by the 50s stream case, whose control tears down 41s in: a revert of the server policy cost the whole window to detect. stateStoreServerOpts's options are now checked in microseconds -- a loopback listener installs exactly one option, the enforcement policy, and that policy is 5s with PermitWithoutStream false, strictly below the dialer's ping interval and at least a factor of two under it. staterpc exports ServerKeepalivePolicy and ClientKeepaliveParams so both halves of the agreement are read from the package that owns them rather than restated in the test: changing either side alone (the floor, or the dialer's interval) fails it. ServerKeepaliveOption is now the policy wrapped in an option. The stream pair is unchanged and still proves the tear-down and the survival end to end; its two cases already run concurrently (t.Parallel, 214f9bd9), so the package pays the longer case (50s) rather than the sum (91s). |
||
|
|
8c3136eb2b
|
fix(staterpc): make the state store's server policy accept the dialer's pings
The dialer's keepalive pings a server running grpc's default enforcement policy (MinTime 5m), which counts every ping arriving less than five minutes after the previous one as a strike and answers the third with GOAWAY too_many_pings. The dialer pings every 10s, so a connection that carries no write for ~40s -- a watch while the watched resource's version is unchanged -- was torn down, where before the client keepalive it stayed up. ServerKeepaliveOption returns MinTime 5s, half the client's ping interval, so every ping lands 5s clear of a strike; stateStoreServerOpts installs it on the loopback and token listeners alike. |
||
|
|
28f7d2a0f7
|
fix(sessioncurator): address curator memory by the deployment's bot user
The curator derived the agent half of its agent-user scope from the session record's BotUser, which is the router's session-resolution match key: empty when no [[identities]] are configured (the shipped default), identities[0].Name when they are. The engine validates the scope and refuses an empty agent, so every pass in a single-identity deployment failed on its first session and wrote nothing, forever; in a multi-identity deployment the write landed at an agent no chat turn reads. A turn addresses its own memory with cfg.BotUser, so the composition now hands the curator that same value through NewAdapter. The record's BotUser stays exactly what it is, the match key resolution compares against. A session the pass cannot address is now skipped with a memory.skipped action naming why, at the point the scope is produced, instead of aborting the pass and dropping the actions already collected: one session with no address must not starve the rest. Real infrastructure failures -- an unregistered engine, an unreadable store -- remain pass errors. |
||
|
|
0263bf4e0d
|
fix(configuration): resolve the default config path in one place
Four binaries derived the default with os.UserConfigDir while the daemon resolved it from its own config home. The two agree on Linux with an absolute XDG_CONFIG_HOME and diverge everywhere else, so one deployment booted from a different config file depending on which binary started. Move the rule into the package that owns configuration resolution (internal/infrastructure/configuration, which already owns xdgDataHome and DefaultWorkDir) as DefaultConfigDir/DefaultConfigPath, and have every -config default take it from there: archie-gateway, archie-messaging, archie-state-store (serve and recovery) and archie-ui, plus the daemon's own parseArgs, setup generator and drain-marker path. Fence the claim at the source, since the resolved value is only observable by starting a process: no source under cmd/ or internal/app/archied may call os.UserConfigDir, and every -config registration must default to the helper. |
||
|
|
fbd5739235
|
fix(controlplane): make the scheduling policy carry the label its trigger pairs with
The scheduling-policy resource carried the dispatch trigger but not the trigger-matching label, so validateScheduling could judge only half of the pairing the file layer's validateDispatch enforces on the effective document (a label-requiring trigger with no label matches every open issue -- the GH#445 guard). The write path therefore stored trigger label/either with no label whenever the file's own label was unset, and boot then refused the layered document: a value the store blessed, archied unstartable, the operator left with the offline rollback as the only remedy (archie-core-7pyj). The resource now carries the label: the seed copies the file document's label, RuntimeConfig layers it with the trigger (a policy stored before the field existed decodes nil and leaves the file's label in force, the same absence-means-inherited shape a kind with no stored value has), and validateScheduling refuses a label-requiring trigger with no label, the pairing judged on the data the store actually holds. Once the store carries a label it owns it, so a file that later loses the label can no longer break a stored policy that depends on one. The parity test gains both directions, and a legacy policy without the field is pinned as an absence, not an erasure. |
||
|
|
553330df41
|
fix(statestore): skip the legacy cron jobs the schedules resource cannot hold
migrateLegacySchedules replaced the whole legacy cron/jobs.json list into the schedules resource, whose validator refuses every job whose kind is not 'workflow' -- and chat is the legacy default (an empty kind on schema-v1 jobs means chat). One chat job therefore failed the replace, the migration returned the error and RunStateStore aborted before the server ever listened. The failure was permanent: the seed had already landed at version 1, so every restart re-ran the migration and refused again, until an operator renamed cron/jobs.json by hand -- a remedy no recovery doc mentions (archie-core-q6vw). The migration now moves only the jobs the schedules resource can hold and reports the rest instead of refusing them: chat and unrecognised kinds were already dead deliveries in the old engine (the delivery router maps KindWorkflow alone). An unreadable or corrupt sidecar is logged and left in place for the next start, the way ImportConfig skips a seed the resource validator refuses -- a value this process cannot use must not stop the one process every other process dials. A successful replace is marked by renaming the file to jobs.json.migrated (the skipped jobs stay readable in it); until the rename lands, the replaying request ID keeps the replace idempotent across restarts. |
||
|
|
61887fd781
|
feat(eda): wire the playbook coordinator into production workflow selection
A loaded playbook now decides a real task's workflow. The wiring point is the daemon's definition pin (Daemon.resolveWorkflowID, consumed by pinWorkflowFromCollection), not pollNATS/publishTask as the design doc assumed: routing moved out of the agent process when workflow definitions became database rows pinned before dispatch, so the pin is the one place a task's workflow is chosen. Precedence: an explicit Task.Workflow (the waiting_human -> approved requeue) still wins, then a matching playbook, then workflow.ResolveWorkflowID's existing label/kind bindings. A playbook naming an undefined workflow is a reported failure that parks the task rather than a silent fall-through to the binding's choice -- the operator bound that trigger deliberately. Store.Dispatch returns the selected workflow name plus the matching playbook's id and version, instead of a compiled workflow.Workflow: the production caller decides against the active definition collection, and the id/version are the first two components of the resolved gap-2 idempotency key. The playbook package no longer imports internal/domain/workflow. The shipped example's `when` read event.priority, a field no intake supplies, so it could never have fired once wired. Both examples now read the event surface playbookInput really builds, and label-trigger.yaml documents the axis an instance defines for itself: trigger.kind is the closed workintake vocabulary because a kind addresses a NATS subject, while trigger.labels is free-form and binds an operator's own taxonomy to a workflow. Module/Channel/Forge positions stay rejected at load; they need the playbook_dispatches ledger first (archie-core-t2db.24). Closes archie-core-t2db.23 |
||
|
|
a989e7e2d8
|
test(archied): supersede the restart test with the broader one, staleness window made mutation-proof
Takes the wider of the two independently-written archie-core-eju6 tests: it also covers the queried half of boot.runtimeConfig (plugin_dir, not just the watched budgets), the SIGHUP reload re-applying the database layer, a task-scoped grant denied on PutApplyStatus/ListApplyStatus, and a real gRPC transport over bufconn behind TaskGrants. Its staleness leg had the same defect the narrower test did: the aged fixture was derived from applystatus.StaleAfter, the constant the reader honours, so the fixture moved with any mutation and the assertion held for a window measured in hours. The aged row now uses a documented-window literal (90s, the operator-facing contract) so the reader is constrained from both sides. |