Alaga

Alága

Choose the requested result before acting. Use scope-only when the user wants just the coding boundaries, protected behavior, or expansion triggers; map the job below and return the guard without starting delivery. For authorized delivery, choose proof within the delivery workflow. Use test-first implementation when the user requests it or a material behavior-bearing seam with an independent oracle makes a failing test capable of controlling implementation.

A scope correction during already-authorized delivery updates its active boundaries and preserves that delivery authorization unless the user pauses or narrows it. Do not turn ordinary local choices inside the accepted scope into new approval gates.

Delegate substantial analysis, research, and expert work to subagents, returning concise findings and evidence links to keep the main context lean.

1. Map the job

Pin only what can change delivery:

• outcome and current/desired behavior;
• scope and local non-goals/task exclusions;
• expected change envelope and explicitly unchanged contracts;
• acceptance and smallest sufficient proof;
• governing specification/decision identities when present;
• ordinary documentation required by the delivered contract; and
• workspace and mutation authority.

When project knowledge could change implementation or proof, reuse applicable evidence already supplied; otherwise search the existing knowledge and research destinations by affected concepts and components. Read plausible matches and check their authority and current applicability before applying a constraint or avoiding a past approach. Flag material conflicts; an empty search does not require documentation or knowledge maintenance.

Treat local non-goals as active negative implementation boundaries. Material growth outside the expected envelope is a signal to re-check understanding, causal ownership, or scope rather than preserve the first plan with workaround layers.

Use project behavior and accepted decisions to define boundaries, not arbitrary file, line, test, or dependency quotas. Expose changes to accepted interfaces, storage, compatibility, permissions, operational burden, or material risk/cost as expansion; require a current reason for new dependencies, infrastructure, abstractions, unrelated cleanup, or test frameworks.

Use amose, architect, and arojinle as needed. Make local implementation choices within the accepted scope and contracts; surface unresolved requirements rather than inventing them.

When consequential stack-native behavior, ownership/lifecycle, compatibility, proportionality, or version-specific evidence is genuinely non-obvious, read expert implementation counsel. When the job materially changes a product interface, component system, design-token contract, responsive behavior, or rendered interaction, read UI delivery. For multi-candidate, blocked/handoff-prone, migration/security/recovery-sensitive, or externally destructive work, read job report. Do not create parallel reporting when an active plan already owns that continuity.

Repository/Git state never grants commit, history-rewrite, publication, provider-write, or destructive authority.

For scope-only, return the desired result, protected behavior/areas, exclusions, sufficient evidence, and the event that requires reconsidering scope. Stop here: do not edit, implement, run delivery proof, commit, or publish from a guard-only request.

2. Deliver and prove

Prepare the workspace without disturbing unrelated changes. Continue until the requested outcome is proved, a material decision/authority gap blocks safe progress, or no safe independent work remains.

Minimum sufficient mechanism

Minimum means the least necessary mechanism that remains idiomatic and readable, not the fewest lines, helpers, or files. Understand the affected flow and real owners, then take the first sound option:

1. eliminate unnecessary mechanism or causal state;
2. reuse an existing project capability;
3. use native language/framework/platform capability;
4. use an already-selected dependency/tool;
5. derive duplicated state or localize policy at its real owner; then
6. add the minimum new mechanism still required.

Do not add indirection for hypothetical variation. A new abstraction needs a current second consumer/variant or an independently real production boundary such as external protocol, trust, persistence, volatile platform integration, or owned lifecycle/policy. Do not create production architecture solely for test convenience.

When a mutation is authorized by mutable shared state—existence, uniqueness, balance/capacity, ownership, quota/count, expected version, or another predicate another actor can change—identify the invariant and its authoritative enforcement before writing the change. Do not let an unprotected read → decide → write sequence be the sole authority. Treat concurrency correctness as an invariant question, not a traffic threshold. Existing constraints, conditional mutation, version checks, serialized ownership, locking, or isolation count only when they cover the same invariant and all relevant writers; use expert implementation counsel when exact database/runtime semantics can change the mechanism.

