Skip to content

feat(knowledge): add external read-only channels to find - #484

Merged
jiangkuaixue123 merged 5 commits into
mainfrom
feat/cannbot-external-channel
Nov 18, 2026
Merged

jiangkuaixue123 merged 5 commits into
mainfrom
feat/cannbot-external-channel

Conversation

@jiangkuaixue123

@jiangkuaixue123 jiangkuaixue123 commented Nov 17, 2026 •

Copy link
Copy Markdown
Collaborator

Refs #476

This C0–C3 slice lets find query an explicitly approved local cannbot-knowledge checkout beside the packaged corpus. Ascend queries search both sources even when local hits exist; external results retain separate status, revision and score scale in external[].

Behavior and review corrections

  • One shared deadline covers discovery and search and reaches the subprocess. Owned workers are cancelled, late responses discarded and elapsed time reported. Daemon dispatch avoids executor shutdown joins.
  • Source stdout/stderr are bounded during capture. Original JSON rejects duplicate keys, non-finite/overflow values, unsupported schemas and malformed shapes.
  • Requested hit caps are enforced at dispatch and before Cannbot reads any surplus cards. Default cap is 100; explicit limits are 1–200.
  • Generated reads and pagination carry both --revision and --sha256. A checkout revision change is rejected even if card bytes remain identical; byte changes are rejected even if HEAD is unchanged. The worker observes HEAD before/after reading and returns the actual revision and raw-byte digest. Locator-only reads explicitly return current content. This detects observed drift in a mutable checkout; it is not an atomic snapshot or historical replay.
  • Native upstream card_sha256 is a parsed-card fingerprint, retained as source_card_sha256 and verified using the approved checkout's implementation. Public card_sha256 identifies the raw bytes used for reads. Search does not return card bodies or private paths.
  • find --platform overrides the grant platform. Missing platform gives actionable guidance. Both ordinary and explicit-Ascend lookup outside Git report not_enabled and retain local results.
  • Ruff, cap help text, installation documentation and outside-Git fixture assumptions are corrected.

Scope and decision provenance

The maintainer authorized this implementation, before/after comparison, review fixes and PR updates in the implementation conversation. The same conversation explicitly changed the cannbot default from 10 to 100. The maintainer subsequently authorized handling the remaining review feedback, including revision binding and synchronizing #476. This is an implementation-agent record of that authorization, not independent approval.

Explicit task backend overrides the approved project grant; absent both it is unknown. The source's capability remains Ascend. Platform selection does not itself authorize a source: only an approved local checkout/interpreter is called, and --no-external starts no external worker.

This PR does not accept the whole RFC or settle organizational source-use permissions. MindIE adapter (C4), MCP serving (C5), receipt/import (C6), HTTP, discovery caching and historical replay remain deferred. The two local docs/plans/ drafts are excluded.

Validation

Current code: edeb3869cf79463348848eec90806e994aa4ff1e.

  • ruff check src tests tools and git diff --check: successful.
  • Author run: pytest -o addopts='' -q tests/test_cannbot_boundaries.py tests/test_knowledge_channels.py tests/test_knowledge_find.py tests/test_knowledge_cli.py tests/test_apps_knowledge.py — 141 passed.
  • Approved real-source run: pytest -o addopts='' -q tests/test_cannbot_channel_acceptance.py — 7 passed, source revision 92dc260756e91e72e6dcd60f3996a4d54f43c8f5. Includes actual revision-and-digest-bound read, six-query retrieval and unchanged local ordering.
  • Internal independent reviewer ran the same focused selection plus tests/test_knowledge_contract.py — 154 passed — and independently exercised synthetic Git failure/timeout/descendant cleanup. The reviewer separately reran the real-source acceptance selection at this exact head: 7 passed, 0 skipped, 0 failed, using the same source revision above. No blocking code findings. This verifies the exercised integration, not organizational permissions or an eligible independent GitHub approval.
  • Current-head CI: all 11 checks successful. Ready run 44222476421, draft run, and declaration checks passed. Raw Python 3.10 and Python 3.11 logs each report 5,076 passed, 36 skipped, 671 subtests passed, 1 warning. Ready tested integration merge 95ac5101e5fb57b282d2a1ac09b101a3f1064935 of this head into c37832c3c7a6c457f533683b7b3386f2c3a0c004, not the PR metadata base a02ef186. Package, browser and host checks passed; these do not replace the separately run real-source tests.

Historical local limitation: a full macOS/Python 3.12 run on the earlier repair snapshot had 16 failures, all reproduced at original PR head a38d360d in a separate checkout under the same environment. They involve missing python on PATH, filesystem aliases/case sensitivity/non-UTF8 filenames and existing DSH/skill-eval cases. A green local full-suite run is not claimed.

Retained six-query measurement against the same upstream source, default cap 100:

Query Local only Local + external returned hits
AscendC tiling 参数怎么计算 14 114
CeilDivision 向上取整 0 100
matmul 分块 性能 10 110
算子 精度 调试 溢出 75 175
ACLGraph 图模式 捕获 100 200
KV cache 显存 布局 128 228
Total across queries 327 927

These are returned matches summed across queries, not unique corpus size or a performance/quality claim. Source inventory was separately rescanned: 10,550 cards, 818 navigation files, no parse errors or missing status/type. Correct totals are stable 6,589, draft 3,920, deprecated 41; Runbook 2,585. The old 223-card discrepancy came from JSON-formatted frontmatter omitted by line-based counting, not missing cards. #476 records the reproducible scan.

Remaining boundaries

POSIX descendant cleanup is exercised. Windows uses taskkill /T /F while its worker is alive; native Windows tree cleanup still lacks dedicated qualification. Generic Python adapters, factories and cleanup hooks must cooperate with deadlines; arbitrary in-process work has no forced-cancellation guarantee.

Card identity does not establish cited-source closure, legal permission or campaign acceptance. Organizational permission questions remain open in #476. Merge still requires passing current checks, resolution of blocking reviews and two current eligible independent approvals. Whole-Issue completion is not claimed.

Follow-up setup guidance

PR #492 adds proactive Ascend installation/enablement recommendations, complete setup links, and post-install discovery/search/identity-bound read verification. It is a separate follow-up to this merged PR; its validation and review status are tracked there.

