nsaspy/zara-plugins
1
0
Fork 0
Code Issues 10 Pull requests 297 Projects Releases Packages Wiki Activity Actions

[WORKER] Symbolics+Dev — Prolog, coding, memory and verified-automation hardening loop #53

New issue
Open
opened 2026-09-08 02:02:52 +00:00 by nsaspy · 19 comments
nsaspy commented 2026-09-08 02:02:52 +00:00
Owner
Copy link

Mission

Continuously expand Zara's symbolic/developer capability while making it harder to lie to itself. Own the Prolog-heavy plugin surface, verified coding automation, memory/expert composition and evidence-driven system operations.

Stagger slot

fleet_cycle = 2h
slot = +60m

Start one hour after Frontier Research and 15 minutes after Voice+Models. Preserve relative ordering if cadence changes.

Primary queue

  1. zara-coding Prolog-RLM harness slices that satisfy current Core contracts;
  2. zara-expert real SWI-Prolog backend and safe cross-plugin expert composition;
  3. zara-memory + symbolic-memory integration with provenance/scope/truth-maintenance-compatible semantics;
  4. zara-sysadmin production Linux/Nix observations and verified bounded remediation;
  5. zara-healthcheck production probes and symbolic fact/evidence export;
  6. zara-shell cancellation/security/correctness hardening only as a bounded primitive;
  7. plugin/Core composition blockers such as canonical cancellation and capability invocation through focused handoff issues.

Current architecture reconciliation

Current Zara master may consume pinned Prolog-RLM in explicitly bounded direct-mode paths. The old blanket statement that Core can never have a Prolog-RLM runtime dependency is stale.

The invariant that remains:

  • Prolog/typed runtime policy and canonical Zara capability authorization own effects;
  • model/RLM output is proposal/data until validated;
  • no arbitrary model-provided Prolog goal becomes trusted execution;
  • plugin symbolic state must not create a parallel authority, task store or assistant runtime;
  • capabilities can be narrowed, never invented by a model/child plan.

Feature-expansion targets

Prefer capabilities that make Zara meaningfully more inspectable and useful:

  • reusable plugin expert predicates and explanations;
  • symbolic task/spec/verification state;
  • repository/worktree/test/CI evidence in zara-coding;
  • project/user scoped symbolic memory;
  • proof-oriented health/sysadmin diagnosis;
  • structured plugin composition through Core-owned capability seams;
  • deterministic/offline reasoning paths useful on low-power/Android profiles.

Deep-testing contract

Every slice must test the trust boundary, not only happy predicates.

Required where applicable:

  1. PLUnit for pure Prolog semantics;
  2. Python unit/integration tests for host bridges;
  3. property/generative tests for state transitions, serialization, budgets and malformed terms;
  4. malicious terms including call/1, directives, module-qualified goals, cyclic/deep terms and oversized inputs;
  5. cancellation, worker crash, stale state, restart and concurrent-task isolation;
  6. negative authorization/capability tests;
  7. exact-head plugin registry + full tests + nix flake check.

Never count a model assertion, subprocess exit zero or provider acknowledgement as verification evidence by itself.

Cross-plugin composition rule

Do not import another plugin's private Python implementation to get work done. Consume canonical Core capability composition when available; otherwise file a focused Core blocker and move to a different dependency-satisfied slice.

State loop

worker = symbolics-dev
mode = RESEARCH | IMPLEMENT | REVIEW
  • RESEARCH: inspect exact current contracts/upstream Prolog-RLM/symbolic-memory heads and choose one bounded slice.
  • IMPLEMENT: worktree, RED first, minimum implementation, focused + full gates, PR.
  • REVIEW: attack authority, evidence provenance, stale/CAS behavior, failure semantics and extraction boundaries; independent cross-repo review remains #646.

Output contract

WORKER_STATE
worker: symbolics-dev
mode_used: <RESEARCH|IMPLEMENT|REVIEW>
result: <one-line outcome>
issue_or_pr: <refs or none>
head: <sha or none>
prolog_tests: <PLUnit/property/adversarial summary>
integration_tests: <summary>
verification_evidence: <what proves success>
core_handoffs: <refs or none>
blockers: <summary or none>
next_mode: <RESEARCH|IMPLEMENT|REVIEW>
next_target: <specific slice>

Guardrails

  • Never commit directly to main.
  • No unrestricted Prolog goal/eval or shell surface.
  • Desired state, observed state, authorization and verification remain separate.
  • No false completion from model claims.
  • Keep generic symbolic logic extraction-friendly where the owning architecture requires it.
## Mission Continuously expand Zara's symbolic/developer capability while making it harder to lie to itself. Own the Prolog-heavy plugin surface, verified coding automation, memory/expert composition and evidence-driven system operations. ## Stagger slot ```text fleet_cycle = 2h slot = +60m ``` Start one hour after Frontier Research and 15 minutes after Voice+Models. Preserve relative ordering if cadence changes. ## Primary queue 1. `zara-coding` Prolog-RLM harness slices that satisfy current Core contracts; 2. `zara-expert` real SWI-Prolog backend and safe cross-plugin expert composition; 3. `zara-memory` + symbolic-memory integration with provenance/scope/truth-maintenance-compatible semantics; 4. `zara-sysadmin` production Linux/Nix observations and verified bounded remediation; 5. `zara-healthcheck` production probes and symbolic fact/evidence export; 6. `zara-shell` cancellation/security/correctness hardening only as a bounded primitive; 7. plugin/Core composition blockers such as canonical cancellation and capability invocation through focused handoff issues. ## Current architecture reconciliation Current Zara `master` may consume pinned Prolog-RLM in explicitly bounded direct-mode paths. The old blanket statement that Core can never have a Prolog-RLM runtime dependency is stale. The invariant that remains: - Prolog/typed runtime policy and canonical Zara capability authorization own effects; - model/RLM output is proposal/data until validated; - no arbitrary model-provided Prolog goal becomes trusted execution; - plugin symbolic state must not create a parallel authority, task store or assistant runtime; - capabilities can be narrowed, never invented by a model/child plan. ## Feature-expansion targets Prefer capabilities that make Zara meaningfully more inspectable and useful: - reusable plugin expert predicates and explanations; - symbolic task/spec/verification state; - repository/worktree/test/CI evidence in `zara-coding`; - project/user scoped symbolic memory; - proof-oriented health/sysadmin diagnosis; - structured plugin composition through Core-owned capability seams; - deterministic/offline reasoning paths useful on low-power/Android profiles. ## Deep-testing contract Every slice must test the trust boundary, not only happy predicates. Required where applicable: 1. PLUnit for pure Prolog semantics; 2. Python unit/integration tests for host bridges; 3. property/generative tests for state transitions, serialization, budgets and malformed terms; 4. malicious terms including `call/1`, directives, module-qualified goals, cyclic/deep terms and oversized inputs; 5. cancellation, worker crash, stale state, restart and concurrent-task isolation; 6. negative authorization/capability tests; 7. exact-head plugin registry + full tests + `nix flake check`. Never count a model assertion, subprocess exit zero or provider acknowledgement as verification evidence by itself. ## Cross-plugin composition rule Do not import another plugin's private Python implementation to get work done. Consume canonical Core capability composition when available; otherwise file a focused Core blocker and move to a different dependency-satisfied slice. ## State loop ```text worker = symbolics-dev mode = RESEARCH | IMPLEMENT | REVIEW ``` - RESEARCH: inspect exact current contracts/upstream Prolog-RLM/symbolic-memory heads and choose one bounded slice. - IMPLEMENT: worktree, RED first, minimum implementation, focused + full gates, PR. - REVIEW: attack authority, evidence provenance, stale/CAS behavior, failure semantics and extraction boundaries; independent cross-repo review remains #646. ## Output contract ```text WORKER_STATE worker: symbolics-dev mode_used: <RESEARCH|IMPLEMENT|REVIEW> result: <one-line outcome> issue_or_pr: <refs or none> head: <sha or none> prolog_tests: <PLUnit/property/adversarial summary> integration_tests: <summary> verification_evidence: <what proves success> core_handoffs: <refs or none> blockers: <summary or none> next_mode: <RESEARCH|IMPLEMENT|REVIEW> next_target: <specific slice> ``` ## Guardrails - Never commit directly to `main`. - No unrestricted Prolog goal/eval or shell surface. - Desired state, observed state, authorization and verification remain separate. - No false completion from model claims. - Keep generic symbolic logic extraction-friendly where the owning architecture requires it.
nsaspy commented 2026-09-08 02:17:45 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: plugin-c
mode_used: IMPLEMENT
result: Hardened zara-coding symbolic task completion so caller/model-authored evidence cannot masquerade as verifier-owned passing evidence; provenance is now enforced at the Prolog protocol boundary, not only the public Python wrapper.
issue_or_pr: zara-plugins#1, zara-plugins#511; Core composition remains tracked by lost-rob0t/zara#400
head: 1bf3523b16
tests: TDD regression added first for direct SWI-Prolog protocol provenance; PR diff audited. Exact-head CI run 34096236914 is in progress on this SHA; whitespace and compatibility-gate contract steps are green, registry/plugin tests and package/Nix gates are still pending.
blockers: No blocker for this bounded hardening slice. Cross-plugin planning/execution expansion remains blocked on canonical Core PluginRuntime composition contract lost-rob0t/zara#400; do not import plugin/Core internals around it.
next_mode: REVIEW
next_target: Adversarially review zara-plugins#511 at exact head after CI, focusing on whether verifier provenance can be forged through any callable/public path, whether failed observations correctly revoke prior passes, and whether completion can still report false success under stale or malformed evidence.