For a defect, correct the narrowest confirmed causal owner that covers affected paths. Treat an unplanned dependency/service/infrastructure component, public API/schema/storage/wire/compatibility change, material new abstraction, unrelated subsystem cleanup, parallel implementation, new test infrastructure, or destructive effect as scope expansion. If the accepted outcome genuinely needs it, surface the reason and required authority rather than silently enlarging the job.

Proof policy

Proof is required; a new test is not. Use the smallest evidence that can independently falsify the changed contract: existing affected tests, compiler/type guarantees, static analysis, builds/schema checks, focused runtime probes, integration checks, bug reproduction, browser/manual verification, or another stronger current proof surface.

Apply TDD only when its admission gate is met. Glue, wiring, declarative configuration, trivial delegation, framework-native behavior, or similarly low-information changes do not earn a new test by ceremony. Wiring that binds identity, authority, or resource limits needs proof through the assembled path: show that the intended identity reaches the correct authority and that the configured limits govern the resulting operation. Constructor tests alone may miss incorrect combinations. Reuse sufficient existing integration or acceptance evidence before adding proof.

Run focused proof while changing the relevant behavior, then job-level integration/acceptance proof. Use real-browser journey evidence only when literal user journeys changed and browser-dependent acceptance remains materially unproved by cheaper evidence.

For a planned stateful refactor/rewrite that can change transitions, ordering, locking, retries, idempotency, ownership, or cross-entry behavior, require a current independent parity/contract result before relying on the rewrite plan.

Exact candidate boundary

Before independent review, pin the exact candidate with the strongest native content identity available: commit, tree, snapshot, digest, or equivalent. For a PR/MR candidate, the current base is part of that identity; when the candidate is one stack layer, pin at least the head SHA plus the current base-ref SHA. A stable head with a changed base-ref SHA is a changed review candidate.

Ambient unrelated changes must not enter the candidate. If the candidate/base changes, an ancestor changes the effective stacked base, or unresolved conflict state makes the content ambiguous, refresh the identity before relying on review evidence. Preserve proof that is independently unaffected by the base change; rerun only evidence whose falsification boundary moved. Leave ordinary Git/restack mechanics to native capability under the required mutation authority.

Before review, include required ordinary documentation. Do not promote task rationale, findings, or reversible implementation choices into durable project knowledge unless they independently qualify under the current durable-knowledge policy.

Pre-review convergence

Remove issues you already know an independent reviewer should not need to discover: scope drift, wrong causal owner, unnecessary files/abstractions/dependencies/state/compatibility paths, temporary scaffolding, low-value durable tests, and proof that cannot distinguish plausible wrong behavior. This is a delivery self-check, not a retrospective or substitute for independent review.

3. Review and converge

Use atunwo for independent code review after implementation proof. Review each stable candidate at the smallest coherent boundary; use the relevant checks for non-code work.

A review finding is a hypothesis, not automatic mutation authority. Before correcting it:

• verify the failure/contract consequence;
• confirm it is inside accepted scope and local non-goals;
• prefer removing causal state/duplication over adding special-case machinery;
• prefer an existing mechanism at the real owner; and
• surface any genuine scope expansion instead of auto-building it.

Apply corrections through the proof mechanism appropriate to the changed invariant, refresh the exact candidate, and rerun only evidence invalidated by the correction. Do not close with a blocking finding or material evidence gap.

Before closing, every touched file, new abstraction, dependency, compatibility path, and durable test should have a concise requested-contract or necessary-proof reason to exist. Passing tests and smaller line counts are evidence, not permission for unnecessary structure.

When a deliberate simplification has a known ceiling, record the ceiling and observable revisit trigger at its natural owner rather than creating a parallel debt ledger.

4. Report

Return the job boundary, local exclusions, final change shape, delivered result, proof/review state, exact candidate identity, material scope decisions, blockers/residual limits, and next safe action. Publication remains a separate authority/outcome.