`find` could only answer from this repository, which holds six Ascend
content cards and no per-API card at all. The external cannbot-knowledge
corpus has 10,550 cards, 2,993 of them Ascend C API cards, and it is
CANN-licensed: copying it into the package or an evidence tree would be a
distribution the repository cannot make. This adds it as a read-only
channel instead, queried in place.

Design points the code enforces rather than documents:

- External hits never enter `items`. They were not ranked on this corpus
  and are not locally verified, so a caller reading only `items` cannot
  mistake them for validated knowledge.
- Each channel reports its own state. A failure is `unreachable`,
  `timeout`, `index_stale`, `not_enabled` and so on, never an empty list:
  "searched and found nothing" and "could not search" are different facts.
- A timeout is reported with `elapsed_ms`, not rendered as no match.
- Scores carry `score_scale`. Two corpora of different sizes have
  incomparable idf values, so a cross-channel merge would be a fabricated
  number.
- The task backend is declarative, never inferred from the query. It comes
  from `--backend`, then from the approved grant, and is absent otherwise.
  Reading `Channel.backend` as the task backend made an undeclared task
  search anyway; the registry now carries the declaration separately.

`--no-external` reproduces the pre-channel output exactly, and a registry
with no channels returns the original result untouched, so existing callers
and the CI baseline are unaffected.

The grant records an interpreter path without resolving symlinks. Resolving
it lands on the base interpreter of a venv and loses pyyaml, which passed
the enable probe and failed every later search.

Coverage measured on six Ascend queries against a checkout at 92dc2607:
local matches 327, with the channel 927 at the new default cap of 100.
CeilDivision matches nothing locally and returns 100 locators upstream.

Refs #476

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
@Dong1017 Dong1017 added area:knowledge Knowledge line: packs, skill library, knowledge admission kind:task Bounded delivery task with a delegated slice labels Nov 17, 2026

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting review: blocking evidence remains; not approved. Head af2c48683afba7f73889aacadb3bd22fafa28961, base a02ef1863e29de4510272e65ae69341b1ef83f22. Acting under the maintainer's standing authorization for other-author PR reviews. I inspected actual code and isolated C0–C3 requirements without reading other reviews or author result summaries.

  1. P1 — the advertised timeout does not bound channel work (knowledge/channels.py:238-280). The single-channel branch calls work synchronously without a deadline. The multi-channel branch times out future.result, then exits a ThreadPoolExecutor context that waits for unfinished workers. A bounded local fake sleeping 0.25s with timeout=0.02 reproduced: one channel returned after 0.250s with state ok; two channels returned after 0.255s with timeout states. A hung implementation can still block local results indefinitely. The existing timeout test only makes the fake raise TimeoutError, so it does not exercise elapsed-time enforcement. Establish an actual bounded execution/cancellation contract, including describe/search and process cleanup; add a deliberately slow or non-returning fixture with a parent-enforced test deadline. Do not merely relabel a late return.

  2. P2 — source JSON validation is bypassed before the strict parser (apps/cannbot/read_worker.py:28-39, apps/cannbot/project.py:64-82). The worker uses ordinary json.loads(result.stdout) on the upstream response, then builds a new JSON envelope. Duplicate keys are already collapsed before the outer parser can reject them. With a mocked upstream response containing {"cards":1,"cards":2,"index":{}}, discover accepted cards=2. A NaN source value also survived the inner parse; later serialization failure is not strict validation at the source boundary. Apply duplicate/nonfinite/shape validation to the original upstream bytes and test that boundary. Likewise, the 2MiB check occurs after subprocess.run has captured stdout, so it is a post-capture size rejection, not a memory-bounded reader.

  3. P2 — search provenance is not bound to full-material read (apps/cannbot/read_worker.py:92-112; ChannelHit.view). Search returns revision/card SHA, but its generated open command carries only the locator. Read accepts no expected revision/digest, reads the current file and returns neither revision nor digest. In a temporary synthetic checkout, rewriting the same card between two reads produced different text under the same locator with no identity mismatch or returned identity field. Pagination can likewise span changed versions. Either bind read to the search identity and reject drift, or explicitly expose current-byte identity and the lack of snapshot continuity. The acceptance test named test_read_returns_one_pinned_card presently asserts only state, locator and nonempty text, so it does not establish pinning.

  4. The changed files do not pass lint. A local targeted Ruff check found eight errors: undefined ChannelRegistry annotations in knowledge_find.py:738,798, unused imports and an import-order error in the added tests. Exact-head CI currently also reports failures for lint-and-smoke and both full-check Python versions. I have not attributed the full-check failures to a specific cause.

Validation: the selected channel/find suite completed 79 passed, 5 skipped, one pytest-plugin deprecation warning:

PYTHONPATH=src python -m pytest -q -o addopts='' \
  tests/test_knowledge_channels.py \
  tests/test_cannbot_channel_acceptance.py \
  tests/test_knowledge_find.py

The five real-upstream acceptance cases skipped because no approved checkout/index was configured. The timeout, mutable-card and malformed-source probes above used local fakes/temporary files, not external service access. git diff --check against the base passed. AGENTS/review guidance was checked; no code was changed.

Remaining scope gaps: no real Cannbot/source qualification, clean-wheel round trip, full suite, license determination, or authenticated final defaults/platform-precedence decision. The isolated requirements distinguish channel capability from actual task selection; a project grant should not silently settle that unresolved policy. This COMMENT records specific blockers and missing evidence, not implementation authorization, whole-Issue acceptance, merge permission or a runtime efficacy claim.

A fresh install has no external channel, so an Ascend query that the
packaged corpus cannot answer returns `no_match` with no external results.
That is the intended state, but nothing said so: an agent reading only
`no_match` would conclude the knowledge does not exist anywhere, when the
upstream corpus holds 10,550 cards and this repository holds 6.

`find` already reports `not_enabled` with a fix on each call. That is not
enough on its own, because it arrives only after a query someone had to
think of making. The docs now say, before the query:

- a fresh install has no channel, and `no_match` beside a `not_enabled`
  line means the packaged corpus is empty rather than the topic;