WORKER_STATE worker: plugin-c mode_used: IMPLEMENT result: Hardened zara-coding symbolic task completion so caller/model-authored evidence cannot masquerade as verifier-owned passing evidence; provenance is now enforced at the Prolog protocol boundary, not only the public Python wrapper. issue_or_pr: zara-plugins#1, zara-plugins#511; Core composition remains tracked by lost-rob0t/zara#400 head: 1bf3523b16aa3bf8ac769e9f427a10e118f3f81c tests: TDD regression added first for direct SWI-Prolog protocol provenance; PR diff audited. Exact-head CI run 34096236914 is in progress on this SHA; whitespace and compatibility-gate contract steps are green, registry/plugin tests and package/Nix gates are still pending. blockers: No blocker for this bounded hardening slice. Cross-plugin planning/execution expansion remains blocked on canonical Core PluginRuntime composition contract lost-rob0t/zara#400; do not import plugin/Core internals around it. next_mode: REVIEW next_target: Adversarially review zara-plugins#511 at exact head after CI, focusing on whether verifier provenance can be forged through any callable/public path, whether failed observations correctly revoke prior passes, and whether completion can still report false success under stale or malformed evidence.
nsaspy commented 2026-09-08 02:17:45 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review of zara-plugins#511 confirmed caller-authored passing evidence is rejected and CI is green, but found a blocking false-success path: declared completion_criteria are stored yet never required to have current verifier-owned passing evidence, so a multi-criterion task can complete after only one passing verifier observation.
refs: zara-plugins#511 review 5129663621; CI run 34096236914; Core composition remains lost-rob0t/zara#400
head: 1bf3523b16
tests: Exact-head CI run 34096236914 completed success. Existing adversarial coverage proves caller-authored pass rejection, unknown provenance rejection, later same-kind failure revocation, and current failure in another verifier blocks completion. Review inspection found the missing-criterion case is not covered and currently succeeds by construction in passing_evidence/1.
blockers: PR #511 is not semantically merge-ready until completion criteria are reconciled against current verifier-owned evidence. No Core blocker for this bounded repair; zara#400 still blocks only cross-plugin composition expansion.
next_mode: IMPLEMENT
next_target: On PR #511 branch, add RED Prolog/Python regression for a task with multiple declared completion criteria and missing verifier evidence, then minimally require every declared criterion to have current verifier-owned passing evidence while preserving caller-pass rejection and later-failure revocation; run focused + registry + exact-head Nix/CI gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review of zara-plugins#511 confirmed caller-authored passing evidence is rejected and CI is green, but found a blocking false-success path: declared completion_criteria are stored yet never required to have current verifier-owned passing evidence, so a multi-criterion task can complete after only one passing verifier observation. refs: zara-plugins#511 review 5129663621; CI run 34096236914; Core composition remains lost-rob0t/zara#400 head: 1bf3523b16aa3bf8ac769e9f427a10e118f3f81c tests: Exact-head CI run 34096236914 completed success. Existing adversarial coverage proves caller-authored pass rejection, unknown provenance rejection, later same-kind failure revocation, and current failure in another verifier blocks completion. Review inspection found the missing-criterion case is not covered and currently succeeds by construction in passing_evidence/1. blockers: PR #511 is not semantically merge-ready until completion criteria are reconciled against current verifier-owned evidence. No Core blocker for this bounded repair; zara#400 still blocks only cross-plugin composition expansion. next_mode: IMPLEMENT next_target: On PR #511 branch, add RED Prolog/Python regression for a task with multiple declared completion criteria and missing verifier evidence, then minimally require every declared criterion to have current verifier-owned passing evidence while preserving caller-pass rejection and later-failure revocation; run focused + registry + exact-head Nix/CI gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Rebuilt the stale/non-mergeable #511 repair from current main as #515 and closed the false-success path: every declared completion criterion is now a verifier key whose latest evidence must be verifier-owned and passed; caller/model-authored passes are rejected at the Prolog boundary and later failures revoke prior passes.
refs: zara-plugins#515; supersedes closed zara-plugins#511; CI run 34106704465; Core composition handoff remains lost-rob0t/zara#400
head: f868fe1052
tests: RED direct SWI-Prolog regression committed first at 254a88b14c covering caller-authored pass rejection, missing criterion evidence, unrelated verifier evidence, and later-failure revocation. Exact-head CI run 34106704465 completed success: whitespace, compatibility contract/source/installed checks, registry + plugin tests, package builds, and avatar CPU budget all green.
blockers: No blocker for this bounded repair. Cross-plugin planning/execution expansion remains blocked on canonical Core PluginRuntime composition contract lost-rob0t/zara#400; no Core internals were imported or bypassed.
next_mode: REVIEW
next_target: Adversarially review #515 at exact head for criterion/evidence-key semantics, caller-failure revocation, malformed provenance/status handling, empty-criteria fallback, stale evidence behavior, and preservation of current-main zara-coding lifecycle before considering merge.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Rebuilt the stale/non-mergeable #511 repair from current main as #515 and closed the false-success path: every declared completion criterion is now a verifier key whose latest evidence must be verifier-owned and passed; caller/model-authored passes are rejected at the Prolog boundary and later failures revoke prior passes. refs: zara-plugins#515; supersedes closed zara-plugins#511; CI run 34106704465; Core composition handoff remains lost-rob0t/zara#400 head: f868fe1052b9ec3c8ef8af042bfc8c57d49f71f7 tests: RED direct SWI-Prolog regression committed first at 254a88b14c78b0fcd0bb1dd29216b3940697722f covering caller-authored pass rejection, missing criterion evidence, unrelated verifier evidence, and later-failure revocation. Exact-head CI run 34106704465 completed success: whitespace, compatibility contract/source/installed checks, registry + plugin tests, package builds, and avatar CPU budget all green. blockers: No blocker for this bounded repair. Cross-plugin planning/execution expansion remains blocked on canonical Core PluginRuntime composition contract lost-rob0t/zara#400; no Core internals were imported or bypassed. next_mode: REVIEW next_target: Adversarially review #515 at exact head for criterion/evidence-key semantics, caller-failure revocation, malformed provenance/status handling, empty-criteria fallback, stale evidence behavior, and preservation of current-main zara-coding lifecycle before considering merge.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head adversarial review of #515 found a stale-state false-success blocker: verifier evidence is criterion/provenance checked, but it is not bound to the repository snapshot and completion does not re-inspect current repo identity, so an H1 pass can complete after the worktree advances to H2.
issue_or_pr: zara-plugins#515 review comment 5569246889; Core composition remains lost-rob0t/zara#400
refs: zara-plugins#515; CI run 34106704465; review comment 5569246889
head: f868fe1052
prolog_tests: Existing direct SWI-Prolog regressions cover caller-authored pass rejection, criterion-key matching, missing/unrelated evidence, and later same-kind failure revocation. Missing adversarial coverage: verifier pass at repository head H1 followed by repository mutation/head H2 must make completion fail closed.
integration_tests: Exact-head CI run 34106704465 is completed/success on f868fe1052. Current Python public tool rejects caller-authored passing evidence, but task completion performs no fresh repository inspection.
verification_evidence: Source inspection at exact head shows task_create snapshots root/head/branch, task_complete delegates directly to Prolog, evidence stores only kind/status/detail/provenance, and current_verifier_pass/2 checks only latest evidence by kind/status/provenance. Therefore repository movement cannot invalidate prior passes.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed for this bounded repair.
blockers: #515 is not semantically merge-ready until verifier evidence is tied to the observed repository identity or completion re-inspects and rejects stale evidence. No new Core blocker required.
next_mode: IMPLEMENT
next_target: On #515 branch, add RED H1-pass -> repository changes to H2 -> completion-rejected regression, then minimally add snapshot/CAS semantics so verifier evidence is valid only for the repository identity it observed; preserve provenance rejection, criterion matching, and later-failure revocation, then rerun focused + registry + exact-head Nix/CI gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head adversarial review of #515 found a stale-state false-success blocker: verifier evidence is criterion/provenance checked, but it is not bound to the repository snapshot and completion does not re-inspect current repo identity, so an H1 pass can complete after the worktree advances to H2. issue_or_pr: zara-plugins#515 review comment 5569246889; Core composition remains lost-rob0t/zara#400 refs: zara-plugins#515; CI run 34106704465; review comment 5569246889 head: f868fe1052b9ec3c8ef8af042bfc8c57d49f71f7 prolog_tests: Existing direct SWI-Prolog regressions cover caller-authored pass rejection, criterion-key matching, missing/unrelated evidence, and later same-kind failure revocation. Missing adversarial coverage: verifier pass at repository head H1 followed by repository mutation/head H2 must make completion fail closed. integration_tests: Exact-head CI run 34106704465 is completed/success on f868fe1052b9ec3c8ef8af042bfc8c57d49f71f7. Current Python public tool rejects caller-authored passing evidence, but task completion performs no fresh repository inspection. verification_evidence: Source inspection at exact head shows task_create snapshots root/head/branch, task_complete delegates directly to Prolog, evidence stores only kind/status/detail/provenance, and current_verifier_pass/2 checks only latest evidence by kind/status/provenance. Therefore repository movement cannot invalidate prior passes. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed for this bounded repair. blockers: #515 is not semantically merge-ready until verifier evidence is tied to the observed repository identity or completion re-inspects and rejects stale evidence. No new Core blocker required. next_mode: IMPLEMENT next_target: On #515 branch, add RED H1-pass -> repository changes to H2 -> completion-rejected regression, then minimally add snapshot/CAS semantics so verifier evidence is valid only for the repository identity it observed; preserve provenance rejection, criterion matching, and later-failure revocation, then rerun focused + registry + exact-head Nix/CI gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Closed the stale-repository false-success path on #515: completion now re-reads the Prolog-owned task snapshot, freshly inspects the stored repository root, and rejects head/branch/root drift or a dirty worktree before Prolog can mark the task complete.
issue_or_pr: zara-plugins#515; implementation note 5569992906; Core composition remains lost-rob0t/zara#400
refs: RED test commit 0d26d2ea78; implementation 16b6712c83; exact-head cleanup 6acd3ded79; CI run 34116965490
head: 6acd3ded79
prolog_tests: Existing direct SWI-Prolog adversarial regressions remain green for verifier provenance, criterion-key matching, missing/unrelated evidence, and later-failure revocation; this slice did not change Prolog semantics.
integration_tests: Added H1 snapshot -> H2 observed repository -> completion rejected regression first. Exact-head CI run 34116965490 completed success: whitespace, compatibility contract/source/installed checks, registry + plugin tests, package builds, and avatar CPU budget all green.
verification_evidence: The new public completion path obtains the durable task repository identity from Prolog state, performs a fresh repository inspection, rejects mismatched root/head/branch and dirty worktrees, and only then delegates to Prolog completion. CI is green on the exact head above.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed here.
blockers: No blocker for this bounded repair. Remaining semantic risk is the inspect->complete TOCTOU window: repository state can theoretically change after the fresh inspection but before Prolog completion, so the recheck is fail-closed for observed stale state but not yet an atomic CAS.
next_mode: REVIEW
next_target: Adversarially review #515 at exact head 6acd3ded for inspect->complete TOCTOU/CAS semantics, dirty-state coverage, malformed/missing repository snapshot handling, repository-root substitution/symlink behavior, and whether verifier evidence can still outlive the exact repository identity it observed; require a precise blocker or merge-ready conclusion from evidence.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Closed the stale-repository false-success path on #515: completion now re-reads the Prolog-owned task snapshot, freshly inspects the stored repository root, and rejects head/branch/root drift or a dirty worktree before Prolog can mark the task complete. issue_or_pr: zara-plugins#515; implementation note 5569992906; Core composition remains lost-rob0t/zara#400 refs: RED test commit 0d26d2ea78c5f6cb2024a51dc21d23507ba587ea; implementation 16b6712c83437a33e87fa2d9658e7666501cbe39; exact-head cleanup 6acd3ded796fd77f6744741f6205747886305eb0; CI run 34116965490 head: 6acd3ded796fd77f6744741f6205747886305eb0 prolog_tests: Existing direct SWI-Prolog adversarial regressions remain green for verifier provenance, criterion-key matching, missing/unrelated evidence, and later-failure revocation; this slice did not change Prolog semantics. integration_tests: Added H1 snapshot -> H2 observed repository -> completion rejected regression first. Exact-head CI run 34116965490 completed success: whitespace, compatibility contract/source/installed checks, registry + plugin tests, package builds, and avatar CPU budget all green. verification_evidence: The new public completion path obtains the durable task repository identity from Prolog state, performs a fresh repository inspection, rejects mismatched root/head/branch and dirty worktrees, and only then delegates to Prolog completion. CI is green on the exact head above. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed here. blockers: No blocker for this bounded repair. Remaining semantic risk is the inspect->complete TOCTOU window: repository state can theoretically change after the fresh inspection but before Prolog completion, so the recheck is fail-closed for observed stale state but not yet an atomic CAS. next_mode: REVIEW next_target: Adversarially review #515 at exact head 6acd3ded for inspect->complete TOCTOU/CAS semantics, dirty-state coverage, malformed/missing repository snapshot handling, repository-root substitution/symlink behavior, and whether verifier evidence can still outlive the exact repository identity it observed; require a precise blocker or merge-ready conclusion from evidence.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head adversarial review of #515 confirmed the H1→H2 stale-observation fix but found a remaining false-success blocker: the final repository inspection and Prolog completion transition are not CAS-bound, so repo state can change after inspect() returns and before Prolog marks the task completed.
issue_or_pr: zara-plugins#515 review comment 5570661370; Core composition remains lost-rob0t/zara#400
refs: zara-plugins#515; exact head 6acd3ded79; prior green CI run 34116965490; review comment 5570661370
head: 6acd3ded79
prolog_tests: Existing direct SWI-Prolog regressions remain valid for verifier provenance, criterion-key matching, missing/unrelated evidence, and later same-kind failure revocation. Review found the authoritative complete operation still accepts only task_id and has no repository snapshot/generation precondition.
integration_tests: Prior exact-head CI run 34116965490 is green. Source inspection confirms RepositoryInspector double-reads HEAD/branch/changed paths during inspect and fails if they move during inspection, but task_complete then calls session.complete_task(task_id) after inspect returns, leaving an untested mutation window between observation and state transition.
verification_evidence: At exact head, Python task_complete() performs get_task -> inspect(stored root) -> compare root/head/branch+dirty -> session.complete_task(task_id); Prolog dispatch_op("complete", ...) receives only task_id, rechecks dependencies/evidence, and transitions state without any expected repository identity. This permits stale success if HEAD/branch/dirty state changes in the inspect->complete gap.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition handoff; not needed for this repair and no Core internals should be imported.
blockers: #515 remains not semantically merge-ready because observed repository state and authoritative completion are not atomic/CAS-bound. No new Core blocker required.
next_mode: IMPLEMENT
next_target: On #515 branch, add a RED regression that mutates repository state after successful inspect() returns but before Prolog completion, then minimally add an expected repository snapshot/generation precondition to the authoritative completion transition (or equivalent serialized CAS boundary) so the transition rejects stale state; preserve verifier provenance/criterion semantics and rerun focused + registry + exact-head Nix/CI gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head adversarial review of #515 confirmed the H1→H2 stale-observation fix but found a remaining false-success blocker: the final repository inspection and Prolog completion transition are not CAS-bound, so repo state can change after inspect() returns and before Prolog marks the task completed. issue_or_pr: zara-plugins#515 review comment 5570661370; Core composition remains lost-rob0t/zara#400 refs: zara-plugins#515; exact head 6acd3ded796fd77f6744741f6205747886305eb0; prior green CI run 34116965490; review comment 5570661370 head: 6acd3ded796fd77f6744741f6205747886305eb0 prolog_tests: Existing direct SWI-Prolog regressions remain valid for verifier provenance, criterion-key matching, missing/unrelated evidence, and later same-kind failure revocation. Review found the authoritative `complete` operation still accepts only task_id and has no repository snapshot/generation precondition. integration_tests: Prior exact-head CI run 34116965490 is green. Source inspection confirms RepositoryInspector double-reads HEAD/branch/changed paths during inspect and fails if they move during inspection, but task_complete then calls session.complete_task(task_id) after inspect returns, leaving an untested mutation window between observation and state transition. verification_evidence: At exact head, Python `task_complete()` performs get_task -> inspect(stored root) -> compare root/head/branch+dirty -> `session.complete_task(task_id)`; Prolog `dispatch_op("complete", ...)` receives only task_id, rechecks dependencies/evidence, and transitions state without any expected repository identity. This permits stale success if HEAD/branch/dirty state changes in the inspect->complete gap. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition handoff; not needed for this repair and no Core internals should be imported. blockers: #515 remains not semantically merge-ready because observed repository state and authoritative completion are not atomic/CAS-bound. No new Core blocker required. next_mode: IMPLEMENT next_target: On #515 branch, add a RED regression that mutates repository state after successful inspect() returns but before Prolog completion, then minimally add an expected repository snapshot/generation precondition to the authoritative completion transition (or equivalent serialized CAS boundary) so the transition rejects stale state; preserve verifier provenance/criterion semantics and rerun focused + registry + exact-head Nix/CI gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Added a RED-first regression for the inspect→complete race on #515 and moved the final repository snapshot validation into the TaskStateSession completion critical section, so repository movement injected after the outer inspect is rejected before the authoritative Prolog complete operation is issued.
issue_or_pr: zara-plugins#515; implementation note 5571465557; Core composition remains lost-rob0t/zara#400
refs: RED test 380e3fad72; session CAS boundary f6c53b2da3; plugin wiring efe6c305a0; exact head 4a5d57bf14; CI run 34128323863
head: 4a5d57bf14
prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation regressions were preserved; this slice did not expand callable Prolog authority or change the Prolog evidence model.
integration_tests: RED race regression added first. Exact-head CI run 34128323863 is running on 4a5d57bf; whitespace and compatibility-contract setup are green so far, while source/installed diagnostics, registry+plugin tests, package builds, and avatar CPU gate are still in progress/pending.
verification_evidence: task_complete still performs an outer stale/dirty check, then calls TaskStateSession.complete_task with the durable expected repository snapshot and a bounded validator; complete_task holds its RLock, revalidates the repository immediately before issuing the Prolog complete request, and rejects stale state without transitioning. This closes the previously demonstrated plugin-operation interleaving window, though external Git writers are not made filesystem-atomic by this lock.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition blocker and was not bypassed.
blockers: Exact-head CI has not completed yet. Also, the session RLock serializes Zara task-state operations but cannot make arbitrary external Git ref/index writes atomic with the Prolog transition; REVIEW must decide whether the remaining external-writer micro-window is acceptable or needs a stronger repository CAS/lease primitive.
next_mode: REVIEW
next_target: After exact-head CI completes, adversarially review #515 at 4a5d57bf for the remaining external Git writer race, validator exception/fail-closed behavior, reentrant-lock semantics, malicious/malformed repository snapshots, and whether this boundary can still produce a false-success claim; if CI fails, treat the failure as the first blocker before semantic review.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Added a RED-first regression for the inspect→complete race on #515 and moved the final repository snapshot validation into the TaskStateSession completion critical section, so repository movement injected after the outer inspect is rejected before the authoritative Prolog complete operation is issued. issue_or_pr: zara-plugins#515; implementation note 5571465557; Core composition remains lost-rob0t/zara#400 refs: RED test 380e3fad721353e132065a8a9d3826eb4576d71b; session CAS boundary f6c53b2da37fd70c5061864845aac9a53078a3de; plugin wiring efe6c305a03fa9b69d71c55fc99d73005c9f0a7f; exact head 4a5d57bf148469f7f22ddd8d5fdb7953fee60398; CI run 34128323863 head: 4a5d57bf148469f7f22ddd8d5fdb7953fee60398 prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation regressions were preserved; this slice did not expand callable Prolog authority or change the Prolog evidence model. integration_tests: RED race regression added first. Exact-head CI run 34128323863 is running on 4a5d57bf; whitespace and compatibility-contract setup are green so far, while source/installed diagnostics, registry+plugin tests, package builds, and avatar CPU gate are still in progress/pending. verification_evidence: task_complete still performs an outer stale/dirty check, then calls TaskStateSession.complete_task with the durable expected repository snapshot and a bounded validator; complete_task holds its RLock, revalidates the repository immediately before issuing the Prolog complete request, and rejects stale state without transitioning. This closes the previously demonstrated plugin-operation interleaving window, though external Git writers are not made filesystem-atomic by this lock. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition blocker and was not bypassed. blockers: Exact-head CI has not completed yet. Also, the session RLock serializes Zara task-state operations but cannot make arbitrary external Git ref/index writes atomic with the Prolog transition; REVIEW must decide whether the remaining external-writer micro-window is acceptable or needs a stronger repository CAS/lease primitive. next_mode: REVIEW next_target: After exact-head CI completes, adversarially review #515 at 4a5d57bf for the remaining external Git writer race, validator exception/fail-closed behavior, reentrant-lock semantics, malicious/malformed repository snapshots, and whether this boundary can still produce a false-success claim; if CI fails, treat the failure as the first blocker before semantic review.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review of #515 confirmed CI green and the Zara-owned inspect→complete interleaving is closed, but found the remaining external-writer false-success window is still real: the process-local RLock cannot serialize arbitrary Git ref/index/worktree mutation with the authoritative Prolog completion transition.
issue_or_pr: zara-plugins#515 review comment 5572076182; Core composition remains lost-rob0t/zara#400
refs: zara-plugins#515; exact head 4a5d57bf14; CI run 34128323863; review comment 5572076182
head: 4a5d57bf14
prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation coverage remains green. Review confirms Prolog complete still receives task_id only and has no independently observed repository generation/CAS precondition.
integration_tests: Exact-head CI run 34128323863 completed success. Current race regression proves the session critical section rejects repository movement injected before final validation completes, but does not cover an external Git writer synchronized after validator success and before the Prolog complete request is consumed.
verification_evidence: Source at exact head shows complete_task holds an RLock, validates expected_repository, then calls _request({op: complete, task_id}); _request re-enters the same process-local lock. Validator exceptions/malformed snapshots fail closed, but external Git writers do not participate in this lock, so HEAD/branch/index/worktree can change after validation and before the authoritative state transition.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed by this review.
blockers: #515 is not semantically merge-ready under the no-false-success contract while arbitrary external repository writers can mutate state in the final validation→Prolog transition gap. A plain expected-head field in Prolog is insufficient unless repository mutation is also serialized or independently observed at the authority boundary.
next_mode: IMPLEMENT
next_target: Add a RED external-writer race regression synchronized after the final repository validator returns but before Prolog consumes complete; then introduce the smallest owned repository lease/generation or equivalent authority boundary that makes completion conditional on a repository state token advanced by all accepted mutation paths, without importing Core internals; rerun focused, registry/plugin, package/Nix, and exact-head CI gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review of #515 confirmed CI green and the Zara-owned inspect→complete interleaving is closed, but found the remaining external-writer false-success window is still real: the process-local RLock cannot serialize arbitrary Git ref/index/worktree mutation with the authoritative Prolog completion transition. issue_or_pr: zara-plugins#515 review comment 5572076182; Core composition remains lost-rob0t/zara#400 refs: zara-plugins#515; exact head 4a5d57bf148469f7f22ddd8d5fdb7953fee60398; CI run 34128323863; review comment 5572076182 head: 4a5d57bf148469f7f22ddd8d5fdb7953fee60398 prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation coverage remains green. Review confirms Prolog `complete` still receives task_id only and has no independently observed repository generation/CAS precondition. integration_tests: Exact-head CI run 34128323863 completed success. Current race regression proves the session critical section rejects repository movement injected before final validation completes, but does not cover an external Git writer synchronized after validator success and before the Prolog complete request is consumed. verification_evidence: Source at exact head shows complete_task holds an RLock, validates expected_repository, then calls _request({op: complete, task_id}); _request re-enters the same process-local lock. Validator exceptions/malformed snapshots fail closed, but external Git writers do not participate in this lock, so HEAD/branch/index/worktree can change after validation and before the authoritative state transition. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed by this review. blockers: #515 is not semantically merge-ready under the no-false-success contract while arbitrary external repository writers can mutate state in the final validation→Prolog transition gap. A plain expected-head field in Prolog is insufficient unless repository mutation is also serialized or independently observed at the authority boundary. next_mode: IMPLEMENT next_target: Add a RED external-writer race regression synchronized after the final repository validator returns but before Prolog consumes `complete`; then introduce the smallest owned repository lease/generation or equivalent authority boundary that makes completion conditional on a repository state token advanced by all accepted mutation paths, without importing Core internals; rerun focused, registry/plugin, package/Nix, and exact-head CI gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Closed the demonstrated external-writer validation→complete false-success race on #515 with RED-first coverage and optimistic repository validation around the authoritative Prolog completion transition; stale post-transition observations now revoke completion before success can be returned.
issue_or_pr: zara-plugins#515; implementation note 5572797812; Core composition remains lost-rob0t/zara#400
refs: RED synchronized race test ba292c4a6b; RED live SWI-Prolog regression 41dbce6a09; Python post-validation/compensation a48a71a651; Prolog invalidation boundary 2e0bf23c07; CI run 34138379310
head: 2e0bf23c07
prolog_tests: Added live SWI-Prolog regression requiring a task completed against H1 to be returned to open when the repository validator becomes stale after the complete transition. Existing verifier provenance/criterion/revocation semantics are preserved; new Prolog authority is limited to invalidate_completion on an already-completed task and is not exposed as a public StructuredTool.
integration_tests: Added synchronized unit race where the simulated external writer mutates exactly when the complete protocol command is written after pre-validation. Expected behavior is rejected repository-snapshot-stale plus authoritative completion invalidation. Exact-head CI 34138379310 is queued on this SHA, so registry/plugin/package/Nix gates are not yet claimed green.
verification_evidence: complete_task now performs pre-validation, issues the Prolog complete transition, then revalidates the same bounded repository snapshot before returning success. A stale post-check triggers invalidate_completion; validator exceptions also compensate before surfacing failure, and failed compensation fences the Prolog process rather than reporting success. This gives a clear optimistic linearization boundary without pretending arbitrary Git writers honor Zara's RLock.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed in this slice.
blockers: Exact-head CI has not completed. REVIEW must also adversarially confirm the new compensation operation cannot become a parallel callable authority, that compensation failure cannot leave a reusable stale-completed session, and that a writer landing after the successful post-check is correctly treated as occurring after the completion linearization point rather than as false success.
next_mode: REVIEW
next_target: After CI run 34138379310 resolves, adversarially review #515 at exact head 2e0bf23c for compensation authority/provenance, post-validation exception/fencing behavior, stale completed-state survivability, optimistic linearization semantics, malformed repository snapshots, and preservation of shell/model trust boundaries; if CI is red, make that the first blocker.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Closed the demonstrated external-writer validation→complete false-success race on #515 with RED-first coverage and optimistic repository validation around the authoritative Prolog completion transition; stale post-transition observations now revoke completion before success can be returned. issue_or_pr: zara-plugins#515; implementation note 5572797812; Core composition remains lost-rob0t/zara#400 refs: RED synchronized race test ba292c4a6ba5f292971dc6abb826e211b13906ae; RED live SWI-Prolog regression 41dbce6a0920fc3a5a388383cc63f7435378af7a; Python post-validation/compensation a48a71a6512d294adf47dcd9c2e6dcaf28129f4a; Prolog invalidation boundary 2e0bf23c0798086f7f56e8845dea78072032fb04; CI run 34138379310 head: 2e0bf23c0798086f7f56e8845dea78072032fb04 prolog_tests: Added live SWI-Prolog regression requiring a task completed against H1 to be returned to open when the repository validator becomes stale after the complete transition. Existing verifier provenance/criterion/revocation semantics are preserved; new Prolog authority is limited to `invalidate_completion` on an already-completed task and is not exposed as a public StructuredTool. integration_tests: Added synchronized unit race where the simulated external writer mutates exactly when the complete protocol command is written after pre-validation. Expected behavior is rejected `repository-snapshot-stale` plus authoritative completion invalidation. Exact-head CI 34138379310 is queued on this SHA, so registry/plugin/package/Nix gates are not yet claimed green. verification_evidence: `complete_task` now performs pre-validation, issues the Prolog complete transition, then revalidates the same bounded repository snapshot before returning success. A stale post-check triggers `invalidate_completion`; validator exceptions also compensate before surfacing failure, and failed compensation fences the Prolog process rather than reporting success. This gives a clear optimistic linearization boundary without pretending arbitrary Git writers honor Zara's RLock. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed or bypassed in this slice. blockers: Exact-head CI has not completed. REVIEW must also adversarially confirm the new compensation operation cannot become a parallel callable authority, that compensation failure cannot leave a reusable stale-completed session, and that a writer landing after the successful post-check is correctly treated as occurring after the completion linearization point rather than as false success. next_mode: REVIEW next_target: After CI run 34138379310 resolves, adversarially review #515 at exact head 2e0bf23c for compensation authority/provenance, post-validation exception/fencing behavior, stale completed-state survivability, optimistic linearization semantics, malformed repository snapshots, and preservation of shell/model trust boundaries; if CI is red, make that the first blocker.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review of #515 confirmed CI green and compensation/fencing closes the demonstrated stale post-completion false-success path, but found a blocking verifier-authority flaw: verifier provenance is still caller-supplied protocol data, so an in-process caller with TaskStateSession access can mint authoritative passing evidence without a verifier capability.
issue_or_pr: zara-plugins#515 review comment 5573390414; Core composition remains lost-rob0t/zara#400
refs: zara-plugins#515; exact head 2e0bf23c07; CI run 34138379310; review comment 5573390414
head: 2e0bf23c07
prolog_tests: Existing direct SWI-Prolog criterion/provenance/revocation and stale-completion invalidation regressions are green, but they only prove the string provenance="verifier" is accepted and caller provenance is rejected for passes; they do not prove verifier provenance is minted by a distinct authority.
integration_tests: Exact-head CI run 34138379310 completed success. Source review confirms post-validation stale state triggers invalidate_completion, validator exceptions compensate, and failed compensation fences the Prolog session. invalidate_completion is not exported as a StructuredTool.
verification_evidence: TaskStateSession.record_evidence defaults provenance to "verifier"; its protocol request carries that caller-selected string. Prolog evidence_response/4 validates only the provenance enum and current_verifier_pass/2 trusts rows whose provenance string is "verifier". The public plugin wrapper forces caller, but the authoritative Python/Prolog boundary has no capability distinction for verifier-owned evidence.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed for this bounded authority repair and no Core internals should be imported.
blockers: #515 is not semantically merge-ready under the no-false-success/model-data-vs-authority contract while generic session callers can self-assert verifier provenance. The compensation/CAS slice itself is green.
next_mode: IMPLEMENT
next_target: On #515, add RED coverage proving the generic/public/session evidence path cannot mint verifier-owned passing evidence, then split verifier evidence recording into a narrow verifier-only callable path whose provenance is fixed by construction while caller/model evidence is always caller; preserve stale-completion compensation/fencing and rerun focused SWI-Prolog, Python, registry/plugin, package/Nix, and exact-head CI gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review of #515 confirmed CI green and compensation/fencing closes the demonstrated stale post-completion false-success path, but found a blocking verifier-authority flaw: `verifier` provenance is still caller-supplied protocol data, so an in-process caller with `TaskStateSession` access can mint authoritative passing evidence without a verifier capability. issue_or_pr: zara-plugins#515 review comment 5573390414; Core composition remains lost-rob0t/zara#400 refs: zara-plugins#515; exact head 2e0bf23c0798086f7f56e8845dea78072032fb04; CI run 34138379310; review comment 5573390414 head: 2e0bf23c0798086f7f56e8845dea78072032fb04 prolog_tests: Existing direct SWI-Prolog criterion/provenance/revocation and stale-completion invalidation regressions are green, but they only prove the string `provenance="verifier"` is accepted and caller provenance is rejected for passes; they do not prove verifier provenance is minted by a distinct authority. integration_tests: Exact-head CI run 34138379310 completed success. Source review confirms post-validation stale state triggers `invalidate_completion`, validator exceptions compensate, and failed compensation fences the Prolog session. `invalidate_completion` is not exported as a StructuredTool. verification_evidence: `TaskStateSession.record_evidence` defaults `provenance` to `"verifier"`; its protocol request carries that caller-selected string. Prolog `evidence_response/4` validates only the provenance enum and `current_verifier_pass/2` trusts rows whose provenance string is `"verifier"`. The public plugin wrapper forces `caller`, but the authoritative Python/Prolog boundary has no capability distinction for verifier-owned evidence. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; not needed for this bounded authority repair and no Core internals should be imported. blockers: #515 is not semantically merge-ready under the no-false-success/model-data-vs-authority contract while generic session callers can self-assert verifier provenance. The compensation/CAS slice itself is green. next_mode: IMPLEMENT next_target: On #515, add RED coverage proving the generic/public/session evidence path cannot mint verifier-owned passing evidence, then split verifier evidence recording into a narrow verifier-only callable path whose provenance is fixed by construction while caller/model evidence is always `caller`; preserve stale-completion compensation/fencing and rerun focused SWI-Prolog, Python, registry/plugin, package/Nix, and exact-head CI gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Split caller/model evidence from verifier-owned authority on #515: generic/session evidence is now caller-owned by construction and cannot mint passing verifier evidence; verifier provenance requires a distinct injected capability path.
issue_or_pr: zara-plugins#515; implementation note 5573965425; Core composition remains lost-rob0t/zara#400
refs: RED Python bce713388b; RED/live SWI migration aaf05ddbd7; authority split 460d60f602; public-path wiring/exact head 5b5a928ffc; CI run 34147800920
head: 5b5a928ffc
prolog_tests: Live SWI-Prolog verifier regressions were migrated first to an explicit verifier-capability path; criterion matching, later-failure revocation, and stale-completion invalidation semantics are preserved. Generic TaskStateSession evidence can no longer author a passing row or select provenance.
integration_tests: RED unit coverage added first for generic pass rejection, mismatched verifier capability rejection, and caller provenance fixed by construction. Exact-head CI 34147800920 is in progress: whitespace, compatibility contract, and source/installed compatibility diagnostics are green; registry/plugin tests and avatar CPU are running, package builds pending.
verification_evidence: TaskStateSession.record_evidence fixes provenance to caller and rejects passed before protocol I/O. record_verifier_evidence fixes provenance to verifier internally and requires identity possession of an injected capability object. The public StructuredTool surface exposes neither the verifier method nor a capability parameter. Existing repository pre/post validation, invalidate_completion compensation, and fencing remain unchanged.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition handoff; it was not needed or bypassed for this bounded repair.
blockers: Exact-head CI has not completed, so full gates are not yet claimed green. REVIEW should also verify verifier-capability ownership/injection cannot leak onto a model-callable surface and that fail-closed production construction is compatible with the intended trusted verifier integration.
next_mode: REVIEW
next_target: After exact-head CI resolves, adversarially review #515 at 5b5a928f for capability ownership/injection and leakage, generic/session/public attempts to mint verifier rows, restart/failure behavior, preservation of compensation/CAS semantics, and any shell/model route to the verifier capability; if CI is red, treat that as the first blocker.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Split caller/model evidence from verifier-owned authority on #515: generic/session evidence is now caller-owned by construction and cannot mint passing verifier evidence; verifier provenance requires a distinct injected capability path. issue_or_pr: zara-plugins#515; implementation note 5573965425; Core composition remains lost-rob0t/zara#400 refs: RED Python bce713388b65deb9c1ef0b811907f6106b84b7e5; RED/live SWI migration aaf05ddbd744f4f9ab2cff2a94f2f5b9dc736ebd; authority split 460d60f6024e3570fd642790fb6b8afbb984b14c; public-path wiring/exact head 5b5a928ffca18df0e3a8cf23b2746de13a3b47c1; CI run 34147800920 head: 5b5a928ffca18df0e3a8cf23b2746de13a3b47c1 prolog_tests: Live SWI-Prolog verifier regressions were migrated first to an explicit verifier-capability path; criterion matching, later-failure revocation, and stale-completion invalidation semantics are preserved. Generic TaskStateSession evidence can no longer author a passing row or select provenance. integration_tests: RED unit coverage added first for generic pass rejection, mismatched verifier capability rejection, and caller provenance fixed by construction. Exact-head CI 34147800920 is in progress: whitespace, compatibility contract, and source/installed compatibility diagnostics are green; registry/plugin tests and avatar CPU are running, package builds pending. verification_evidence: TaskStateSession.record_evidence fixes provenance to caller and rejects passed before protocol I/O. record_verifier_evidence fixes provenance to verifier internally and requires identity possession of an injected capability object. The public StructuredTool surface exposes neither the verifier method nor a capability parameter. Existing repository pre/post validation, invalidate_completion compensation, and fencing remain unchanged. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition handoff; it was not needed or bypassed for this bounded repair. blockers: Exact-head CI has not completed, so full gates are not yet claimed green. REVIEW should also verify verifier-capability ownership/injection cannot leak onto a model-callable surface and that fail-closed production construction is compatible with the intended trusted verifier integration. next_mode: REVIEW next_target: After exact-head CI resolves, adversarially review #515 at 5b5a928f for capability ownership/injection and leakage, generic/session/public attempts to mint verifier rows, restart/failure behavior, preservation of compensation/CAS semantics, and any shell/model route to the verifier capability; if CI is red, treat that as the first blocker.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
mode_used: REVIEW
result: blocked — verifier provenance remains forgeable through the generic TaskStateSession/raw protocol boundary; exact-head CI also failed.
refs: #515; review comment #5574457663; CI run 34147800920
head: 5b5a928ffc
tests: adversarial exact-head source/protocol review at the recorded head. Existing repository post-validation, stale-completion compensation, and fencing paths remain present. Exact-head CI run 34147800920 completed FAILED, so gates are not green.
blockers: generic session stores the verifier capability as an inspectable attribute; generic _request can carry caller-selected evidence provenance; Prolog's raw record_evidence boundary trusts provenance="verifier" as request data. An in-process caller holding the generic session can therefore mint authoritative passing evidence and reopen a false-success completion path. No additional direct shell-specific capability leak was established in this bounded review.
next_mode: IMPLEMENT
next_target: add RED tests proving generic-session token replay and raw-protocol verifier-provenance forgery are impossible; then split verifier authority into a separate non-model writer/trusted operation or channel so generic session/model paths cannot mint verifier passes. Preserve repository post-validation/compensation/fencing semantics and rerun exact-head gates before any merge claim.

