Repository navigation
feat(knowledge): add external read-only channels to find - #484
Conversation
`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>
zengchuang-hw
left a comment
There was a problem hiding this comment.
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.
-
P1 — the advertised timeout does not bound channel work (
knowledge/channels.py:238-280). The single-channel branch callsworksynchronously without a deadline. The multi-channel branch times outfuture.result, then exits aThreadPoolExecutorcontext that waits for unfinished workers. A bounded local fake sleeping 0.25s withtimeout=0.02reproduced: one channel returned after 0.250s with stateok; 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 raiseTimeoutError, 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. -
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 ordinaryjson.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":{}},discoveracceptedcards=2. ANaNsource 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 aftersubprocess.runhas captured stdout, so it is a post-capture size rejection, not a memory-bounded reader. -
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 namedtest_read_returns_one_pinned_cardpresently asserts only state, locator and nonempty text, so it does not establish pinning. -
The changed files do not pass lint. A local targeted Ruff check found eight errors: undefined
ChannelRegistryannotations inknowledge_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
left a comment
There was a problem hiding this comment.
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 sourcejson.loadsstill 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.
There was a problem hiding this comment.
PR review verdict — DO NOT PASS
Reviewed base a02ef1863e29de4510272e65ae69341b1ef83f22 and head a38d360d79317aadc771db1b75949f758bf9cc04.
Blockers:
- CI red:
lint-and-smokeandfull-check(3.10/3.11) fail on Ruff before tests. Confirmed locally —ChannelRegistryF821 insrc/inferrsi/knowledge/knowledge_find.py(L738, L798); unused/import-order issues intests/test_cannbot_channel_acceptance.pyandtests/test_knowledge_channels.py. - Advertised external timeout does not bound work:
src/inferrsi/knowledge/channels.pysearch_channels(~L268–280). Single-channel path runs sync with no deadline; multi-channelfuture.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 raisesTimeoutError; it does not enforce elapsed-time cancellation. - Upstream JSON is validated after ordinary
json.loadscollapses 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. - 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.
|
Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on Independent formal review on tip Blockers: Ruff CI red ( |
|
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 Blocking
Non-blocking
Scope checked: full |
zengchuang-hw
left a comment
There was a problem hiding this comment.
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
left a comment
There was a problem hiding this comment.
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
left a comment
There was a problem hiding this comment.
One compatibility issue in local lookup outside a project.
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
left a comment
There was a problem hiding this comment.
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.
There was a problem hiding this comment.
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:
- Ruff /
ChannelRegistryF821 + unused imports — TYPE_CHECKING import + cleaned tests; Ready lint/full-check green. - External timeout on single-channel path — unified daemon thread +
ChannelRequestdeadline for all channel counts (channels.pysearch_channels). - Upstream JSON validated on original bytes via
_strictbefore ordinaryjson.loadscollapse (read_worker.py). - Read bound to search identity via
--sha256/ expected digest refuse (channels.pyopen +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].
|
Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on Independent formal re-review at tip Prior blockers cleared: Ruff/ Still needs a write-access second |
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
left a comment
There was a problem hiding this comment.
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 toolspasses, andtest_smoke.py + test_claim.pyreports 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 intoc37832c3c7a6c457f533683b7b3386f2c3a0c004, 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
left a comment
There was a problem hiding this comment.
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.
|
Review follow-up at edeb386:
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
left a comment
There was a problem hiding this comment.
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 -rsover 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.
|
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 The four blockers from the prior I ran 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 |
|
@david6666666 @zengchuang-hw help review or apporve |
zengchuang-hw
left a comment
There was a problem hiding this comment.
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
itemsare constructed before external enrichment; external hits occupy a separateexternalfield. 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.
There was a problem hiding this comment.
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
left a comment
There was a problem hiding this comment.
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.
|
Posted by an authorized steward agent on behalf of @Dong1017 (hosted Dong-bot on Head moved past morning Approve ( Governing RFC #476 remains |
Refs #476
This C0–C3 slice lets
findquery 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 inexternal[].Behavior and review corrections
--revisionand--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.card_sha256is a parsed-card fingerprint, retained assource_card_sha256and verified using the approved checkout's implementation. Publiccard_sha256identifies the raw bytes used for reads. Search does not return card bodies or private paths.find --platformoverrides the grant platform. Missing platform gives actionable guidance. Both ordinary and explicit-Ascend lookup outside Git reportnot_enabledand retain local results.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-externalstarts 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 toolsandgit diff --check: successful.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.pytest -o addopts='' -q tests/test_cannbot_channel_acceptance.py— 7 passed, source revision92dc260756e91e72e6dcd60f3996a4d54f43c8f5. Includes actual revision-and-digest-bound read, six-query retrieval and unchanged local ordering.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.95ac5101e5fb57b282d2a1ac09b101a3f1064935of this head intoc37832c3c7a6c457f533683b7b3386f2c3a0c004, not the PR metadata basea02ef186. 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
a38d360din a separate checkout under the same environment. They involve missingpythonon 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:
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 /Fwhile 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.