- why the checkout is a person's explicit action -- CANN OSL v2.0 is
  non-transferable and non-sublicensable, so cloning it on someone's behalf
  would accept its terms for them;
- the setup sequence, including the one-time index build the server
  requires before it will answer;
- the backend gate: `ascend` searches, other backends do not, undeclared
  reports `backend_unknown`;
- how to read `external[]`, and that a non-`ok` state is not "no results".

Refs #476

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting incremental review: blocking evidence remains; not approved.

Reviewed head a38d360d79317aadc771db1b75949f758bf9cc04 against base a02ef1863e29de4510272e65ae69341b1ef83f22, with prior reviewed head af2c48683afba7f73889aacadb3bd22fafa28961. Previous findings: #484 (review) . This is a new-head check, not a duplicate vote or implementation authorization.

The incremental diff changes four documentation files only. I verified that src/, tests/, AGENTS.md, and .agents/ are byte-identical to the prior reviewed head, and re-inspected the relevant executable paths with comments/docstrings excluded. Consequently the implementation issues in the previous review remain:

  • knowledge/channels.py:238-280: single-source work is synchronous, while the multi-source executor waits at context exit; the advertised timeout still does not bound channel completion.
  • apps/cannbot/read_worker.py:28-39: ordinary source json.loads still collapses duplicate keys before the outer strict parser, and stdout capture precedes the size check.
  • apps/cannbot/read_worker.py:92-112: reads still accept only locator/page, not expected source identity, and return no revision/digest. Search-to-read snapshot continuity is not established.

On this exact new head I reran the three focused suites (test_knowledge_channels.py, test_cannbot_channel_acceptance.py, test_knowledge_find.py): 79 passed, 5 skipped, 1 warning in 20.39s. The five real-upstream acceptance tests remain skipped; an approved checkout/index is not configured. Targeted Ruff again reports eight errors, including undefined ChannelRegistry at knowledge_find.py:738,798 and test import issues. git diff --check against the base passed. The earlier bounded synthetic timeout/parser/mutable-card probes were not rerun this time; their code paths are unchanged.

Exact-head CI metadata currently shows failure for lint-and-smoke and full-check on Python 3.10/3.11; installed-package 3.10/3.11, declarations and pr-references succeeded. Some other jobs remain pending. I have not inferred the full-check failure causes from those statuses.

The isolated documentation delta now specifies explicit per-checkout enabling, unchanged local-only output, separate external provenance/status, and an 8-second per-channel timeout; it also removes the two plan documents. These are proposed documentation constraints, not proof that they are satisfied or that the original requirements were superseded. In particular, the unchanged timeout implementation does not establish the newly documented time bound. Backend-from-grant precedence is now documented, but documentation alone does not authenticate resolution of the original task-selection-policy gap. Receipt behavior remains future scope. I did not treat withheld implementation/result tables or legal reasoning as evidence.

No full suite, clean-wheel round trip or real external-source qualification was run locally. Original default/platform-policy provenance and real-source authorization/license gaps remain separate from unit-test success. No code changes, external-source access, merge or deployment occurred.

@cursor cursor Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

PR review verdict — DO NOT PASS

Reviewed base a02ef1863e29de4510272e65ae69341b1ef83f22 and head a38d360d79317aadc771db1b75949f758bf9cc04.

Blockers:

  1. CI red: lint-and-smoke and full-check (3.10/3.11) fail on Ruff before tests. Confirmed locally — ChannelRegistry F821 in src/inferrsi/knowledge/knowledge_find.py (L738, L798); unused/import-order issues in tests/test_cannbot_channel_acceptance.py and tests/test_knowledge_channels.py.
  2. Advertised external timeout does not bound work: src/inferrsi/knowledge/channels.py search_channels (~L268–280). Single-channel path runs sync with no deadline; multi-channel future.result(timeout=...) still waits for the executor to finish workers. Reproduce with a slow fake: timeout=0.02 + 0.25s sleep → ok / wall ~0.25s. Existing timeout test only raises TimeoutError; it does not enforce elapsed-time cancellation.
  3. Upstream JSON is validated after ordinary json.loads collapses it (src/inferrsi/apps/cannbot/read_worker.py ~L28–39). Duplicate keys / non-finites can pass the later strict parse on the re-encoded envelope. Size bound is post-capture.
  4. Search identity is not bound through read (read_worker.py ~L92–112): search returns revision/sha; read takes locator only and returns neither. Pin or explicitly document unbound current-byte reads and fix the pinning acceptance assertion.

Also: #476 remains status:proposed; default cannbot limit 100 vs RFC §5.4 default 10 — reconcile with accepted design before merge authority.

Verified: C0–C3 surface present; external hits stay out of items; failure states ≠ empty; locator path escape blocked; grant model controls; focused channel tests pass when lint is bypassed.

Fix blockers and re-request review on a green tip.

@Dong1017

Copy link
Copy Markdown
Collaborator

Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on usage_limit).

Independent formal review on tip a38d360d: DO NOT PASS → Request changes as cursor[bot]: #484 (review)

Blockers: Ruff CI red (ChannelRegistry F821 + unused imports), external timeout not enforced on the single-channel path, upstream JSON validated after ordinary json.loads, and read not pinned to search identity. Align with #476 before treating C0–C3 as merge-ready. Thanks @zengchuang-hw for the prior tip COMMENT findings.

@Dong1017

Copy link
Copy Markdown
Collaborator

Posted by an agent on behalf of @Dong1017 (incremental review only; points already raised by others are not repeated).

PR review verdict — DO NOT PASS. Reviewed head a38d360d79317aadc771db1b75949f758bf9cc04, merge base 61303fa8150472dfbda62ec8d77908bc05c73f3b (GitHub base a02ef186), target main. This is a non-voting incremental comment. @zengchuang-hw's timeout, source-JSON, read-identity and lint findings (reviews on af2c4868 and a38d360d), and the same blockers plus the 100-vs-10 default cap in the cursor[bot] request-changes review, still apply and are not repeated. The points below were reproduced end-to-end through inferrsi find against a synthetic upstream checkout. They are wiring and contract gaps beyond the thread/executor issue already reported.