WORKER_STATE mode_used: REVIEW result: blocked — verifier provenance remains forgeable through the generic `TaskStateSession`/raw protocol boundary; exact-head CI also failed. refs: #515; review comment #5574457663; CI run 34147800920 head: 5b5a928ffca18df0e3a8cf23b2746de13a3b47c1 tests: adversarial exact-head source/protocol review at the recorded head. Existing repository post-validation, stale-completion compensation, and fencing paths remain present. Exact-head CI run 34147800920 completed FAILED, so gates are not green. blockers: generic session stores the verifier capability as an inspectable attribute; generic `_request` can carry caller-selected evidence provenance; Prolog's raw `record_evidence` boundary trusts `provenance="verifier"` as request data. An in-process caller holding the generic session can therefore mint authoritative passing evidence and reopen a false-success completion path. No additional direct shell-specific capability leak was established in this bounded review. next_mode: IMPLEMENT next_target: add RED tests proving generic-session token replay and raw-protocol verifier-provenance forgery are impossible; then split verifier authority into a separate non-model writer/trusted operation or channel so generic session/model paths cannot mint verifier passes. Preserve repository post-validation/compensation/fencing semantics and rerun exact-head gates before any merge claim.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Reworked #515 so generic/session evidence cannot self-assert verifier provenance: generic protocol rejects verifier authority before I/O, caller evidence carries no provenance field, and Prolog derives verifier provenance from a distinct verifier-only operation rather than request data.
issue_or_pr: zara-plugins#515; implementation note 5574882675; Core composition remains lost-rob0t/zara#400
refs: RED authority test d1a8a2f159; refined RED expectations 2761c52f11; session authority split 294add3bb0; Prolog operation-derived provenance 2d42a5e5c4; test migrations fdbfeeb113 and d909e9305b; CI run 34155620448
head: d909e9305b
prolog_tests: Direct SWI provenance regression now sends forged provenance on generic record_evidence and expects caller authority/pass rejection; trusted verifier observations use the distinct record_verifier_evidence operation so provenance is derived by Prolog, preserving criterion matching and later-failure revocation semantics.
integration_tests: Added RED-first generic _request forgery/token-storage tests; TaskStateSession unit expectations migrated to authority-derived operations. Exact-head CI 34155620448 is in progress; whitespace and compatibility contract gates are green so far, registry/plugin/package/Nix gates not yet claimed green.
verification_evidence: Generic TaskStateSession._request rejects verifier provenance and record_verifier_evidence before protocol I/O; generic record_evidence emits no provenance field; verifier capability object is not stored on the session; Prolog record_evidence fixes caller provenance and record_verifier_evidence fixes verifier provenance by operation. Repository post-validation, invalidate_completion compensation, and fencing remain unchanged.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition handoff and was only read for the contract; no Core internals were imported.
blockers: Exact-head CI has not completed. Also, the Prolog service still recognizes the verifier-only operation on its owned stdin; generic TaskStateSession blocks that path, but REVIEW must determine whether any model/shell-accessible route can obtain/write the process pipe or invoke the trusted operation directly. No false green is claimed.
next_mode: REVIEW
next_target: After CI 34155620448 resolves, adversarially review #515 at d909e930 for direct-pipe/shell escape to record_verifier_evidence, capability identity replay, restart/failure semantics, Prolog operation authority, preservation of repository CAS/compensation/fencing, and any remaining model-data-vs-callable-authority false-success path.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Reworked #515 so generic/session evidence cannot self-assert verifier provenance: generic protocol rejects verifier authority before I/O, caller evidence carries no provenance field, and Prolog derives verifier provenance from a distinct verifier-only operation rather than request data. issue_or_pr: zara-plugins#515; implementation note 5574882675; Core composition remains lost-rob0t/zara#400 refs: RED authority test d1a8a2f159a6ada432ce87b3cf66f825dfc2f7d6; refined RED expectations 2761c52f11212a67932cfea400e8749b9c7479b2; session authority split 294add3bb0e1aad260180d47563c54b5d6d11ee1; Prolog operation-derived provenance 2d42a5e5c4513e70558d6851cc94fa9db14d7c79; test migrations fdbfeeb11383748350ae182c382a72e3af4cfd73 and d909e9305ba0356e8f72055bc6d6c3634a28f9a8; CI run 34155620448 head: d909e9305ba0356e8f72055bc6d6c3634a28f9a8 prolog_tests: Direct SWI provenance regression now sends forged provenance on generic record_evidence and expects caller authority/pass rejection; trusted verifier observations use the distinct record_verifier_evidence operation so provenance is derived by Prolog, preserving criterion matching and later-failure revocation semantics. integration_tests: Added RED-first generic _request forgery/token-storage tests; TaskStateSession unit expectations migrated to authority-derived operations. Exact-head CI 34155620448 is in progress; whitespace and compatibility contract gates are green so far, registry/plugin/package/Nix gates not yet claimed green. verification_evidence: Generic TaskStateSession._request rejects verifier provenance and record_verifier_evidence before protocol I/O; generic record_evidence emits no provenance field; verifier capability object is not stored on the session; Prolog record_evidence fixes caller provenance and record_verifier_evidence fixes verifier provenance by operation. Repository post-validation, invalidate_completion compensation, and fencing remain unchanged. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition handoff and was only read for the contract; no Core internals were imported. blockers: Exact-head CI has not completed. Also, the Prolog service still recognizes the verifier-only operation on its owned stdin; generic TaskStateSession blocks that path, but REVIEW must determine whether any model/shell-accessible route can obtain/write the process pipe or invoke the trusted operation directly. No false green is claimed. next_mode: REVIEW next_target: After CI 34155620448 resolves, adversarially review #515 at d909e930 for direct-pipe/shell escape to record_verifier_evidence, capability identity replay, restart/failure semantics, Prolog operation authority, preservation of repository CAS/compensation/fencing, and any remaining model-data-vs-callable-authority false-success path.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review of #515 found two blockers: CI is red at the registry/plugin gate, and verifier authority remains forgeable because the generic TaskStateSession still exposes the raw trusted protocol sender used by record_verifier_evidence; operation-derived provenance is therefore not yet separated from generic callable authority.
issue_or_pr: zara-plugins#515 review comment 5575326109; Core composition remains lost-rob0t/zara#400
refs: zara-plugins#515; exact head d909e9305b; CI run 34155620448; review comment 5575326109
head: d909e9305b
prolog_tests: Existing direct SWI-Prolog semantics derive caller vs verifier provenance from distinct operations, but review shows the generic Python session can still select the verifier-only operation through _request_protocol, so those semantics do not establish caller authority separation. No new PLUnit mutation was made in REVIEW.
integration_tests: Exact-head CI run 34155620448 completed failure: whitespace/compatibility diagnostics and avatar CPU gate passed, Run registry and plugin tests failed, and package builds were skipped. Source review also found TaskStateSession retains _process and _request_protocol, allowing in-process raw protocol access around the generic _request guard.
verification_evidence: At exact head, record_verifier_evidence() calls self._request_protocol({op: record_verifier_evidence, ...}); _request_protocol is directly reachable on the same generic TaskStateSession and writes to the owned Prolog stdin. _request() rejects the verifier op, but a caller holding the session can bypass it. The constructor additionally stores only id(verifier_capability) without retaining the capability object, making token identity vulnerable to object-id reuse after GC. Repository pre/post validation, invalidate_completion compensation, and fencing remain present.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition handoff; not needed or bypassed here.
blockers: #515 is not merge-ready: exact-head registry/plugin tests are red, and verifier callable authority still resides on the generic session/raw protocol path. No separate model-facing StructuredTool verifier route was established, but the in-process trust boundary is sufficient to violate the authority contract.
next_mode: IMPLEMENT
next_target: On #515, add RED tests proving a generic TaskStateSession cannot invoke _request_protocol/direct trusted verifier operations or replay verifier authority, then move verifier writes to a separate narrow trusted writer/channel that the generic session does not possess; replace id()-based capability checking with retained identity or a stronger construction boundary, preserve repository compensation/fencing, fix the registry/plugin failure, and rerun focused SWI-Prolog/Python plus exact-head registry/plugin and package/Nix gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review of #515 found two blockers: CI is red at the registry/plugin gate, and verifier authority remains forgeable because the generic TaskStateSession still exposes the raw trusted protocol sender used by record_verifier_evidence; operation-derived provenance is therefore not yet separated from generic callable authority. issue_or_pr: zara-plugins#515 review comment 5575326109; Core composition remains lost-rob0t/zara#400 refs: zara-plugins#515; exact head d909e9305ba0356e8f72055bc6d6c3634a28f9a8; CI run 34155620448; review comment 5575326109 head: d909e9305ba0356e8f72055bc6d6c3634a28f9a8 prolog_tests: Existing direct SWI-Prolog semantics derive caller vs verifier provenance from distinct operations, but review shows the generic Python session can still select the verifier-only operation through _request_protocol, so those semantics do not establish caller authority separation. No new PLUnit mutation was made in REVIEW. integration_tests: Exact-head CI run 34155620448 completed failure: whitespace/compatibility diagnostics and avatar CPU gate passed, `Run registry and plugin tests` failed, and package builds were skipped. Source review also found TaskStateSession retains `_process` and `_request_protocol`, allowing in-process raw protocol access around the generic `_request` guard. verification_evidence: At exact head, `record_verifier_evidence()` calls `self._request_protocol({op: record_verifier_evidence, ...})`; `_request_protocol` is directly reachable on the same generic TaskStateSession and writes to the owned Prolog stdin. `_request()` rejects the verifier op, but a caller holding the session can bypass it. The constructor additionally stores only `id(verifier_capability)` without retaining the capability object, making token identity vulnerable to object-id reuse after GC. Repository pre/post validation, invalidate_completion compensation, and fencing remain present. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition handoff; not needed or bypassed here. blockers: #515 is not merge-ready: exact-head registry/plugin tests are red, and verifier callable authority still resides on the generic session/raw protocol path. No separate model-facing StructuredTool verifier route was established, but the in-process trust boundary is sufficient to violate the authority contract. next_mode: IMPLEMENT next_target: On #515, add RED tests proving a generic TaskStateSession cannot invoke `_request_protocol`/direct trusted verifier operations or replay verifier authority, then move verifier writes to a separate narrow trusted writer/channel that the generic session does not possess; replace id()-based capability checking with retained identity or a stronger construction boundary, preserve repository compensation/fencing, fix the registry/plugin failure, and rerun focused SWI-Prolog/Python plus exact-head registry/plugin and package/Nix gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Split verifier callable authority away from the generic TaskStateSession on #515: generic task state no longer owns/exposes the raw Prolog process/protocol sender or verifier operation, and verifier evidence is emitted only through a separate narrow TaskStateVerifier interface; the old id()-based capability token was removed.
issue_or_pr: zara-plugins#515; implementation note 5575807293; Core composition remains lost-rob0t/zara#400
refs: RED authority boundary 8ec2c905c3; protocol/writer split b09278538c; live verifier migration 37de14bc94 and 247ef1e90f; session-test migration/exact head 3b97516bc2; CI run 34163328353
head: 3b97516bc2
prolog_tests: RED-first authority test now requires no _request_protocol/_process/verifier method on generic TaskStateSession and verifies trusted evidence uses a separate writer whose operation is derived internally. Live SWI-Prolog criterion/revocation/stale-completion tests were migrated to the writer; direct Prolog provenance tests remain unchanged.
integration_tests: Previous registry/plugin failure was addressed by migrating session/live tests off the removed verifier-capability API. Exact-head CI 34163328353 is in progress: whitespace + compatibility contract and source diagnostics are green so far; installed diagnostics, registry/plugin tests and package/Nix gates are still pending, so no full-green claim is made.
verification_evidence: TaskStateSession now stores only bounded caller-side callbacks and no subprocess handle/raw protocol method; caller requests reject verifier op/provenance defense-in-depth. _TaskStateProtocol owns stdin/process state; TaskStateVerifier exposes only record_evidence and its protocol callback constructs record_verifier_evidence internally with no caller provenance field. The id(verifier_capability) scheme is gone. Existing repository pre/post validation, invalidate_completion compensation, and fencing remain in place.
core_handoffs: lost-rob0t/zara#400 remains the canonical Core composition blocker; only its contract was read and no Core internals were imported or bypassed.
blockers: Exact-head CI has not finished, so #515 is not yet gate-green. REVIEW must also adversarially decide whether the remaining callback/closure construction boundary is sufficiently non-model/non-shell reachable, verify restart/fencing semantics through the shared protocol owner, and confirm no trusted writer is exposed by TaskStateCodingPlugin or another callable surface.
next_mode: REVIEW
next_target: After CI 34163328353 resolves, adversarially review #515 at 3b97516b for verifier-writer leakage through callbacks/closures/plugin construction, direct-pipe or shell/model access, shared-owner restart/fencing behavior, preservation of repository CAS/compensation semantics, and any remaining model-data-vs-callable-authority false-success path; treat any CI failure as the first blocker.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Split verifier callable authority away from the generic TaskStateSession on #515: generic task state no longer owns/exposes the raw Prolog process/protocol sender or verifier operation, and verifier evidence is emitted only through a separate narrow TaskStateVerifier interface; the old id()-based capability token was removed. issue_or_pr: zara-plugins#515; implementation note 5575807293; Core composition remains lost-rob0t/zara#400 refs: RED authority boundary 8ec2c905c3c73cef911f1dc86a349aafd0179de0; protocol/writer split b09278538c68f5e3c30bfd45fe2141bfc053cf93; live verifier migration 37de14bc94320c452b554fb4d78eb7c9dbb17f70 and 247ef1e90fa477a3c71a68cdcd448d65bf76fa24; session-test migration/exact head 3b97516bc269e51e919768f111e634f86bf7cbe5; CI run 34163328353 head: 3b97516bc269e51e919768f111e634f86bf7cbe5 prolog_tests: RED-first authority test now requires no _request_protocol/_process/verifier method on generic TaskStateSession and verifies trusted evidence uses a separate writer whose operation is derived internally. Live SWI-Prolog criterion/revocation/stale-completion tests were migrated to the writer; direct Prolog provenance tests remain unchanged. integration_tests: Previous registry/plugin failure was addressed by migrating session/live tests off the removed verifier-capability API. Exact-head CI 34163328353 is in progress: whitespace + compatibility contract and source diagnostics are green so far; installed diagnostics, registry/plugin tests and package/Nix gates are still pending, so no full-green claim is made. verification_evidence: TaskStateSession now stores only bounded caller-side callbacks and no subprocess handle/raw protocol method; caller requests reject verifier op/provenance defense-in-depth. _TaskStateProtocol owns stdin/process state; TaskStateVerifier exposes only record_evidence and its protocol callback constructs record_verifier_evidence internally with no caller provenance field. The id(verifier_capability) scheme is gone. Existing repository pre/post validation, invalidate_completion compensation, and fencing remain in place. core_handoffs: lost-rob0t/zara#400 remains the canonical Core composition blocker; only its contract was read and no Core internals were imported or bypassed. blockers: Exact-head CI has not finished, so #515 is not yet gate-green. REVIEW must also adversarially decide whether the remaining callback/closure construction boundary is sufficiently non-model/non-shell reachable, verify restart/fencing semantics through the shared protocol owner, and confirm no trusted writer is exposed by TaskStateCodingPlugin or another callable surface. next_mode: REVIEW next_target: After CI 34163328353 resolves, adversarially review #515 at 3b97516b for verifier-writer leakage through callbacks/closures/plugin construction, direct-pipe or shell/model access, shared-owner restart/fencing behavior, preservation of repository CAS/compensation semantics, and any remaining model-data-vs-callable-authority false-success path; treat any CI failure as the first blocker.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review of #515 found two blockers: CI 34163328353 is red at registry/plugin tests, and the verifier split still leaks callable authority because TaskStateSession stores bound callbacks whose self exposes the shared _TaskStateProtocol and therefore verifier_evidence_request/raw _request.
issue_or_pr: zara-plugins#515; review comment 5576197383; Core composition remains lost-rob0t/zara#400
refs: exact head 3b97516bc2; CI run 34163328353; review comment 5576197383
head: 3b97516bc2
prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation/stale-completion semantics were not changed by this review. Source inspection confirms verifier provenance is operation-derived in Prolog-facing traffic, but the verifier operation remains reachable by recovering the shared protocol owner from generic-session bound callbacks.
integration_tests: Exact-head CI 34163328353 completed failure: whitespace and compatibility diagnostics passed; registry/plugin tests failed; package builds were skipped; avatar CPU budget passed. No green exact-head claim.
verification_evidence: TaskStateSession stores _request_command = protocol.caller_request plus other bound protocol callbacks. Python bound methods retain __self__, so a generic-session holder can recover _TaskStateProtocol and call verifier_evidence_request(...) or raw _request(...), bypassing the intended TaskStateVerifier authority split. TaskStateCodingPlugin.tools() itself does not expose verifier writes; public evidence still rejects passed; shell execution remains shell=False. Repository pre/post validation, invalidate_completion compensation, and fencing remain present.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition blocker and was not needed or bypassed.
blockers: #515 is not merge-ready: exact-head CI is red, and verifier callable authority is still recoverable from generic TaskStateSession via bound-callback owner introspection.
next_mode: IMPLEMENT
next_target: Add RED coverage proving a generic TaskStateSession cannot recover a verifier writer through callback/closure/bound-method ownership, then replace recoverable shared-protocol callbacks with a genuinely opaque/separate authority seam; fix the registry/plugin CI failure; preserve repository compensation/fencing semantics and rerun focused + registry/plugin + package/Nix exact-head gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review of #515 found two blockers: CI 34163328353 is red at registry/plugin tests, and the verifier split still leaks callable authority because TaskStateSession stores bound callbacks whose __self__ exposes the shared _TaskStateProtocol and therefore verifier_evidence_request/raw _request. issue_or_pr: zara-plugins#515; review comment 5576197383; Core composition remains lost-rob0t/zara#400 refs: exact head 3b97516bc269e51e919768f111e634f86bf7cbe5; CI run 34163328353; review comment 5576197383 head: 3b97516bc269e51e919768f111e634f86bf7cbe5 prolog_tests: Existing direct SWI-Prolog provenance/criterion/revocation/stale-completion semantics were not changed by this review. Source inspection confirms verifier provenance is operation-derived in Prolog-facing traffic, but the verifier operation remains reachable by recovering the shared protocol owner from generic-session bound callbacks. integration_tests: Exact-head CI 34163328353 completed failure: whitespace and compatibility diagnostics passed; registry/plugin tests failed; package builds were skipped; avatar CPU budget passed. No green exact-head claim. verification_evidence: TaskStateSession stores `_request_command = protocol.caller_request` plus other bound protocol callbacks. Python bound methods retain `__self__`, so a generic-session holder can recover `_TaskStateProtocol` and call `verifier_evidence_request(...)` or raw `_request(...)`, bypassing the intended TaskStateVerifier authority split. TaskStateCodingPlugin.tools() itself does not expose verifier writes; public evidence still rejects passed; shell execution remains shell=False. Repository pre/post validation, invalidate_completion compensation, and fencing remain present. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin composition blocker and was not needed or bypassed. blockers: #515 is not merge-ready: exact-head CI is red, and verifier callable authority is still recoverable from generic TaskStateSession via bound-callback owner introspection. next_mode: IMPLEMENT next_target: Add RED coverage proving a generic TaskStateSession cannot recover a verifier writer through callback/closure/bound-method ownership, then replace recoverable shared-protocol callbacks with a genuinely opaque/separate authority seam; fix the registry/plugin CI failure; preserve repository compensation/fencing semantics and rerun focused + registry/plugin + package/Nix exact-head gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: IMPLEMENT
result: Added RED-first callback-owner recovery coverage and replaced generic-session bound protocol callbacks with separate opaque caller/verifier endpoint tokens over the shared task-state protocol; generic session no longer retains a bound-method/closure path to verifier authority.
issue_or_pr: zara-plugins#515; implementation comment #5576668779; RED CI 34169902541; exact-head CI 34169968811; Core composition remains lost-rob0t/zara#400
head: 5c0a5a6034
prolog_tests: Existing direct SWI-Prolog verifier provenance, criterion-key, revocation, and stale-completion semantics are unchanged by this Python authority-seam slice. Verifier protocol traffic still derives record_verifier_evidence from the trusted verifier endpoint rather than caller-supplied provenance.
integration_tests: RED commit af40364242 ran CI 34169902541 and failed in registry/plugin tests. Exact-head 5c0a5a6034 CI 34169968811 is in progress; whitespace and compatibility contract checks are green so far, registry/plugin and package/Nix gates are not yet complete. No full-green claim.
verification_evidence: Source now stores only a caller endpoint token on TaskStateSession; verifier uses a distinct token registered in a separate verifier endpoint map. Caller requests reject verifier op/provenance before protocol dispatch; verifier helper fixes the trusted op internally. Existing repository pre/post validation, invalidate_completion compensation/fencing, and shell=False process launch remain preserved.
core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition blocker; not needed or bypassed by this slice.
blockers: Exact-head CI has not completed, so merge readiness is unproven. The Python boundary now blocks the previously demonstrated bound-method/closure owner-recovery path, but REVIEW should adversarially test endpoint-token leakage/replay, module-global registry reachability, restart/fencing behavior, and whether registry/plugin gates actually turn green.
next_mode: REVIEW
next_target: Adversarially review #515 at exact head after CI: attack caller-token replay into verifier APIs, endpoint/registry introspection and leakage, shared-protocol restart/fencing semantics, model/shell reachability, and preservation of repository stale-completion compensation; if CI is red, identify the exact failing test before any merge claim.

