[Varuas37]

Motivation

The existing skills already incorporate the earlier Rust study corpus in
#20 and proof planning in
#21. Subsequent source inspections
identified a smaller set of missing distinctions and overly absolute rules:
custom future construction can act before polling, native cleanup can fail
without ending external use, and acceptance or a merged implementation slice
does not establish a complete delivered guarantee.

This change adapts those lessons to their existing owners. It preserves the
earlier guidance, fixes contradictions in place, and keeps project evidence in
this description.

Solution

1. 719e8af: amend coding's existing input, identity, cleanup, bounds and shutdown rules;
   allow configuration justified by a caller contract or a demonstrated policy
   need; retain accepted retry work through temporary prerequisite absence.
2. 719e8af: correct Rust future construction and extend existing ownership,
   allocation, code-generation, overflow, FFI and build-compatibility guidance.
   Keep only the Rust-specific forced-poll test under the general notification
   owner's link.
3. 719e8af: extend the existing patterns reference for mutation witnesses, compatibility
   fallback guarantees and independent stream progress. Keep the upstream-fix
   detail there and replace the duplicate PR convention with a link.
4. 719e8af: add the ADR reconciliation procedure to the existing ADR reference: distinguish
   decision history, delivered slices, evidence and remaining gates; reconcile
   all current-state projections and structural inventories. Link it from the
   architecture skill and list its ownership in the engineering README.
5. 719e8af: add core-rule examples pointing to the detail owners, check feature-partitioned
   suite discovery, and bump matching package/plugin versions to 0.5.0.

Source-to-owner mapping: accepted amendments

Each source below supports the stated mechanism. Merged fixes are evidence for
the lesson, not claims that the defect still affects today's upstream code.