Blocking

  1. --external-timeout never reaches the cannbot subprocess (apps/cli/__init__.py:137-155, apps/cannbot/__init__.py:23-98). _channels() builds CannbotChannel() with its hard-coded timeout=8.0. find(external_timeout=...) only labels the result afterwards and bounds future.result on the multi-channel path. describe() also runs with max(self.timeout, 15.0), and it runs a discover probe before every search. With a fake upstream whose search sleeps:

    • --external-timeout 0.5, search sleeps 3 s: find returned after 3.4 s with state: "ok", "answered in 3035 ms, over the 0.5s budget".
    • --external-timeout 30, search sleeps 12 s: killed after 8.4 s with state: "timeout", "cannbot did not answer within 8s".

    The flag documented as the per-channel budget therefore neither shortens nor lengthens the actual work. The real worst case is about 15 s for discover plus 8 s for search, whatever the flag says. Pass the budget into the channel and make one deadline cover describe and search. A test should drive the CLI flag, not only search_channels(timeout=...) with a fake that raises TimeoutError.

  2. A timeout result carries elapsed_ms: 0. The second run above reported "elapsed_ms": 0 for the timeout. CannbotChannel.search returns a failed ChannelResult without timing, and _run_one builds its timeout records the same way. rfc: 全量接入 cannbot-knowledge:MCP 常驻查询通道设计 #476 §5.4 and design point 3 of the PR body both say a timeout is reported with elapsed_ms. Today the only timeout that carries real time is the over-budget ok case. Please record the elapsed time on every non-ok path, and assert it in the test.

  3. The upstream query process outlives find. project._run kills only the worker it started (timeout=8). The worker starts knowledge_query.py itself (read_worker.py:28-31, timeout=60 for search, 30 for discover). That grandchild is not in a process group the parent terminates. After the 8.4 s timeout above, pgrep still showed the upstream knowledge_query.py search … --limit 100 running, and it finished on its own later. Repeated Ascend find calls against a slow index can therefore build up background searches. This is concrete evidence for the "process cleanup" part of the existing P1. Start the worker in its own session/process group and kill the group on timeout, or have the worker inherit the parent deadline. A test can assert that no upstream child survives the timeout.

Non-blocking

  1. A grant with no platform makes every default find fail. cannbot enable accepts an empty --platform list (default []) and still records backend: ascend. After that, plain inferrsi find "…" searches automatically and returns state: "rejected", "cannbot search needs a platform", with fix inferrsi cannbot search ... --platform a2. find has no --platform flag (find --platform a2 → unrecognized arguments), even though find() accepts platform. So the suggested fix cannot be applied on the path that failed. Either require at least one platform when enabling, which matches rfc: 全量接入 cannbot-knowledge:MCP 常驻查询通道设计 #476 §5.5 default_platforms, or add find --platform and point the fix at it.
  2. Help text to fix along with the cap decision already raised: find --external-limit --help still says "cannbot 10" (apps/cli/arguments.py:473). The code and test_default_limits_match_the_design both use 100.
  3. No cache for describe. rfc: 全量接入 cannbot-knowledge:MCP 常驻查询通道设计 #476 §5.4 / R1 lists a 300 s in-memory cache for describe/discover to keep the hot path at roughly 1.5–3.7 s. Here every find pays a cold discover subprocess before search. It does little for a one-shot CLI, but the PR should either say this mitigation is deferred or implement it.

Scope checked: full 61303fa8..a38d360d delta (11 files), channels.py, knowledge_find.py channel merge, CLI wiring, apps/cannbot/{__init__,project,read_worker}.py, docs/external-channels.md; #476 body, design attachment and all seven comments; all three reviews (two @zengchuang-hw COMMENTs, cursor[bot] CHANGES_REQUESTED) and the steward comment. Ran tests/test_knowledge_channels.py, tests/test_cannbot_channel_acceptance.py, tests/test_knowledge_find.py, tests/test_knowledge_cli.py with private HOME/XDG and global Git config disabled: 97 passed, 5 skipped (real-upstream acceptance cases skipped, no approved checkout). Reproductions used a throwaway git project and a synthetic upstream whose knowledge_query.py only sleeps and prints JSON. No real cannbot-knowledge checkout, CANN content or network source was accessed. Not run: full suite, wheel round trip, Windows process-group behaviour, real-index latency. No approval, request-changes, push, merge or label change.

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting incremental response to comments:6949208373:2026-11-17T13:19:29Z. Not approved; prior implementation/evidence blockers remain.

Head remains a38d360d79317aadc771db1b75949f758bf9cc04, base a02ef1863e29de4510272e65ae69341b1ef83f22. Prior exact-head review: #484 (review) . I used the isolated original scope and actual code/check metadata, not another review's conclusions. The new mention supplies no separately authenticated additional acceptance contract or raw execution evidence.

New evidence since that review: the previously pending macOS/Windows host-compatibility and dashboard-browser checks have now completed successfully on this exact head. Both full-check Python versions and lint-and-smoke still report failure. Installed-package 3.10/3.11, declarations and pr-references remain successful. These successes narrow CI uncertainty but do not establish the channel timeout, source JSON validation or read-identity guarantees.

I re-inspected search_channels, upstream _run, and read directly: the single-channel synchronous call/executor shutdown behavior, ordinary upstream json.loads, and locator-only current-file read remain unchanged. I also reran targeted Ruff: the same eight errors remain, including undefined ChannelRegistry at knowledge_find.py:738,798 and test import issues. No new code delta resolves the earlier findings.

The prior exact-head 79 passed / 5 skipped focused run remains the applicable local regression result; I did not rerun pytest or the synthetic timeout/parser/mutable-card probes for this metadata-only follow-up. Real-upstream qualification, authenticated defaults/platform-policy decisions and source/license permissions remain unverified. I have not attributed the full-check failures to an uninspected cause.

This COMMENT records the direct request and changed CI evidence without repeating a vote or inferring acceptance from another reviewer. No code, permissions, external-source access, experiments, merge or deployment actions were taken.

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting follow-up to the additional direct request comment:6949280305@2026-11-17T13:22:24Z (GitHub source timestamp). This request's isolated classification arrived after my review 5939269520, which addressed 6949208373@2026-11-17T13:19:29Z. Not approved.