WORKER_STATE worker: symbolics-dev mode_used: IMPLEMENT result: Added RED-first callback-owner recovery coverage and replaced generic-session bound protocol callbacks with separate opaque caller/verifier endpoint tokens over the shared task-state protocol; generic session no longer retains a bound-method/closure path to verifier authority. issue_or_pr: zara-plugins#515; implementation comment #5576668779; RED CI 34169902541; exact-head CI 34169968811; Core composition remains lost-rob0t/zara#400 head: 5c0a5a6034b0540c81cf82a5295249a21549e9f0 prolog_tests: Existing direct SWI-Prolog verifier provenance, criterion-key, revocation, and stale-completion semantics are unchanged by this Python authority-seam slice. Verifier protocol traffic still derives `record_verifier_evidence` from the trusted verifier endpoint rather than caller-supplied provenance. integration_tests: RED commit af40364242553db1c3f633e12e84c8716d086690 ran CI 34169902541 and failed in registry/plugin tests. Exact-head 5c0a5a6034b0540c81cf82a5295249a21549e9f0 CI 34169968811 is in progress; whitespace and compatibility contract checks are green so far, registry/plugin and package/Nix gates are not yet complete. No full-green claim. verification_evidence: Source now stores only a caller endpoint token on TaskStateSession; verifier uses a distinct token registered in a separate verifier endpoint map. Caller requests reject verifier op/provenance before protocol dispatch; verifier helper fixes the trusted op internally. Existing repository pre/post validation, invalidate_completion compensation/fencing, and shell=False process launch remain preserved. core_handoffs: lost-rob0t/zara#400 remains the canonical cross-plugin capability-composition blocker; not needed or bypassed by this slice. blockers: Exact-head CI has not completed, so merge readiness is unproven. The Python boundary now blocks the previously demonstrated bound-method/closure owner-recovery path, but REVIEW should adversarially test endpoint-token leakage/replay, module-global registry reachability, restart/fencing behavior, and whether registry/plugin gates actually turn green. next_mode: REVIEW next_target: Adversarially review #515 at exact head after CI: attack caller-token replay into verifier APIs, endpoint/registry introspection and leakage, shared-protocol restart/fencing semantics, model/shell reachability, and preservation of repository stale-completion compensation; if CI is red, identify the exact failing test before any merge claim.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
worker: symbolics-dev
mode_used: REVIEW
result: Exact-head review found verifier authority still forgeable through module-global endpoint registries: an in-process caller can enumerate _VERIFIER_ENDPOINTS, recover a live verifier token/protocol, and mint record_verifier_evidence; exact-head CI is also red at registry/plugin tests.
issue_or_pr: zara-plugins#515 review #5577174756; CI run 34169968811; Core composition blocker remains lost-rob0t/zara#400
head: 5c0a5a6034
prolog_tests: Existing Prolog criterion-key/provenance/revocation semantics were not changed in this REVIEW slice. The semantic failure is above Prolog: trusted verifier op authority can still be reconstructed by importing module state, so operation-derived provenance is not sufficient yet.
integration_tests: Exact-head CI 34169968811 completed failure. Whitespace and compatibility contract/source/installed diagnostics passed; Run registry and plugin tests failed; package builds were skipped; avatar CPU budget passed. No merge-ready claim.
verification_evidence: Current task_state.py defines module-global _CALLER_ENDPOINTS and _VERIFIER_ENDPOINTS WeakKeyDictionaries plus _verifier_request() and _TaskStateProtocol.request(). While the verifier exists, its token is a live _VERIFIER_ENDPOINTS key, making verifier callable authority recoverable by an importing in-process caller. Public caller evidence still rejects passed, SWI-Prolog launch retains shell=False, and repository pre/post validation plus invalidate_completion compensation/fencing remains present.
core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; it is not needed for this bounded repair and no Core internals should be imported.
blockers: #515 is not semantically merge-ready because verifier authority is reconstructible from module-global registries, and exact-head CI is red in registry/plugin tests.
next_mode: IMPLEMENT
next_target: On #515, add RED coverage proving an importing generic caller can enumerate/recover verifier endpoint authority and mint a verifier pass; replace module-global authority registries with a construction where generic/session code has no discoverable verifier reference or raw trusted protocol path, then identify/fix the exact registry/plugin test failure and rerun focused + exact-head gates.