Lesson	Existing owner	Primary evidence and important limits
Validate before a transform erases rejected input distinctions	coding, explicit contracts	Polars #29658: ragged rows lost data through iteration; documented intentional loss remains allowed.
Apply protocol precedence and reconcile the raw emitted representation	coding, explicit contracts	Hyper #4223, #4224, #4201, #4196: conflicting raw metadata can survive parsed absence; unrelated extension values must survive. This does not prescribe one protocol's ordering to another.
Replace the blanket configurability ban with a demonstrated need	coding, while writing	Tokio #8410: busy maintenance and blocking/idle polls have different admission costs. Explicit caller contract parameters need no invented benchmark prerequisite.
Readiness must reflect taking work, including scheduler-induced Pending	coding, failure first	Hyper #4208: consumer take reconciles a stale hint. Remaining multiplexed capacity is different from an idle-only flag.
Retry with stable identity and retain accepted work through temporary absence	coding, failure first	Bevy #25815, #25816: temporary dependency absence consumed pending work; replaceable render handles must be resolved at retry. Terminal cancellation/refusal still removes work.
Cleanup is not proof that externally referenced state can be freed	coding, cleanup	Tokio #8540: duplicate descriptor kept epoll's token live after failed unregister. This merged into tokio-1.51.x; it does not establish default-branch inclusion or require retaining state when the foreign API proves no reference remains.
Notify live waiters owed a transition, preserving conservative wakes	coding, notification; Rust retains forced-poll test mechanics	Hyper #4225, with prior #4168: skip known-dead peer wakes without losing required open-peer progress. No throughput gain is claimed.
Semantic quotas differ from transport-buffer capacity	coding, bounds	Hyper #4183: partial acquisition, complete items and secondary fragments must respect the same semantic budget without counting unrelated payload.
Acceptance names a handoff; graceful shutdown follows the buffering owner	coding, shutdown	Hyper #4018, Tokio #8506, Tauri #14443, #16134: normal drain, forced termination and indefinite outside input have different contracts. #8506 is repeated evidence, used as a refinement.
Record cleanup ownership before panic-capable instrumentation or notification	Rust, how to think	Tokio #8542, supporting #8560 and #8566: state and cleanup obligation agree before the call-out. #8542's target is tokio-1.51.x.
Public mutators define reachable states as well as constructors	architecture, tactical rules; Rust retains mutable-access mechanics and links here	Bevy #25995: legal setters can put elapsed time past a shortened duration; getters must honor the actual API rather than a stronger assumed invariant.
Grow stable storage without moving address-sensitive live values	Rust, allocation	Deno #36678, Rust Pin documentation: stable chunks preserve pinned pointees and release ownership. Ordinary movable storage can still reallocate.
Check type-dependent branch instantiation before adding runtime erasure	Rust, generics/code size	Tokio #8414: associated-constant pruning changes generated instances without changing boxing semantics. Compiler and caller measurements remain necessary; no general speedup is claimed.
Wrapping chronology requires a bounded comparison domain	Rust, concurrency	Tokio #8546, RFC 1982: live comparison window must be strictly smaller than half the counter space, otherwise strengthen the representation. Equality-only IDs need no chronological comparison.
Bound arithmetic must preserve the operation's contract	Rust, overflow	Deno #36962, Tokio #8574: check the bound expression; use equivalent stages or typed refusal where necessary. Saturation is not a universal repair.
Foreign status and exception state determine valid output	Rust, errors/unsafe	Deno #36942: pending exception can make a callback return unusable. Explicitly promised partial results remain valid on their specified statuses.
Dependent fields encode teardown order	Rust, resource ownership	Tokio #8564, Rust destructor reference: wait unregister must precede closing the referenced handle; struct field order differs from local-variable drop order.
Future construction can reserve before first poll	Rust, async	Deno #36679: ordinary constructors already reserved an uncontended borrow before polling. Preserve reservation timing, cancellation and fairness across fast/queued paths; the body of an async function remains lazy.
Native link compatibility includes disabled capabilities	Rust, testing/build compatibility	Tokio #8528: always-compiled imports broke older supported Emscripten consumers even with JSPI off. Rust compilation alone does not establish foreign symbols, ABI or fallback behavior.
Generated-name hygiene and diagnostic spans are separate contracts	Rust, macro testing	Serde #2845, #2847, #2857, #2879: nested expansion, diagnostic compatibility and warning suppression scope need distinct checks. Repeated #2857 evidence is counted once.
Build-script effects respect documented docs/metadata modes	Rust, testing/build compatibility	Tauri #16186: skip unnecessary native-project writes in docs builds before attempting them; preserve required application-build effects.
Feature-partitioned suites need default/aggregate discovery checks	testing, structure and placement	Bevy #25321 to #26036: standalone compilation is not proof the intended benchmark command reaches the case.
A mutation witness covers every permitted answer-changing write	patterns, derived state	Deno #33683: length is sufficient only under the restricted mutation premise. This is a transferable condition, not a claim that a same-length mutation was demonstrated in that implementation.
Compatibility fallback inherits validation and resource obligations	patterns, derived state	Deno #36933: unsupported is not trusted; a fallback must establish or reject the missing guarantee. Repeated evidence, not a new discovery.
Independent streams need independent progress under back-pressure	patterns, concurrency	Zed #65011: blocked log/RPC output must not prevent unrelated input. Deliberately coupled contracts still share waits.
Prefer upstream fixes within the upstream compatibility promise	patterns, concurrency; PR convention links here	Serde #2697 maintainer discussion: generic write formatting cannot assume the narrower caller operation. Historical constraint, not proof no current upstream solution exists.
Reconcile accepted scope, shipped slices, current evidence and inventory	ADR reference	nessa-agent #356, #357, issue #390: rejected/deferred work is not necessarily remaining scope; schema, SDK, gateway, client and desktop delivery are separate slices. No repository-specific numbering or folder scheme is prescribed.

Already covered; deliberately not added again

• The pre-October fold-in is already in skills: fold in 21 Rust studies, name two core rules, add AGENTS.md #20: identity scope, generation guards,
  bounded admission, callback lock/reentry safety, exactly-once cleanup,
  instrumentation cache keys, generated-code testing, process-global test scope,
  published-crate MSRV, real promise boundaries and measured performance limits.
• coding: plan proof before implementation #21 already owns proof planning, ready/resumed paths, producer/consumer effects,
  valid negative fixtures and permitted counterparts. No second proof checklist.
• Optional accelerator availability and semantic parity are already explicit in
  patterns. Tokio #8165 reinforces
  them; it does not justify another accelerator rule.
• Ripgrep traversal/escaping/recount/specialization examples fit existing
  contract, parser and conservative-summary owners. Polars mapping identity,
  post-rewrite caches, coordinate space, phase absence, batch budgets and explicit
  reorderability fit existing identity, state, bounds and optimization owners.
• Rust compiler boundary transformations, refinement progress, capability
  detection and foreign referent lifetime fit existing contract/lifetime owners.
  Cache/PGO provenance and surprising performance outcomes remain evidence under
  the existing performance method, not new checklists or reported speedups.