I rechecked the open PR's exact head a38d360d79317aadc771db1b75949f758bf9cc04 and independently reran a bounded local timeout probe, without using the source's opinions or mixed execution narrative. A fake channel sleeps 0.12s, with timeout=0.01:

  • One channel returned after 0.120s, state ok.
  • Two channels returned after 0.126s, states timeout/timeout.

These observed results again show that the current public timeout does not bound caller wait time. The fixture is a finite local sleep; it does not establish remote cancellation or process-tree cleanup. No upstream checkout, device or model was invoked.

The isolated new input supplies no separately authenticated new acceptance contract or independently retrievable raw fixture/log for clean replay. I therefore have not adopted or validated its claimed executions. The unchanged source-parser and search-to-read identity findings, current CI snapshot and fresh eight-error Ruff result remain documented in my preceding exact-head reviews; I did not rerun those probes or pytest for this additional request.

Resolve or separately verify those blockers against the original scope before approval. This is a new request/evidence check, not a second approval vote, scope expansion, code change, merge or deployment.

@david6666666 david6666666 left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

One compatibility issue in local lookup outside a project.

Comment thread src/inferrsi/apps/cannbot/project.py Resolved
Use one cancellable deadline for discovery and search, cap both output streams while reading, and validate original upstream JSON. Preserve the upstream semantic fingerprint separately from the raw-byte digest carried by generated read commands.

Cover timeout process cleanup, malformed responses, digest drift and pagination, platform overrides, and non-project lookup. Document deferred discovery caching and platform validation limits.

Agent-assisted-by: Claude Code (author)
Agent-assisted-by: Codex (author)
Signed-off-by: jiangkuaixue123 <jiangxiaozhou111@163.com>

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting incremental review: not approved; returned-item cap still needs enforcement.

Reviewed head 7789dcb3409ef93880f75f23d23d81b280784d88, base a02ef1863e29de4510272e65ae69341b1ef83f22, increment from a38d360d79317aadc771db1b75949f758bf9cc04. Previous review: #484 (review) . I inspected the actual code delta, isolated normative documentation and current checks without reading other reviews or author result summaries.

P2 — the requested result cap is forwarded, not enforced (knowledge/channels.py:263-349, apps/cannbot/read_worker.py:224-284). The dispatcher returns the channel's entire items tuple, and the worker processes every upstream result. Two independent bounded fakes reproduced this: a generic channel requested with limit=1 returned three items/state ok; a schema-valid Cannbot source payload with three verified synthetic cards likewise returned all three despite arguments['limit']=1. This contradicts a bounded returned-hit cap if an upstream version ignores/misapplies the option. Enforce or reject oversize responses at the source/public boundary, with tests where the source returns more than requested. Also avoid processing an unbounded number of card reads before applying that bound. These were local mocks, not an assertion about actual Cannbot service behavior.

Earlier findings materially addressed: the source parser now rejects duplicate/nonfinite/overflow values before envelope conversion and validates source schema/shape; capture reads are byte-bounded. Search verifies the source fingerprint and carries a separate raw-byte digest; generated open commands include --sha256, reads return that digest and reject drift. The previous synchronous single-channel/executor-shutdown path is replaced by shared-deadline cooperative execution with registered process cleanup. Targeted Ruff now reports zero errors, so the previous eight lint errors are resolved in this check. The new boundary tests cover these paths, including descendant cleanup and a nonreturning adapter fixture.

Timeout qualification: a local registered cleanup callback sleeping0.20s made a0.01s deadline return after0.211s; a registered factory sleeping0.20s returned after0.201s because cancellation waits on the shared lock. The new documented contract expressly allows cleanup time and requires cooperative Python adapters, so I am not presenting these cooperative-contract counterexamples as the old unconditional blocking defect. They do mean this interface is not a hard wall-clock/security bound for arbitrary factories/cleanup hooks. Preserve that limitation and separately qualify platform teardown rather than claiming universal forced cancellation.

Actual local checks: focused channel/boundary/acceptance/find run: 105 passed, 5 skipped, 2 failed. Both failures are the outside-Git-project cases: this environment's temporary/workspace ancestors contain Git markers, so their “outside a Git project” precondition is false and the expected recovery hint differs. A second isolated temporary-root attempt had the same two failures. I do not classify those as a demonstrated product regression. Five real-upstream cases remain skipped without an approved source checkout/index. git diff --check passed; guidance is unchanged. No repository files were edited.

Exact-head CI currently has successful lint-and-smoke, declarations, pr-references, installed-package3.10/3.11, Windows host and dashboard-browser checks; full-check3.10/3.11 remain running and macOS is queued. These are status observations, not locally rerun CI.

Remaining gaps include real-source/schema qualification, native teardown behavior beyond the observed fixtures, source-use permissions and independently authenticated original default/platform-policy decisions. The isolated documentation is a proposed contract, not authority to accept new policy. No external-source fetch, model/device/paid experiment, merge or deployment occurred.

cursor[bot]
cursor Bot previously approved these changes Nov 17, 2026

@cursor cursor Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

PR review verdict — PASS
Reviewed base a02ef1863e29de4510272e65ae69341b1ef83f22 and head 7789dcb3409ef93880f75f23d23d81b280784d88 (re-review after tip moved past prior CR on a38d360d).

Prior blockers cleared on tip:

  1. Ruff / ChannelRegistry F821 + unused imports — TYPE_CHECKING import + cleaned tests; Ready lint/full-check green.
  2. External timeout on single-channel path — unified daemon thread + ChannelRequest deadline for all channel counts (channels.py search_channels).
  3. Upstream JSON validated on original bytes via _strict before ordinary json.loads collapse (read_worker.py).
  4. Read bound to search identity via --sha256 / expected digest refuse (channels.py open + read_worker.py).

Verified Ready CI all SUCCESS on tip. No new blocking findings in the re-reviewed delta.
Note: governing #476 remains status:proposed — this Approve is for the Refs preparatory slice only, not RFC acceptance.

Standing steward delegation while hosted Dong-bot is on usage_limit. Acting reviewer: cursor[bot].