WORKER_STATE worker: symbolics-dev mode_used: REVIEW result: Exact-head review found verifier authority still forgeable through module-global endpoint registries: an in-process caller can enumerate `_VERIFIER_ENDPOINTS`, recover a live verifier token/protocol, and mint `record_verifier_evidence`; exact-head CI is also red at registry/plugin tests. issue_or_pr: zara-plugins#515 review #5577174756; CI run 34169968811; Core composition blocker remains lost-rob0t/zara#400 head: 5c0a5a6034b0540c81cf82a5295249a21549e9f0 prolog_tests: Existing Prolog criterion-key/provenance/revocation semantics were not changed in this REVIEW slice. The semantic failure is above Prolog: trusted verifier op authority can still be reconstructed by importing module state, so operation-derived provenance is not sufficient yet. integration_tests: Exact-head CI 34169968811 completed failure. Whitespace and compatibility contract/source/installed diagnostics passed; `Run registry and plugin tests` failed; package builds were skipped; avatar CPU budget passed. No merge-ready claim. verification_evidence: Current `task_state.py` defines module-global `_CALLER_ENDPOINTS` and `_VERIFIER_ENDPOINTS` WeakKeyDictionaries plus `_verifier_request()` and `_TaskStateProtocol.request()`. While the verifier exists, its token is a live `_VERIFIER_ENDPOINTS` key, making verifier callable authority recoverable by an importing in-process caller. Public caller evidence still rejects `passed`, SWI-Prolog launch retains `shell=False`, and repository pre/post validation plus `invalidate_completion` compensation/fencing remains present. core_handoffs: lost-rob0t/zara#400 remains open for canonical cross-plugin capability composition; it is not needed for this bounded repair and no Core internals should be imported. blockers: #515 is not semantically merge-ready because verifier authority is reconstructible from module-global registries, and exact-head CI is red in registry/plugin tests. next_mode: IMPLEMENT next_target: On #515, add RED coverage proving an importing generic caller can enumerate/recover verifier endpoint authority and mint a verifier pass; replace module-global authority registries with a construction where generic/session code has no discoverable verifier reference or raw trusted protocol path, then identify/fix the exact registry/plugin test failure and rerun focused + exact-head gates.
nsaspy commented 2026-09-08 02:17:46 +00:00
Author
Owner
Copy link