• Serde #2805/#2821/#2857 repeat prior primary evidence; Zed's saved alternate
  draft and final sample disagree. No duplicate discovery claims or uniform
  sample claims are made, and alternate-only Zed cases are not used for new text.

Omitted narrower proposals

No permanent project references or 32-card review guide. Persisted shortcut
metadata formats, approximate mergeable sketches (Polars #29660), async-to-sync preparation
handoffs, compatibility no-op tombstones and calendar recurrence recipes remain
case-specific candidates unless a distinct recurring contract warrants them.
The existing general owners already cover much of their mechanism. In
particular, approximate merge behavior must use its actual tolerance and order
contract, not an invented bitwise-equivalence promise.

No stale ADR backlog is imported from before the reconciliations in #356/#357.
No Nessa source or ADR is changed by this skills patch. Reconciliation findings
still require their exact current contradiction and bounded acceptance checks.

Validation and limits

Baseline: wip at 7bb0666936c68fd7eb4662972be164ef52ff55b2, independently
rechecked against the remote on October 9, 2026. Documentation-only change;
no runtime implementation, dependency, installed-skill or CI changes.

On the connected Mac:

• Existing quick_validate.py: all six skills pass.
• All 166 local Markdown file/anchor checks across the repository pass.
• Package/plugin versions match; all six declared skill paths exist.
• git diff --check passes.
• Full diff self-review and an independent complete-diff review checked ownership,
  applicability and precision. The independent review found two P2 issues:
  architecture's constructor-only invariant rule contradicted the mutation
  refinement, and ADR inventory language conflated decision acceptance with
  delivery placement. Both were corrected at their owners. The reviewer re-read
  the complete revised diff, confirmed both resolved, and found no further
  actionable issues; its independent validation also passed.

Source: 719e8af7032eb2c3d5bd6c1de051d7563a9b0094, based on the baseline above.
Ten files, 187 insertions and 43 deletions. This is one cohesive local commit;
the evidence mapping is kept in this description instead of the loaded skills.

The source-study experiments and upstream Rust/native/platform/performance suites
were not rerun. Source inspection and documentation validation do not establish
runtime guarantees or measured improvement in defect detection.

[coderabbitai]

Note

Currently processing new changes in this PR. This may take a few minutes, please wait...

⚙️ Run configuration

• Configuration used: defaults
• Review profile: CHILL
• Plan: Advanced
• Run ID: 0ffd9f30-41e1-461a-a020-6d8e885be321

📥 Commits

Reviewing files that changed from the base of the PR and between 7bb0666 and 719e8af.

📒 Files selected for processing (10)

• .claude-plugin/plugin.json
• package.json
• skills/engineering/README.md
• skills/engineering/coding/SKILL.md
• skills/engineering/coding/references/rust.md
• skills/engineering/coding/references/testing.md
• skills/engineering/pull-requests/SKILL.md
• skills/engineering/system-architect/SKILL.md
• skills/engineering/system-architect/references/adr.md
• skills/engineering/system-architect/references/patterns.md

 ______________________________________________________
< Your bugs are no match for my GPU-powered intellect. >
 ------------------------------------------------------
  \
   \   \
        \ /\
        ( )
      .( o ).

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Commit to this branch
• Create a new PR

• Autopilot · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

---

_{Comment @coderabbitai help to get the list of available commands.}

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-09T03:29:14.794673Z	719e8af	Draft marked ready

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 719e8af703

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Keep finding verification with its existing owners

This paragraph introduces substantive rules for filing review findings and classifying evidence, even though the owner table in skills/engineering/README.md:68-69 assigns review standards to pull-requests and verification/evidence classes to method. Keeping those rules here gives the lessons a second owner; move them to the assigned owners and leave only an ADR-specific link or application sentence.

AGENTS.md reference: AGENTS.md:L32-L33

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Require proof before skipping a closed peer's wake

Knowing that a peer is closed does not by itself prove that no live waiter needs notification: for example, a send or receive future may already be pending and require a wake to observe the terminal closed result. As written, this rule can legitimize a lost wake and permanent sleep; qualify it with proof that closure already woke or cancelled every waiter, or that no waiter can exist.

AGENTS.md reference: AGENTS.md:L47-L50

Useful? React with 👍 / 👎.