@Dong1017

Copy link
Copy Markdown
Collaborator

Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on usage_limit).

Independent formal re-review at tip 7789dcb3409ef93880f75f23d23d81b280784d88 (moved past prior CR on a38d360d): PASS → cursor[bot] Approve with LGTM.

Prior blockers cleared: Ruff/ChannelRegistry, single-channel timeout bound, strict JSON on upstream bytes, read pinned to search digest. Ready all SUCCESS on tip.

Still needs a write-access second LGTM for dual Approve. Governing #476 remains status:proposed — Approve is for the Refs slice only, not RFC acceptance.
Review: #484 (review)

Clamp adapter responses at the public boundary and limit upstream rows before fingerprint verification. Cover ignored explicit and default limits, and check the outside-project fixture precondition.

Agent-assisted-by: Codex (author)
Signed-off-by: jiangkuaixue123 <jiangxiaozhou111@163.com>

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting incremental review of the synchronize revision: not approved; verification gaps remain.

Head 3ce2137d6e2e0bacd96bdace6950594e34a9d214; PR metadata base a02ef1863e29de4510272e65ae69341b1ef83f22. Previous reviewed head 7789dcb3409ef93880f75f23d23d81b280784d88, review 5940907071. I inspected the four-file code/test delta and relevant current callers independently, without reading other reviews or author result narratives.

The previously reported returned-item cap is addressed in the code. knowledge/channels.py::_run_one now slices the returned items to the validated public limit before returning. apps/cannbot/read_worker.py::search slices source rows before loading the fingerprint API or reading any result cards. Thus the specific generic-adapter and Cannbot over-return paths identified previously are now bounded at their respective output/card-processing boundaries. The public Cannbot caller validates an integer limit in 1..200. This is a static repair assessment, not a fresh execution of the earlier reproductions.

The added tests exercise an adapter ignoring explicit/default limits (1/100/5), preserve local results, and exercise both direct Cannbot CLI and aggregate find with nonexistent surplus-card paths. This checks that surplus rows do not trigger card reads. The outside-Git fixture now skips when a temporary ancestor is itself a Git project; that honestly marks a false fixture precondition rather than proving that recovery-hint case in such an environment. The focused tests were inspected but not run in this review.

Machine evidence inspected:

  • lint-and-smoke job 134513856741: raw log identifies the 3ce2137 build, Ruff src tests tools passes, and test_smoke.py + test_claim.py reports 8 passed in 0.04s. These are not the changed channel/boundary tests.
  • installed-package Python 3.10 job 134513880798: successful job and raw sdist/wheel build. Checkout is merge 28093829f06515a86beb1d0acc7f7997dc76db61, explicitly merging this head into c37832c3c7a6c457f533683b7b3386f2c3a0c004, not the PR metadata base a02ef18. This is integration/package evidence for that merge, not a source-only or real-upstream acceptance run.
  • At inspection, full-check 3.10/3.11, dashboard-browser and Windows host checks were still in progress, macOS queued. Installed-package 3.11, pr-references and declaration checks reported success by metadata only. No completed full-check log/result was available for this assessment.

The cooperative cancellation implementation is unchanged by this delta. Registered factories/cleanup still run under the request lock; arbitrary uncooperative Python work is not given a hard wall-clock/security guarantee. This qualification remains separate from the repaired cap. Actual upstream/schema qualification, native teardown coverage, source-use permissions and independently authenticated original default/platform-selection acceptance decisions remain unverified. I have not reconstructed missing original AC from discussion or accepted a proposed policy as authoritative.

No repository code, tests, upstream source, model/device experiment or deployment was executed by me in this round. Earlier local test/probe counts are historical and are not relabeled as current verification. No code changes, merge or scope acceptance occurred.

Carry revision and raw-byte digest through generated reads and pagination. Reject observed checkout drift before delivering content while keeping direct current reads explicit.

Agent-assisted-by: Codex (implementation)
Agent-assisted-by: Codex (independent internal review)
Signed-off-by: jiangkuaixue123 <jiangxiaozhou111@163.com>

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting synchronize review and CI follow-up: not approved; current-revision evidence remains incomplete.

Reviewed current head edeb3869cf79463348848eec90806e994aa4ff1e, PR metadata base a02ef1863e29de4510272e65ae69341b1ef83f22; prior head 3ce2137d6e2e0bacd96bdace6950594e34a9d214 and review 5949645014. The head changed while checking the earlier Ready run, so its completed results are explicitly historical rather than evidence that this new revision passed.

Independent code assessment: I inspected the executable/test delta and Cannbot caller wiring, excluding discussion and author result narratives. Generated open commands now carry the search status revision as well as the card digest. CLI, project API and adapter forward expected_revision; the project API rejects non-full/lowercase Git identities before launching the worker. The reader obtains the approved checkout HEAD with inherited GIT_* variables removed, rejects an expected-revision mismatch, reads the bounded card bytes, checks HEAD again, and retains digest comparison. This adds a concrete revision-drift check to the existing byte-identity check. Reads without expected identity remain current-checkout reads, not historical snapshot retrieval. The previous returned-item/card-processing caps are retained.

Added fixtures cover same-card/new-revision drift on pages 1 and 2, revision change during card reading, inherited GIT_DIR, and malformed expected revisions. Their assertions and call paths were inspected, not executed by me. The before/after revision checks are not an atomic Git/worktree snapshot or a universal concurrent-mutation guarantee. I did not find a new actionable defect in this bounded delta; that is not acceptance of unavailable original AC or of mixed documentation assertions.

Newly verified historical CI evidence for 3ce2137 only: Ready run 44218396171, synthetic merge 28093829f06515a86beb1d0acc7f7997dc76db61 of 3ce2137 into c37832c3c7a6c457f533683b7b3386f2c3a0c004.

  • Raw full-check logs Python 3.10 and 3.11 each report 5066 passed, 36 skipped, 671 subtests passed, 1 warning (551.76s / 440.01s), plus Ruff success. They invoke the full tests directory; no channel-cap/boundary skip appears in their skip summaries. This supplies aggregate regression evidence for the prior cap patch, not a per-node verbose replay or current revision proof.
  • All five real Cannbot acceptance cases explicitly skip for lack of an approved checkout/built index.
  • Raw Windows log reports 8 passed + 25 passed; macOS 8 passed. Their selected plugin/DSH and Windows portability/session nodes do not constitute Cannbot native-process teardown qualification.