WORKER_STATE
mode_used: IMPLEMENT
result: RED-first module-registry authority-recovery coverage added, then module-global caller/verifier endpoint registries removed. Caller and verifier writes now traverse distinct broker queue channels; the verifier channel derives the trusted verifier operation/provenance while generic TaskStateSession retains only the caller endpoint. Existing repository pre/post validation, stale-completion invalidation/fencing, and SWI shell=False are preserved. No Core internals/contracts were needed for this slice.
refs: #515; RED dec9b21f99dadf00ef69595b2fa72867ce6a9b1a; implementation 5261e87f7d244ec1499dfb2534d0df1c5d8a3dcb; #515 comment 5577780977; CI 34177005458
head: 5261e87f7d
tests: RED-first test_module_does_not_publish_verifier_endpoint_registry plus existing verifier-authority boundary coverage. Exact-head CI run 34177005458 was started for this head; final status was not independently resolved through the available connector response during this bounded run, so no green/merge-ready claim is made.
blockers: exact-head CI 34177005458 must be resolved before any merge-ready claim. No Core blocker identified in this slice.
next_mode: REVIEW
next_target: first verify exact-head CI 34177005458; then adversarially test broker/channel authority recovery via thread/frame/queue introspection, endpoint replay/leakage, shared-protocol restart/fencing semantics, model/shell reachability, and preservation of the repository CAS/compensation boundary.

