The sd_notify(3) client lived in internal/app/archied, so archie-messaging --
a process that must not import archied's composition -- could never announce
itself to systemd, and could therefore never be a Type=notify unit
(archie-core-g5g8).
The protocol client and the heartbeat sampler move to internal/sdnotify, a
cross-cutting leaf that imports nothing of ours. What stays in archied is
what is the daemon's own: which marker counts as progress (daemon.LastPollAt)
and how long the run loop may go between poll passes. The three entry points
that already announced keep announcing, unchanged.
The Messaging Service announces READY=1 at the point it declares itself
serving, the way the daemon, the Gateway and the State Store already do. No
unit is switched to Type=notify here: that is a separate decision, and
archie-messaging.service is still Type=simple.
An install that stayed in installed_packages left every contribution
unprojected: nothing made a package's workflow a usable org resource, and
nothing stopped it on removal. This lands projection for the workflow family,
the one kind whose org resource, validation and live read path all exist:
- storepkg.Service gains Projections (family -> projector): install resolves
each projected family's contributed names against the fetched
layer (FilesFromLayer), applies them, and on failure withdraws and removes
the half installation; remove withdraws before the record goes, so a failed
withdrawal keeps the package installed and usable.
- controlplane.WorkflowProjector merges the package's entries into the org's
workflow-definitions document — the same document the daemon's
WorkflowDefinitions client reads per dispatch, so a projected workflow is
usable at the next dispatch and a withdrawn one stops dispatching, without
restarts. A contributed id displacing an operator's own workflow is refused
(storepkg.ErrContributionCollision), never silently replaced.
- installed_package_contributions (migration 0023) records the entries a
package projected, so removal takes exactly its own contributions out.
- stateStoreDeps wires the projector set on the State Store's pool; the
composition is pinned by the live round-trip test over a real gRPC
connection.
Prompts, skills, MCP server definitions and default settings remain
unprojected: their contribution formats are not settled by docs/prds/store.md
and are left for their own slices rather than half-wired here.
{{.Scopes}} now substitutes the captured set as an ARRAY in the target
encoding, so a one-element set stays a one-element array rather than
collapsing to a bare string. An empty set REFUSES by name with an
actionable "re-run the setup terminal" message: the spec declares an
omission case for {{.PrimaryApiKey}} but none for {{.Scopes}}, and an empty
array would silently change the CLI's capability decisions.
{{.PrimaryApiKey}} now implements the spec's omit case: its enclosing key is
dropped from the structure, never emptied. archie resolves a service key
only to fill the egress grant and the container holds egress.Sentinel, so
there is never a key to render.
The renderer's input becomes OAuthFacts{Scopes, ExpiresAt} -- still the only
thing it receives about a stored token set, so a real access or refresh
token cannot reach the file and an unsourceable placeholder still refuses by
name (docs/prds/external-agent-harness.md, Verification).
A Kit's credentialFile cannot render {{.Scopes}} because nothing records the
granted scopes: the token response's `scope` field (RFC 6749 section 5.1,
space-delimited) was never read, and the token set had nowhere to hold it.
capture now parses `scope` into []string and keeps the previous set when the
field is absent or empty -- the same rule the refresh token follows, so a
refresh that does not repeat the scopes preserves what the login captured.
The set is carried end to end: Scopes on harnesssecret.Secret, in
harnessSecretPayload (JSON inside the existing encrypted envelope, so no
migration), on message HarnessSecret as `repeated string scopes = 8`, and
both ways through staterpc values.go. The proto field is load-bearing: the
daemon reads the token set over gRPC, so a local-struct-only field is
silently lost in production -- TestHarnessSecretConformance proves the round
trip in both its local and grpc modes.
An archie package declares its authority; nothing in the tree recorded the
operator's acceptance of it. This lands the acceptance-record slice of
docs/prds/store.md ("Authority"):
- storepkg.Authority gains Covers (the upper-bound predicate: equal or
narrower applies, wider does not) and Validate (forge-permission
vocabulary, no blank grants).
- Installed carries AcceptedAuthority (nil until accepted); install leaves it
unset, so an unaccepted package has no authority.
- AcceptPackageAuthority on the storepkg Manager records the acceptance
against the pinned digest and refuses grants the package does not declare
(storepkg.ErrAuthorityNotDeclared), carried over the wire.
- staterpc gains the admin-only AcceptPackageAuthority RPC;
InstalledPackage carries accepted_authority.
A Kit's credential@1 oauth.credentialFile was never rendered: Assemble set
SBX_CRED_<SVC>_MODE=oauth but no file was written, so the harness CLI started
logged out and never reached the token endpoint the egress proxy intercepts.
Render it at launch, for each bound OAuth-managed service that declares one:
the Kit's structure with its access/refresh sentinels, and the stored token
set's expiry for {{.ExpiresAt}}. The renderer's only input about a token set
is that expiry -- the tokens never cross into kit, so a real token cannot be
written (docs/prds/external-agent-harness.md, Verification).
Expiry renders as epoch milliseconds, the unit both in-spec OAuth credential
files use (Claude Code's expiresAt, OpenCode's expires). A placeholder archie
does not render, or a token placeholder with no declared sentinel, refuses the
launch rather than leaving a literal or an empty value in the file.
kitrun reads the store only for a service the run credential carries, and
fails closed when a rendered credential file has no captured token set.
The definitions query was built by hand, so it carried no org and the server
resolved the default one, while the enablement document read beside it and the
enablement write went to the default org outright. A caller in a non-default
org therefore read one org's definitions beside another org's enablement, and
toggled that other org's workflows.
workflowCollection now builds its query with controlplanerpc.QueryRequest, and
the three enablement reads and the write use org.OrgFromContext, so every one of
them names the org the principal put on the request context.
containedctx rejects a struct field of type context.Context, and both new
table tests stored one. Each case now carries what the caller put on the
context -- a builder in the org test, the org id in the client test -- and
builds the context inside the subtest.
The storage and wire contract already key resources by (org, kind), but no
caller sent an org, so every request acted in the default org. The org now
travels on the request context: webui's authorize middleware attaches the
verified principal's org, and one request-constructor per wire shape
(controlplanerpc's Query/History/Watch/CommandRequest) stamps it back, so a
call site cannot send the wrong org and a new one cannot forget it.
No behaviour change today: the shared token's principal is the default org's
owner, no production path creates another org, and a context with no principal
yields DefaultOrgID (what the server already derived from an empty org_id).
The dashboard could not name a workflow's declared inputs, so POST
/api/work-requests admitted a pr-review task with no pr_number, which then
failed at the workflow's intake stage (archie-core-06nq). The handler now takes
`inputs`, checks it against the workflow's declared interface before admitting
the task, and carries it through SpawnRequest.Inputs -> EnqueueChatTaskRequest;
the form renders one field per declared input, sends a declared number as a
number, and keeps Start disabled while a required input is empty.
Item 2 of the lane brief -- archie-core-afbk.12, review.precision_gate /
review.approve_before_post in the dashboard Config tab -- is deliberately NOT in
this commit. The surface it describes no longer exists in this tree; the
supervisor's decision was to stop it and re-scope it as its own lane, and the
facts it must start from belong in the branch's record:
* The Config-tab components were deleted by 5f08625d (2026-09-25, "the legacy
config catalog stops advertising fields the control plane owns"): ConfigSections.vue,
ConfigRow.vue, ConfigControl.vue, ConfigList.vue, ConfigNotices.vue,
ConfigUnavailable.vue, config-field.ts and sections.ts all went, because no
page used them. Descriptor entries in internal/webui/config_schema.go would
therefore change nothing a person can see: the only consumer of GET /api/config
is SystemModelsPage reading `catalog`; the per-field `schema` has no renderer.
* The config write seams went earlier, in 2311529d (2026-09-21, "delete the
runtime config overlay"): UpdateConfig, ResetConfig and UpdateRepoField are
gone and internal/webui/server.go serves only GET /api/config. Configuration
is written through the control plane.
* No control-plane resource carries review settings. executionSettingsDocument
(internal/app/controlplane/workflow_settings.go) and workflow.ExecutionSettings
carry only the four budget fields, and runtimeConfigFrom never layers
cfg.Review. That is exactly why the budget descriptors survive in the catalog
and review.* cannot: budgets are saved through workflow-execution-settings,
edited on the Task-execution page, so those entries match a real write path.
* The brief's precedent name is wrong: TestToolSettingsProjectionCarriesEveryMCPServerField
does not exist. The precedent is TestToolSettingsProjectionCarriesEveryMirroredField
(internal/app/controlplane/runtime_config_test.go:349).
Making review.* genuinely editable needs a carrying control-plane resource
(extend workflow-execution-settings or add a review-settings kind), a layering
step in internal/app/archied/control_plane.go, and the round-trip test that
precedent sets -- an unsettled design decision spanning packages this lane does
not own.
A message's attachments persist as metadata (messaging.Message.Media) and
cross the gateway wire, but the dashboard transcript rendered text only, so
a photo was invisible to the operator while the model had seen it.
The transcript view now carries the persisted metadata, and the browser
labels each attachment in the placeholder vocabulary the channels already
write into a message's text ('[photo]', '[document: report.pdf]'), with the
surviving metadata (mime, name, size, dimensions, duration) in the chip's
tooltip.
Bytes are never rendered: they are turn-scoped and stripped before a record
is stored, so there is nothing to fetch and no broken image or 404 link. The
platform file id is deliberately not served either -- it is a download
handle, not an address -- so the chip links out only when the attachment
itself carried a URL. A message with no attachments omits the media key, so
transcripts written before this change keep the payload they had.
prepareWorkspace always called worktree.Manager.Prepare, whose refresh
resets an existing clone onto origin/<base>. A remediation task -- one
continuing an archie-owned PR branch -- therefore lost that branch's
commits before its container started: StageResumeWorktree runs inside the
container against a tree already reset to base, and hybridTrees.Resume is
a no-op, so nothing restored origin/<branch>.
Route a task whose row names the remediate workflow through
Manager.Resume on the persisted Task.Branch, before Acquire. The branch is
read from the task row, never recomputed from the title or labels, and a
missing branch fails closed with a park rather than falling back to base.
Regression tests use a real bare remote: the prepared worktree's HEAD must
be the PR branch tip, a missing branch must park without touching the
worktree, and a non-remediation task must still start from base.
An empty org or kind, or either containing the '/' that joins them in the
audit record key, fails on read and write instead of colliding or reading as
an absent resource.
resources and resource_history are one document per org and kind, with
per-org advisory locks, request-ID idempotency and audit keys. The
control-plane Query/History/Command/Watch requests carry org_id; a request
naming none acts in the default org until the caller's org is derived
server-side.
The tar.gz extraction already refused ".." escapes, but it did so with
filepath.Rel and checked the resulting relative path. CodeQL's go/zipslip
query models a sanitizer only as strings.HasPrefix applied to the value that
reaches the file-system sink, so the derived relative-path check was invisible
to it and it flagged os.MkdirAll/os.WriteFile on the joined target
(alert 17: internal/infrastructure/prsource/archive.go).
Resolve destDir to an absolute path once, reject an absolute entry name
outright, then test the joined target against the destination root with
strings.HasPrefix -- the PrefixCheck guard the query recognises. Behaviour is
unchanged: a ".." entry is still refused, and a wrapper directory is still
stripped. Adds an absolute-entry rejection test and a test proving an escaping
entry writes nothing outside destDir.
Telegram dropped every incoming photo, document, video and audio
message: the default handler required message text, and nothing on the
turn path knew media existed. The receiving path now closes the gap
end to end.
- telegram: extract the attachment from the update (largest photo, plus
document, video, video-note, audio and voice kinds), download its
bytes on the turn lane through getFile + the Bot API file link with a
20 MB gate, submit the turn with the attachment, and answer
unsupported content kinds (sticker, location, contact, poll) with a
clear notice instead of silence
- messaging: Inbound carries turn-scoped transport media and
MediaAttachment a Data field for in-process bytes; Message gains
Media attachment metadata which stores persist (Postgres jsonb via
migration 0020, memory store) with Data stripped at the persist
boundary, and pb.Message carries the metadata on the gateway wire
- gateway: TurnModelRequest threads the turn's media to the model seam
- archied: the chat turn model merges the attachments into the final
user message as ai-sdk image/file part entries, so vision-capable
models see the file for the turn it arrived in; stored history keeps
the placeholder note plus caption
Session log: messages carry what was sent as data (the attachment
metadata), not just prose. Transcript rendering of attachments and a
re-look capability are tracked as archie-core-jaba.
A workflow-enablement control-plane resource lists, per org, the workflows
that org has disabled. A binding targeting a disabled workflow is skipped at
dispatch like an unarmed one, is refused on save, and is flagged on the
binding list; the workflows page toggles it. Bindings now carry the org_id
column they already had in storage, over the State Store wire too.
Org-owned workflow definitions are deferred to a follow-up bead: they need
the caller's org, which the access chain resolves.
DecodeResult accepted any value reflect could convert, so a number for a
string field silently became the rune string (42 became "*"), and a declared
field absent from the map read as its zero value. Both are now reported: a
value is accepted only at the field's declared type, and every declared field
must be present.
That is the boundary the typed CEL environment promises, and it is live now
that the action runner decodes every result into actions.<id>.result before a
later expression reads it. D5 in docs/prds/multi-action-playbooks.md records
the rule.
An args value that cannot be evaluated aborts its playbook run: the action and
every later action in that playbook do not run, other playbooks matching the
event still run, and the task is unaffected. J3's skip-and-continue rule stays
specific to `when`, because a predicate has a meaningful false and data does
not.
Ratified now that the action runner is the production consumer, and locked by a
call-site test that fails if the rule is weakened to a skip. Drop the stale
"unbuilt decisions" header line, since J1, J2 and the Result schema
declarations have shipped.
A seed was consulted only for a resource kind the store did not hold, so a
document that changed in the build never reached a database an earlier
release had seeded. For workflow-definitions that is not a stale setting but
a total outage: the collection validates as one document, so a stored step
type this build no longer has fails every task's pin, whatever workflow the
task names. The seed's request ID was stable per kind and the store answers a
known request ID from resource_history, which outlives the resource, so the
documented recovery -- remove the resource and restart -- wrote nothing
either.
Seeds now carry one identity the reader can name, and a kind the store holds
is refreshed only when the seed itself wrote the newest revision: a
file-derived value stays the store's, and an operator's replacement is never
undone. The request ID is derived from the value, so an idempotent replay is
still one revision without making a second, changed document impossible. A
replay whose resource is gone re-creates it from the ledger's revision.
The shipped-vs-file-derived distinction is the seed's to make, so it is a
property of the definition (Defaults is set exactly for the kinds that ship a
document) rather than a check at each consumer.
Approving a waiting_human task requeues it under implement, but the requeue
only writes status, workflow and park_reason: the previous run's definition
stays pinned. pinWorkflowDefinition then returned early on any non-empty
stored definition, having checked only that the YAML matched its own recorded
digest -- a property of the write, never of the task -- so the dispatch went
out carrying a definition naming feasibility over a row naming implement.
That is the pair the worker's compile refuses
(agentworker.CompilePinnedWorkflow: "pinned workflow definition does not match
task identity"), so the task parked again immediately, identically on every
further approval, leaving decline the only working operator action.
A pin's identity is part of what makes it valid, not an assumption. The
producer now reads the id the stored definition declares (workflow.DefinitionID
answers that from YAML alone, without the step vocabulary) and re-pins from the
active collection whenever it disagrees with the task's workflow column. A pin
that is present, digest-valid and id-consistent is still a strict no-op, so an
operator's active definition override survives a dispatch unchanged, and a pin
whose YAML does not match its recorded digest is still refused rather than
silently overwritten.
Closes#1235
review_pr self-omitted since 7299b923 deleted the synchronous reviewer it
called. It is rebuilt on the task enqueue path everything else uses: the
tool resolves the identity's configured repo, then queues a pr-review task
naming the pull request through the workflow's declared pr_number input,
which is the same generic input mechanism a watched-repos binding uses.
That input has to reach the store with the task, so
EnqueueChatTaskRequest gains inputs_json and the tasks insert writes the
inputs column directly. StampTaskBinding no longer writes it: the insert is
now the column's only writer, and a chat task must not acquire binding
provenance just to carry an input.
ChatPRReviewer, its result shape and the reviewer wiring are deleted with
the path they served.
stagePRIntake's new missing-PR-number error (ce7b4636) fired even when
this stage runs embedded inside StagePRReviewAndOpenPR (archie's own
PRs, Task.Workflow == "implement"), where no PR exists yet and
localPRSource deliberately ignores the number. Scope the error to the
standalone pr-review workflow, which always needs a real, externally-
fetchable pull request.
Caught before this reached main: the existing StagePRReviewAndOpenPR
tests substitute a fake decision-stage list (by design, so they don't
have to script all nine phases' agent calls), so they never exercised
the real stagePRIntake and would not have caught this. Added a test
that calls stagePRIntake directly with Workflow: "implement" and no
PR number, which does.
Watched-repos needs no bespoke webhook-parsing code: the existing
generic capture+binding system (internal/infrastructure/captureintake,
internal/domain/binding.Binding) already turns any inbound webhook into
a task on any workflow, via a dashboard-editable matcher, CEL filter
and payload-to-input mapping. pr-review just needed to become a
binding-targetable workflow.
- Workflow gains an Interface field (task.WorkflowInterface) so a
Go-literal builtin can declare inputs the same way a YAML-defined one
does; ShippedDefinitions emits an inputs: block only when non-empty,
so every other builtin's generated YAML is byte-identical to before.
- PRReview() declares pr_number as a required number input.
- Task gains EffectivePRNumber(): PRNumber when a producer set it
directly (archie's own PRs), else the pr_number input a binding
assigned generically through Task.Inputs. Handles json.Number (the
store's round-trip encoding), float64 and int.
- The daemon resolves it once in acquireTaskContainer, before the task
brief is written and before the pr-review prefetch runs, so
everything downstream agrees. stagePRIntake falls back to the same
resolution for any dispatch path that bypasses container acquisition,
and fails loudly if neither PRNumber nor the input is set.
An operator wires up watched-repos entirely through the dashboard: a
Binding matching the webhook's source, a CEL filter for pull_request
events, workflow: pr-review, and an Inputs mapping pr_number from the
payload. No code change needed for a new repo or a new source.
Operator/chat trigger remains open, left as a precise continuation:
EnqueueChatTask is part of the State Store's protobuf-generated gRPC
contract (proto/state/v1/state.proto), not just a Go interface --
extending it for a generic inputs parameter needs a proto field
addition + regen, a new SQL query (StampTaskBinding cannot be reused,
since it unconditionally stamps binding_id/version, which a plain chat
task must never carry), and updates across staterpc's client/server and
~20 call sites. Real plumbing, not a quick tool rewrite -- scoped
correctly as its own pass rather than rushed here.
Adds the mechanism pr-review's watched-repos and operator triggers need:
before acquiring a pr-review task's container, the daemon fetches the pull
request's metadata, diff and head snapshot over its own credentialed forge
client (prefetchPRReview, using the already-built HTTP-based prsource.Source
from 600a0553) and writes the result under workDir/.archie-pr-review -- the
same host directory Docker bind-mounts into the container. The container-side
pipeline reads it back with prsource.MountSource, a local filesystem read, no
network call and no credential.
This follows the existing convention exactly (docs/development/agent.md,
"Giving the agent something new": "the daemon's own administrative token
never enters a container") and the same pattern WriteTaskJSON already uses
for the task brief -- prepare on the host before the container starts,
because the container binds the directory. No RPC service, no environment
variable, no exception to the stated rule.
The pipeline's Stage.Run bodies execute inside the sandboxed archie-agent
process, which holds neither a forge credential nor a git-level one --
confirmed the egress/CredentialCapability mechanism (grants.go,
credentials.go) only wires into the Kit/harness launch path
(kitrun.Launcher), not the built-in runner pr-review actually uses, so
routing through it as previously planned isn't viable without a much
bigger structural change. The git-shell Trees dependency needed a local
clone and a git-level credential the sandbox likely doesn't have even with
a bare API token.
Adds two narrow forge capabilities (PullRequestDiffReader,
RepoArchiveReader) implemented on both backends:
- GitHub: PullRequests.GetRaw for the diff, Repositories.GetArchiveLink
plus a manual unauthenticated fetch of the resolved (pre-signed,
non-API) blob URL for the archive.
- Gitea: GetPullRequestDiff and GetArchiveReader directly (no separate
fetch needed).
PRSource.Snapshot fetches the archive and extracts it with a new
extractTarGz, which strips the wrapper directory both forges add (whether
represented as a bare-name path prefix or an explicit tar directory
header), refuses any entry that would escape destDir, and drops .git
entries per the Isolation contract.
Real bug caught before commit: the wrapper-stripping heuristic initially
treated a lone top-level file the same as a top-level directory header,
silently discarding the file entirely when no wrapper existed. Caught by
TestExtractTarGzWithNoWrapperDirectory before it shipped.
Not wired into any trigger yet -- watched-repositories and the operator
trigger still need this Source constructed and handed to the pr-review
task's TaskContext, which is where an execution-model decision (daemon-side
vs sandboxed) has to land first. Left as a precise continuation on
archie-core-afbk.7, not guessed past.
StagePRReviewAndOpenPR runs the pr-review pipeline's decision phases
(1-8) against the task's own uncommitted change, using a new
localPRSource that reads Diff/Snapshot straight from Trees instead of
fetching an external PR -- there is no PR number yet to fetch one by,
which is why this trigger needed its own PRSource rather than the
forge-backed one afbk.7 already built for external PRs.
An unchallenged blocking finding parks the task with the findings
instead of opening a PR; a pipeline stage failure parks it the same
way any stage failure does. Once the PR opens, advisory findings post
against it -- best-effort, matching the deleted StagePostReviewComments'
convention: a posting failure is logged, not reverted into the outcome
the PR's existence already earned.
Implement() now uses this in place of the plain StageOpenPR. Bootstrap
and TDD are untouched -- the PRD names "the implement workflow"
specifically; extending to the others is a separate call.
Resolves this bead's first blocker (confirmed via read: CompilePinnedWorkflow
returns the same workflow.Workflow type and runs through the same
workflow.Run either compilation path, so a stage setting Outcome ends
the run identically regardless -- stagePROutput's posting logic had to
move inside StageOpenPR's own Run body, not follow it as a separate
Stage, which OpenPR's own doc comment already anticipated).
Still open on this bead: watched-repositories and operator triggers,
both blocked on the credential path for PRSource's real forge-backed
implementation reaching the sandboxed archie-agent process -- see the
bead comment for the concrete design (egress credential-capability
grant, narrow forge diff/archive HTTP methods) not yet built.
docs/prds/pr-review-agent.md's own header already declared this
superseded (docs/architecture/adversarial-review.md, docs/prds/
operator-pr-review.md, docs/prds/review-calibration.md); this executes
that removal per the maintainer's explicit decision, so no reference
to the old path remains:
- internal/domain/workflow/review.go, review_findings.go,
review_report_md.go and their tests: Reviewer, ReviewRequest,
StageReview, StagePostReviewComments, ReviewReport/ReviewFinding and
friends. ReviewComment relocated into workflow.go (still used by
Forger.CreateReviewComments and the new pr-review pipeline).
- internal/app/agentworker/review.go: the ai-sdk-backed subagentReviewer.
- internal/app/archied/pr_review.go: the synchronous operator-review
path (prReviewer, gateway.ChatPRReviewer wiring). The review_pr chat
tool now self-omits (nil reviewer) until the operator trigger is
rebuilt to enqueue an async pr-review task instead of reviewing
synchronously in the chat turn.
- config.Repo.ReviewEnabled and its dashboard exposure.
- Two composition-order tests and one dashboard test that existed only
to pin the deleted path.
Also splits PRReview()'s Stage list into prReviewDecisionStages()
(phases 1-8) and stagePROutput() (phase 9), so a future caller can
splice the decision phases before a PR exists and defer posting until
after -- needed for the "archie's own PRs" trigger, not wired here: it
needs the same stage-loop-around-StageOpenPR semantics this pass
couldn't fully verify in the time available (does an Outcome-setting
stage like StageOpenPR end the compiled-workflow-definition engine the
same way it ends workflow.Run's literal loop?). Carries ScoredFinding.
Adversary through synthesis so that trigger's blocking-finding check
doesn't need to cross-reference back into the pre-synthesis slice.
Not built in this pass, left as a precise continuation (see the bead
comment): the watched-repositories and operator triggers, both blocked
on the same real question -- how a forge-reading credential reaches
PRSource's real implementation when the pr-review pipeline's Stage.Run
bodies execute inside the sandboxed archie-agent process, which holds
none today.
Metadata/Diff/Snapshot implemented against a narrow Forge (GetPullRequest)
and Trees (CheckoutPR/Diff/Snapshot) contract, satisfying
workflow.PRSource -- the counterpart to the task's own Trees, which never
reaches an arbitrary external PR. worktree.Manager already satisfies the
narrow Trees interface structurally; forge.PullRequestReader needs a
small field-mapping adapter at the composition root (not yet wired --
see the afbk.7 continuation note).
Deliberately not wired into production task execution this pass: doing
so surfaced a real credential-boundary problem (see bead comment) that
needs resolving first, not papering over.
Add review.precision_gate and review.approve_before_post to config,
threaded through TaskConfig/ForTask/ToConfig so the pr-review workflow
reads them under archie-agent too, not just in-process.
stagePRPrecisionGate runs between review and verification, filtering
findings down to concrete, evidenced defects when the dial is on;
stagePROperatorApproval ends the run in waiting_human right after
synthesis, before the merge gate, when approval is required and
findings exist. Both are off by default and fail open on a broken
agent call, matching the pipeline's existing recall-first fallbacks.
Filed follow-ups: afbk.11 for the actual operator-response resume
mechanics (post/reject/re-review with instructions, the 2-round cap --
genuinely needs either a small Task schema addition or a documented
Notes-encoding decision, a call for whoever wires afbk.7's triggers)
and afbk.12 for exposing the two flags in the dashboard Config tab.