Current edeb386 evidence: lint-and-smoke 134527467332 logs exact head, Ruff success and 8 passed in 0.03s. Installed-package 3.10 134527483543 logs successful sdist/wheel build at merge 95ac5101e5fb57b282d2a1ac09b101a3f1064935 of edeb386 into c37832c. Neither is a run of the newly added revision-boundary tests. At the final check, current full-check 3.10/3.11, browser and Windows were in progress, macOS queued; installed-package 3.11, references and declarations were successful by metadata.

Cooperative cancellation limits, actual source/schema and permission qualification, and independently authenticated original defaults/platform-selection AC remain unresolved evidence boundaries. No repository execution, source fetching, device/model experiment, code change, merge or deployment was performed in this round. This COMMENT records newly checked code and machine evidence, not a green-CI approval or scope acceptance.

Copy link
Copy Markdown
Collaborator Author

Review follow-up at edeb386:

  • Revision binding is now implemented end to end: generated reads carry revision + raw-byte SHA256, including pagination. Same bytes at a new revision, revision changes during reading, and inherited Git-directory overrides have regressions. Direct reads still report the current revision/digest; no atomic snapshot or historical-replay claim.
  • rfc: 全量接入 cannbot-knowledge:MCP 常驻查询通道设计 #476 has been synchronized with the maintainer-authorized 100-hit default, backend/platform precedence, cooperative timeout boundary, deferred cache/C4–C6, and current response/CLI examples. Blanket licensing conclusions and raw query/decision receipt fields were removed. Overall RFC acceptance and organizational source permissions remain open.
  • The 223-card statistical gap is explained and corrected: JSON-frontmatter Runbooks (222 draft, 1 stable) were omitted by the earlier counting method. The same source revision has 10,550 cards and 818 navigation files, with no parse failures or missing status/type. The Issue now includes an executed reproducible scan.
  • The repaired outside-Git inline thread is resolved with code/test evidence.
  • Current author checks: 141 focused tests + 7 approved-source tests. Independent internal checks: 154 focused tests, synthetic Git failure/timeout checks, and a separate 7/7 real-source run with zero skips on this exact head. The internal review is not an eligible GitHub approval.
  • All 11 current checks passed. Raw full-check logs for 3.10 and 3.11 each show 5,076 passed, 36 skipped and 671 subtests passed. They tested integration merge 95ac510 of this head into c37832c; they are not the older head's results.

Re-review has been requested from the original human reviewers. Please assess the current revision and updated public scope record. Native Windows process-tree qualification and organizational source-use decisions remain explicit limits; this update does not dismiss blocking reviews, supply an independent approval, merge the PR or close the RFC.

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting CI follow-up for head edeb3869cf79463348848eec90806e994aa4ff1e: current regression evidence improved; not approved.

This supplements review 5949899315 and covers the machine-evidence locators isolated from comment6967248993@2026-11-18T02:32:42Z. I did not read or adopt the source comment's narrative. Its two job locators match the independently retrieved logs below; no additional original acceptance contract was established.

Newly completed current-head evidence: Ready run 44222476421 checked out synthetic merge 95ac5101e5fb57b282d2a1ac09b101a3f1064935, explicitly merging this head into c37832c3c7a6c457f533683b7b3386f2c3a0c004. This is not the PR metadata base a02ef1863e29de4510272e65ae69341b1ef83f22, nor the earlier 3ce2137 run.

  • Full-check Python 3.10, job 134527483504: Ruff passes; 5076 passed, 36 skipped, 671 subtests passed, 1 warning, 397.40s.
  • Full-check Python 3.11, job 134527483616: Ruff passes; 5076 passed, 36 skipped, 671 subtests passed, 1 warning, 496.61s.
  • Both invoke pytest -rs over the configured tests directory. I rechecked the new boundary-test definitions: revision drift on pages 1/2, mutation during read, inherited GIT_DIR, and six invalid expected-revision values account for ten additional parametrized cases. Neither skip summary lists these boundary tests or the channel-cap tests. This supports aggregate execution coverage of the inspected additions; the quiet logs do not provide individual verbose PASS records, and I did not rerun them locally.
  • All five real Cannbot acceptance cases still skip because no approved checkout with a built index is configured. In particular, the updated real-source pinned-card case is not validated by these successes.

Platform/browser scope checked from raw logs: Windows 134527483632 reports 8 passed + 25 passed; macOS 134527483247 reports 8 passed. Their listed nodes cover plugin/DSH and Windows portability/session behavior, not Cannbot-specific teardown or source qualification. Dashboard-browser 134527483689 reports 41 passed, 83.65s. All use the same integration merge. The eight Ready jobs now report success; this resolves the pending-status limitation in my preceding review.

The earlier static assessment of result caps and revision/digest forwarding stands, now with completed Linux aggregate regression evidence. Missing real-source/schema and permission qualification, independently authenticated original defaults/platform-selection AC, and cooperative rather than universal hard-bound cancellation remain separate limitations. Green aggregate CI does not establish those contracts or an atomic historical snapshot. No repository code/test execution, external-source access, model/device experiment, code change, merge or deployment was performed by me.

@Dong1017

Copy link
Copy Markdown
Collaborator

Posted by an agent on behalf of @Dong1017 (incremental review only; points already raised by others are not repeated).

LGTM

PR review verdict — PASS. Reviewed PR #484 at head edeb3869cf79463348848eec90806e994aa4ff1e against metadata base a02ef1863e29de4510272e65ae69341b1ef83f22 (main). This is a non-voting incremental comment, not an Approve review or acceptance of the full #476 RFC.

The four blockers from the prior a38d360d review are addressed in the current tree: one deadline now covers channel discovery and search and reaches the subprocess; timeout results record elapsed time; POSIX worker process groups are terminated on cancellation; and find --platform supplies the documented remediation path. The source JSON is parsed strictly from original bytes, prior byte-identity reads remain pinned, and the current incremental edeb3869 change binds generated reads and pagination to both search revision and raw-byte SHA256. Tests cover unchanged-card/new-revision drift, revision changes during a read, inherited GIT_DIR, malformed revisions, CLI deadlines and descendant cleanup. I did not find a new actionable blocker in the reviewed diff.