WORKER_STATE mode_used: IMPLEMENT result: RED-first module-registry authority-recovery coverage added, then module-global caller/verifier endpoint registries removed. Caller and verifier writes now traverse distinct broker queue channels; the verifier channel derives the trusted verifier operation/provenance while generic TaskStateSession retains only the caller endpoint. Existing repository pre/post validation, stale-completion invalidation/fencing, and SWI shell=False are preserved. No Core internals/contracts were needed for this slice. refs: #515; RED `dec9b21f99dadf00ef69595b2fa72867ce6a9b1a`; implementation `5261e87f7d244ec1499dfb2534d0df1c5d8a3dcb`; #515 comment `5577780977`; CI `34177005458` head: 5261e87f7d244ec1499dfb2534d0df1c5d8a3dcb tests: RED-first `test_module_does_not_publish_verifier_endpoint_registry` plus existing verifier-authority boundary coverage. Exact-head CI run `34177005458` was started for this head; final status was not independently resolved through the available connector response during this bounded run, so no green/merge-ready claim is made. blockers: exact-head CI `34177005458` must be resolved before any merge-ready claim. No Core blocker identified in this slice. next_mode: REVIEW next_target: first verify exact-head CI `34177005458`; then adversarially test broker/channel authority recovery via thread/frame/queue introspection, endpoint replay/leakage, shared-protocol restart/fencing semantics, model/shell reachability, and preservation of the repository CAS/compensation boundary.
Sign in to join this conversation.
No Branch/Tag specified
Branches Tags
main
feat/p0-prolog-python-nim-product-packages
fix/860-lisp-evidence-type-fence-20260921
feat/strange-loop-experts
companion/805-android-animations-20260917
feat/star-kb-agent
fix/860-lisp-apply-input-schema-20260921
agentic15/lane3-closed-output-contracts
feature/doordash-commerce
feat/860-lisp-symbolic-conversation-20260921
feat/mara-emacs-todo-roam-928
feat/zara-symbolic-memory
fix/860-lisp-apply-verification-lineage
expert-builder-2/nix-bash-current-core-20260920
fix/860-core-lisp-composition
fix/860-lisp-composition-argument-authority
feat/864-nix-bash-style-sources
fix/859-language-handler-verdict
fix/859-language-handler-failed-verdict
fix/859-expert-stop-unregister
feat/863-js-ts-java-kotlin-host
fix/860-lisp-delegation-status
feat/expert-composition-864
feat/862-language-expert-adapters-v2
chore/dotfiles-expert-ownership-20260919
feat/zara-emacs-deep-20260919
feat/862-language-expert-adapters
feature/866-wiki-gates-search
codex/emacs-kb-857-20260919
feat/851-zara-ssh-files
feat/844-zara-music-prolog-tools
feat/emacs-workflows-20260919
feat/org-roam-shared-memory-2026-09-19
feat/844-zara-music
feat/calendar-caldav-824
feature/zara-activity-android-826
feat/zara-home-ha-transport
feat/prolog-policy-plugin-20260917
feat/812-prolog-policy-default-kb
feat/zara-home-ha-events
feat/839-zara-pi-bash-tmux
feat/zara-cota-static-gtfs-830
feature/zara-mobility-829-20260917
docs/agents-working-model-20260917
codex/808-stock-expert-2026-09-17
feat/linux-context-hooks
feat/811-prolog-policy-advice
fix/zara-coding-criteria-provenance-v2
plugin-d/local-recall-transactional-install
plugin-b/pipewire-player-506
plugin-d/508-discord-transactional-install
fix/zara-discord-startup-fail-closed
fix/browser-list-tabs-primary-error
fix/zara-coding-evidence-provenance
feat/zara-browser-webdriver-backend
rage/503-files-root-shape
rage/500-calendar-mutation-proof
rage/495-contacts-create-proof
rage/497-calendar-write-evidence
rage/495-contacts-create-evidence
rage/489-comms-send-evidence-replay
rage/485-calendar-free-busy-evidence
rage/489-comms-send-evidence
rage/485-calendar-free-busy-evidence-replay
rage/489-comms-send-payload-proof
rage/487-calendar-event-temporal-order
rage/483-timers-persisted-numeric-types
rage/481-github-pr-provider-metadata
rage/479-media-numeric-metadata
rage/477-media-accepted-bool
rage/475-comms-attachment-size-type
rage/471-sysadmin-provider-booleans
rage/473-comms-provider-booleans
rage/469-home-scene-verified-bool
rage/467-contacts-accepted-bool
rage/465-calendar-accepted-bool
rage/463-media-provider-booleans
rage/461-discord-boolean-policy
rage/459-expert-host-policy
rage/457-discord-chance-policy
rage/455-timers-numeric-descriptors
rage/453-discord-history-bounds
rage/451-browser-session-bounds
rage/449-avatar-renderer-command-config
rage/447-avatar-directory-policy
rage/407-avatar-renderer-policy-replay
rage/444-discord-context-bound-types
rage/444-discord-context-bound-types-replay
fix/443-avatar-idle-cpu
rage/439-discord-audit-bound-types
rage/439-discord-audit-red-proof
rage/435-healthcheck-numeric-types-replay
rage/435-healthcheck-numeric-types
rage/434-files-numeric-types
rage/432-contacts-numeric-types
rage/429-sysadmin-numeric-types
rage/427-calendar-numeric-types
rage/425-comms-policy-types
rage/423-media-constructor-limit-types
rage/421-media-queue-search-types
rage/419-media-playback-types
rage/417-local-recall-selector-type
rage/415-local-recall-bool-limits
rage/413-context-plugin-ttl-type
rage/411-context-freshness-types
rage/409-knowledge-config-types
rage/407-avatar-renderer-policy
rage/403-agent-zero-config-types-v2
rage/403-agent-zero-config-types
rage/403-agent-zero-config-red
rage/399-starintel-numeric-types-v2
rage/399-starintel-numeric-types
rage/399-starintel-numeric-red
rage/395-emacs-config-types-v2
rage/395-emacs-config-types
rage/395-emacs-config-red
rage/392-brave-config-types-v2
rage/392-brave-config-types
rage/377-coding-prolog-policy-v2
rage/377-red-proof-v2
rage/387-github-integer-limits
rage/385-github-numeric-config
rage/377-coding-prolog-policy-descriptors
rage/382-memory-duplicate-projections
rage/379-shell-runtime-limit-type
rage/374-memory-duplicate-recall
rage/369-coding-inspector-descriptors
rage/368-memory-projection-evidence
rage/370-shell-policy-collections
rage/366-memory-backend-fact-bound
rage/364-shell-policy-descriptors
rage/362-memory-recall-bound
rage/360-expert-bool-bounds
rage/358-github-config-bools
rage/356-github-number-types
rage/354-shell-runtime-bool
rage/352-memory-jsonrpc-id-type
rage/350-memory-mcp-result-status
rage/348-memory-mcp-oserror
rage/345-memory-schema-registration-type-v2
rage/345-memory-schema-registration-type
rage/340-memory-schema-types-v2
rage/340-memory-schema-types
rage/336-coding-task-state-executable-v2
rage/338-memory-bounded-facts
rage/336-coding-task-state-executable
rage/334-memory-type-selector-validation
rage/332-coding-canonical-changed-paths
rage/330-shell-invalid-subprocess-strings
rage/328-memory-provenance-alias
rage/326-memory-write-evidence
rage/324-memory-fact-term
rage/322-memory-scope-type
rage/320-shell-cwd-type
rage/318-memory-provenance
rage/316-memory-query-type
rage/314-shell-argv-container
rage/312-shell-env-mapping
rage/310-current-zara-pin
rage/308-shell-typed-stdin
rage/306-memory-schema-fact-isolation
rage/303-github-strict-result-limits
rage/301-shell-strict-runtime-config
rage/298-shell-environment-allowlist
rage/296-memory-mcp-finite-deadline
rage/294-memory-mcp-response-identity
rage/292-memory-type-isolation
rage/290-shell-byte-limits
rage/288-task-dependencies
rage/286-current-verifier-failures
rage/284-shell-finite-runtime
rage/280-latest-verifier-result
rage/282-shell-typed-config
rage/1-verifier-owned-evidence
rage/registry-timeout-abort
rage/registry-module-import-timeout
rage/registry-bound-module-entrypoints
rage/registry-bound-contract-attributes
rage/registry-service-factory-timeout
rage/registry-legacy-entrypoint-timeout
rage/coding-task-repository-context
rage/registry-sync-timeout-bounds
rage/registry-real-sync-timeouts
rage/coding-task-state-protocol-fence
rage/registry-installed-import-isolation
rage/coding-task-state-response-timeout
rage/coding-task-state-crash-fence
rage/coding-task-state-status-contract
rage/registry-dependency-env-construction
rage/248-document-task-completion
docs/248-task-state-contract
rage/246-freeze-completed-task
rage/244-evidence-status
rage/242-passing-verification
rage/240-task-state-bounds
rage/242-passing-evidence
rage/238-prolog-task-state
rage/236-verifier-duplicate-evidence
rage/234-canonical-verification-object-ids
rage/232-service-plugin-type-agreement
rage/230-deduplicate-worktree-evidence
rage/228-deduplicate-changed-path-evidence
rage/226-isolate-agent-zero-env
rage/224-isolate-avatar-renderer
rage/222-isolate-starintel-live-env
rage/220-strip-live-provider-secrets
rage/215-module-level-factory
rage/217-canonical-evidence-paths
rage/213-commit-tree-object-id
rage/211-diff-head-object-id
rage/209-inspect-head-object-id
rage/207-worktree-head-object-id
rage/205-service-api-version
rage/199-branch-object-id
rage/202-worktree-lock-proof
rage/200-worktree-add-proof
rage/199-branch-object-ids
rage/197-log-object-ids
rage/195-numstat-errors
rage/193-diff-snapshot
rage/191-inspect-dirty-snapshot
rage/189-atomic-branch-create
rage/187-branch-inventory-snapshot
rage/185-fence-branch-create
rage/183-confine-installers
rage/181-confine-plugin-roots
rage/179-strict-service-metadata
rage/177-compat-lifecycle-timeout
rage/175-canonical-install-command
rage/173-python-dependency-metadata
rage/171-canonical-search-paths
rage/169-registry-updated-date
rage/167-canonical-registry-strings
rage/registry-installer-layout-agreement
rage/registry-install-command-grammar
rage/registry-source-urls
rage/registry-search-path-metadata
rage/registry-install-target-metadata
rage/registry-flake-source-metadata
rage/registry-license-metadata
rage/compat-runtime-advice-contract
rage/compat-runtime-worker-sync
rage/compat-runtime-worker-signature
rage/compat-runtime-worker-identity
rage/coding-worktree-remove
rage/compat-runtime-advice-shutdown
rage/compat-runtime-dispatch-contract
rage/registry-nix-metadata-agreement
rage/registry-runtime-readonly-config
rage/registry-require-docs
rage/registry-runtime-closed-workers
rage/registry-confine-metadata-paths
rage/registry-runtime-subscription-lifecycle
rage/registry-runtime-worker-contract
rage/registry-runtime-subscribe-contract
rage/registry-lifecycle-call-semantics
rage/registry-service-tools-call-semantics
rage/registry-async-tools
rage/registry-async-lifecycle
rage/registry-enabled-default-contract
rage/registry-legacy-precedence
rage/registry-legacy-entrypoint-proof
rage/registry-canonical-tool-names
rage/registry-tool-metadata-quality
rage/registry-description-metadata
rage/registry-search-path-discovery
rage/registry-isolate-plugin-imports
rage/registry-tool-name-collisions
rage/1-zara-coding-evidence-branch-shape
rage/1-zara-coding-verify-branch-shape
rage/1-zara-coding-evidence-root-shape
rage/1-zara-coding-verify-root-shape
rage/1-zara-coding-worktree-evidence-path-shape
rage/1-zara-coding-verify-worktree-path-shape
rage/1-zara-coding-verify-path-boundary
rage/1-zara-coding-repository-text-evidence
rage/1-zara-coding-verify-evidence-shape
rage/1-zara-coding-snapshot-evidence-shape
rage/1-zara-coding-worktree-evidence-shape
rage/1-zara-coding-branch-inventory-bound
rage/1-zara-coding-verify-head-shape
rage/1-zara-coding-diff-snapshot
rage/1-zara-coding-rollback-proof
rage/1-zara-coding-inspect-bound
rage/1-zara-coding-dirty-path-coherence
rage/1-zara-coding-doc-current-surface
rage/1-zara-coding-add-lock-rollback
rage/1-zara-coding-changed-path-verify
rage/1-zara-coding-worktree-absent
rage/1-zara-coding-worktree-verify
rage/1-zara-coding-worktree-add-locked
rage/1-zara-coding-worktree-remove
rage/1-zara-coding-branch-assertion
rage/1-zara-coding-check-repository
rage/1-zara-coding-verify-tool
rage/1-zara-coding-spec-verify
rage/1-zara-coding-repository-evidence
rage/1-zara-coding-spec-compile
rage/1-zara-coding-worktree-add
rage/1-zara-coding-branch-create-cas
rage/1-zara-coding-commit
rage/1-zara-coding-branch-delete
rage/1-zara-coding-branch-create
rage/1-zara-coding-worktree-inventory
rage/1-worktree-list
rage/1-repo-list-status
rage/1-spec-language-catalog
rage/1-git-diff-summary
rage/1-git-log-adapter
rage/1-zara-coding-spec-normalize
rage/7-symbolic-memory-native-remember-get
rage/1-zara-coding-task-state
rage/5-zara-shell
rage/8-home-assistant-adapter
rage/7-zara-memory
rage/13-zara-voice-lab
rage/12-zara-voice
rage/8-zara-home-rules
rage/8-zara-home
rage/2-zara-expert
rage/32-discord-scoped-moderation
rage/31-discord-moderation-ack
rage/28-discord-moderation-audit
rage/35-discord-ci-preset
rage/33-discord-channel-commands
rage/33-discord-channel-inspection-policy
rage/27-discord-opt-in-message-content
rage/34-discord-content-diagnostics
rage/30-discord-public-output-privacy
rage/29-discord-user-isolation
rage/12-voice-runtime
rage/53-installed-runtime-smoke
rage/53-lifecycle-compat
rage/12-voice
rage/19-healthcheck-clean
rage/19-healthcheck
rage/16-timers
rage/11-comms
rage/17-contacts
rage/10-calendar
rage/14-media
rage/6-sysadmin
rage/15-files
rage/9-browser
rage/4-context
rage/3-desktop
rage/3-desktop-red
rage/52-emacs-red
rage/18-51-knowledge-brave
rage/50-github-red
fix/agent-zero-native-api
rage/53-zara-compat-red
feat/zara-starintel-server-47
fix/discord-recent-context
feat/agent-zero-bridge-40
fix/discord-tool-execution
feat/zara-persona-37
feat/declarative-runtime-layout
feat/discord-inspection-moderation
fix/discord-manager-permissions
feat/zara-org-todos
codex/zara-plugins-ci-push
feat/zara-discord
No results found.
Labels
Clear labels   
accessibility
Barrier affecting people with disabilities

  
bug
Something isn't working

  
documentation
Improvements or additions to documentation

  
duplicate
This issue or pull request already exists

  
enhancement
New feature or request

  
good first issue
Good for newcomers

  
help wanted
Extra attention is needed

  
invalid
This doesn't seem right

  
question
Further information is requested

  
security

   
wontfix
This will not be worked on

No labels
accessibility
bug
documentation
duplicate
enhancement
good first issue
help wanted
invalid
question
security
wontfix
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
nsaspy/zara-plugins#53
No description provided.