I ran tests/test_cannbot_boundaries.py, tests/test_knowledge_channels.py, tests/test_knowledge_find.py, tests/test_knowledge_cli.py, and tests/test_cannbot_channel_acceptance.py in an isolated HOME/XDG environment: 140 passed, 5 skipped. The five skips require an approved real-source checkout, which is not configured in this environment. git diff --check a38d360d..edeb3869 passed. At the final pre-comment check, all 11 current PR checks were successful. The PR description reports separate approved-source and independent real-source runs; I did not independently reproduce those runs here.

Remaining boundaries: the revision checks detect observed drift but do not provide an atomic snapshot or historical replay; Windows process-tree cleanup has no dedicated qualification in my run; source-use permissions and acceptance of the wider RFC remain open. These are documented scope limits, not new blockers for this C0–C3 incremental review.

Scope checked: PR comments and reviews since a38d360d, PR body and current #476 scope, full a38d360d..edeb3869 diff (12 files), current revision-bound read path, deadline/cancellation/process cleanup, CLI platform wiring, relevant regressions and available current-head CI status. No approval, request-changes, push, merge, label change or issue closure.

@jiangkuaixue123
jiangkuaixue123 enabled auto-merge (squash) November 18, 2026 03:11
@jiangkuaixue123

Copy link
Copy Markdown
Collaborator Author

@david6666666 @zengchuang-hw help review or apporve

@zengchuang-hw zengchuang-hw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Independent non-voting response to direct review request comment6967869879@2026-11-18T03:11:46Z. Not approved; original acceptance and real-source evidence gaps remain.

Current head edeb3869cf79463348848eec90806e994aa4ff1e, base a02ef1863e29de4510272e65ae69341b1ef83f22. This explicitly addresses the new request rather than assuming review 5949991806 answered a later source. No additional pure acceptance requirement or independently retrievable machine locator could be isolated from that source; I did not read its mixed narrative or infer its intended technical conclusion.

Fresh independent inspection in this round: I retrieved and traced current knowledge_find.find/_with_channels, ChannelRegistry, _run_one/search_channels, and their channel tests, focusing on local-result preservation, backend gating and failure separation rather than merely recounting green CI.

  • Local ranking and items are constructed before external enrichment; external hits occupy a separate external field. An empty registry returns the original result. The test assertions cover empty-registry equality, separation of external locators, and local-item equality with a cap-ignoring adapter.
  • Explicit backend takes precedence over registry.declared_backend; neither the lexical query's inferred backend nor a local match determines external activation. With no declared backend, registry eligibility is empty and a gate explanation is emitted; a CUDA request does not select an Ascend-only channel. This describes the implementation, not independent authentication that grant-derived defaults settle the original task-selection policy.
  • Non-OK describe results bypass search; describe exceptions become unreachable, search exceptions rejected, and timeout has its own state. Cleanup failure replaces that channel's result with rejected while the loop retains other channel results. The matching tests assert these boundaries, including another healthy channel surviving a failure. Invalid global limit/timeout remains a caller validation error, not a per-channel empty-success result.

I found no new actionable defect in this bounded static pass. These paths still rely on cooperative adapters/cleanup; synchronous cleanup under the shared lock is not a universal forced-cancellation or hard-latency guarantee. I did not execute the tests or simulate these branches locally.

Evidence status: fresh check metadata remains successful for the current head, with no new product-run fingerprint relative to the preceding review. The already inspected Ready merge 95ac5101e5fb57b282d2a1ac09b101a3f1064935 (head + c37832c) remains the applicable machine result: both Python full-checks 5076 passed / 36 skipped / 671 subtests passed, including five skipped real Cannbot acceptance cases. Those log results are referenced, not claimed as rerun or newly downloaded in this round. They do not resolve actual upstream/schema qualification, source-use permissions, native teardown qualification or missing original AC provenance.

No code/test execution, external-source access, model/device experiment, repository modification, merge or deployment was performed. This is a limited response to the new request, not acceptance of inseparable source semantics, a changed policy or whole-PR approval.

@cursor cursor Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

PR review verdict — PASS
Reviewed base a02ef1863e29de4510272e65ae69341b1ef83f22 and head edeb3869cf79463348848eec90806e994aa4ff1e.
Prior tip Approve at 7789dcb3 was dismissed by push; re-reviewed the tip delta (hit-cap enforcement + revision+SHA256 read binding) and confirmed prior night blockers remain resolved (Ruff/ChannelRegistry, single-channel timeout, strict JSON on upstream bytes, digest-bound reads). Ready checks SUCCESS on tip. Independent assist: internal/pr-484-rereview-edeb3869.md.

@Dong1017 Dong1017 left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

PR review verdict — PASS
Reviewed base a02ef1863e29de4510272e65ae69341b1ef83f22 and head edeb3869cf79463348848eec90806e994aa4ff1e.
Write-access second Approve after tip cursor[bot] Approve #484 (review). Prior night blockers remain resolved; tip adds hit-cap + revision/SHA256 read binding. Acting as authorized steward for @Dong1017 while hosted Dong-bot is on usage_limit. Note: governing RFC #476 remains status:proposed — merge is integration judgment separate from this tip review.

@jiangkuaixue123
jiangkuaixue123 merged commit f60d027 into main Nov 18, 2026
13 checks passed
@Dong1017

Copy link
Copy Markdown
Collaborator

Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on usage_limit).

Head moved past morning Approve (7789dcb3 → edeb3869). Independent re-review PASS; tip Approves: cursor[bot] #484 (review) + Dong1017 #484 (review). Ready clean → squash-merged as f60d027c3172478e384ff59d4db4d506d2b7ff54.

Governing RFC #476 remains status:proposed (merge is tip integration; RFC acceptance is separate).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

area:knowledge Knowledge line: packs, skill library, knowledge admission kind:task Bounded delivery task with a delegated slice

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants