Sync and advanced dashboard health audit: repeated repairs, ownership conflicts, private Brain update, false drift and source readiness

[stuinfla]

Summary

After running ak sync (twice, back to back), the dashboard (ak dashboard → Overview) still shows 6 warnings. Each warning card tells the user to run ak sync, but sync cannot clear any of them. I traced each one to its cause in the installed source. I found four separate defects. In two of them, sync prints ✓ for a step that did not fix what ak status flags. There are also three smaller dashboard and status problems.

#	Subsystem	Dashboard says	What ak sync does	Root cause (file)	Severity
1	mcp	legacy ruflo-keyed MCP registration → "sync migrates it"	prints ✓ mcp: claude-flow registered, never removes the legacy entry	lib/mcp.mjs register() / registrationStatus() disagree on what is migratable	High: the same ~290-tool MCP server loads twice in every Claude session
2	blocks	ruflo-providers-reference→upserted → "sync reconciles blocks"	prints ✓ blocks(CLAUDE.md): in sync	status/nudge build detector context without guidanceContextFromConfig()	Medium: drift that can never clear
3	agentdb	"agentdb CLI not installed" → "setup/sync installs it"	fails every run: npm error EEXIST … ~/.npm-global/bin/agentdb	bin collision with agentic-flow's agentdb proxy; detector checks only node_modules/agentdb	Medium: sync fails on every run
4	ruvnet-brain	"v4.3.22 → v4.3.28 available → sync refreshes the KB"	fails every run: fresh-install activation refused because this brain contains a private overlay	ak always runs the fresh-install path, even when the installer requires --update	Medium: sync fails on every run, and the KB stays stale

Environment

agentic-kit	4.0.0-alpha.55 (next tag; latest tag is 4.0.0-alpha.0)
ruflo	3.45.0
agentic-qe	3.14.3
Claude Code	2.1.282
ruvnet-brain	plugin 4.3.28, KB bundle 4.3.22
Node / npm	v24.18.0 / 11.16.0 (Homebrew node@24)
OS	macOS 27.0 (Apple Silicon)
kit.json hosts	{"claude": true, "codex": false, "opencode": false}. The codex and opencode CLIs are installed but not enabled

Reproduction

ak sync                 # run 1
ak sync                 # run 2: identical result
ak status --deep        # still lists the same warnings
ak dashboard            # Overview → "6 warnings", each one saying "run ak sync"

Output of ak sync (identical on both runs):

sync plan (5 action(s)):
  • [ruvnet-brain] sync refreshes the KB — because: ruvnet-brain release v4.3.22, release v4.3.28 available
  • [agentdb] setup/sync installs it (pinned to ruflo's bundled agentdb) — because: agentdb CLI not installed
  • [mcp] sync migrates it to claude-flow at user scope — because: legacy 'ruflo'-keyed MCP registration present (user)
  • [blocks] sync reconciles blocks — because: 1 CLAUDE.md block(s) drifted: ruflo-providers-reference→upserted
  • [aqe-embedding] verify selected backend and repair missing opted-in local model

✗ ruvnet-brain: ✗ install stopped: fresh-install activation refused because this brain contains a private overlay
✗ agentdb: npm error with --force to overwrite files recklessly. ...
✓ mcp: claude-flow registered (user scope), 0 tool(s) denied per kit.json
✓ blocks(CLAUDE.md): in sync
✗ aqe-embedding: Local embedding setup incomplete. Recommended: local Ollama + MiniLM ...

Note the two ✓ lines. ak status, run straight afterwards, still reports mcp and blocks as drifted.

---

1. Legacy ruflo MCP entry is never migrated, but sync reports ✓ (High)

State on disk (~/.claude.json → mcpServers):

ruflo        → /Users/<me>/.npm-global/bin/ruflo  args: ["mcp"]
claude-flow  → ruflo                               args: ["mcp","start"]

claude mcp list shows both as ✔ Connected. Impact: every Claude Code session loads the full Ruflo tool surface twice (mcp__ruflo__* and mcp__claude-flow__*, about 290 tools each). This doubles deferred-tool noise and context cost, and tools can be routed to either copy.

Cause:

• registrationStatus() in src/lib/mcp.mjs marks every user-scope legacy entry as auto-migratable:

  const autoMigratableLegacyScopes = topology.legacyRufloScopes.filter((scope) => scope === 'user');

  As a result, status/sections/mcp.mjs promises "sync migrates it to claude-flow at user scope".
• register() only removes a legacy entry that passes replaceableRufloRegistration(). That check requires command === 'ruflo' and args deep-equal to ['mcp','start']:

  const removableLegacy = legacy && replaceableRufloRegistration(legacy) ? legacy : null;

  This legacy entry uses an absolute path and args ["mcp"], so it is skipped silently. Because claude-flow is already canonical, alreadyDesired is true, register() returns true, and sync prints ✓.

Suggested fix (either option):

• (a) Treat any user-scope ruflo entry whose command resolves to the ruflo binary (basename ruflo, or realpath equal to which ruflo) and whose args start with mcp as replaceable, or
• (b) If it is intentionally preserved, have registrationStatus() apply the same replaceableRufloRegistration() predicate, so that status says "preserved — remove with claude mcp remove ruflo -s user" instead of promising a migration. Sync should also print ⚠, not ✓, while a legacy entry remains.

A regression test should cover an absolute-path legacy entry (/…/bin/ruflo, args ["mcp"]).

---

2. blocks drift can never clear: status and sync evaluate the detector in different contexts (Medium)

ruflo-providers-reference is gated on codexEnabled, with a fallback to {type:'command', target:'codex'} (PATH).

• Sync calls reconcileGuidance(), which wraps the context with guidanceContextFromConfig(cfg). That gives codexEnabled = false (from kit.json), so the block is correctly omitted and sync reports "in sync".
• Status (src/commands/status/sections/blocks.mjs:23) and the nudge (src/lib/nudge.mjs:43) build a bare context:

  const ctx = { flags: { dualMode: bothHostsEnabled(cfg), opencodeEnabled: !!cfg.integrations?.hosts?.opencode } };

  codexEnabled is absent, so the detector falls back to "is codex on PATH?". It is (installed but disabled), so status reports →upserted on every run.

~/.claude/CLAUDE.md does not contain the block, which is correct for kit.json. So sync is right and status/nudge are wrong. The comment in nudge.mjs states its contract as "never disagrees with ak status". Both call sites should instead share sync's context.

Suggested fix: in status/sections/blocks.mjs and lib/nudge.mjs, call reconcileGuidance({ …, dryRun: true }), or at least guidanceContextFromConfig(cfg, ctx), so that all three paths share one context builder. Status also passes retiredForTarget(rowsReg, t.name) without knownTargets, while reconcileGuidance passes it. That is a second, latent divergence. A good regression test: kit.json with codex:false plus a codex binary on PATH should mean status reports no drift.

---

3. agentdb install fails on every sync with EEXIST (bin owned by agentic-flow); the detector misreports "not installed" (Medium)

$ ls -l ~/.npm-global/bin/agentdb
agentdb -> ../lib/node_modules/agentic-flow/dist/cli/agentdb-proxy.js
$ agentdb --version
agentdb v3.0.0-alpha.20          # ← the exact version ak wants to pin
$ ls ~/.npm-global/lib/node_modules/agentdb
No such file or directory

npm log (npm install --global --allow-scripts … agentdb@3.0.0-alpha.20):

error code EEXIST
error path ~/.npm-global/bin/agentdb
error File exists: ~/.npm-global/bin/agentdb

Cause:

• globalVersion() in src/lib/agentdb.mjs checks only <globalRoot>/agentdb/package.json. It never considers that a working agentdb bin can be supplied by another global package (agentic-flow ships an agentdb proxy bin).
• The install in setup.mjs (around line 341) then collides with that bin. npm refuses, and the same failure repeats on every sync forever.

Suggested fix:

• Detect bin ownership first (readlink of $(npm prefix -g)/bin/agentdb). If agentic-flow owns it, either (a) accept it when agentdb --version matches the bundled target and report "provided by agentic-flow proxy", or (b) report a clear, specific conflict with a guarded remediation (for example, a Maintenance action that removes the proxy symlink and retries), rather than re-running a doomed install every sync.
• Do not blindly add --force. That would clobber agentic-flow's bin.
• ak x verify (verify.mjs:259) uses have('agentdb'), which is satisfied by the proxy. So verify and status already disagree about whether agentdb is present.

---

4. ruvnet-brain refresh fails on every sync: ak uses the fresh-install path, but an existing KB with private stores requires --update (Medium)

ak runs npx ruvnet-brain@latest with INSTALL_ARGS = ['--yes','--no-stack','--no-enhance','--no-nightly-prompt','--no-telemetry'] (src/lib/ruvnet-brain.mjs:33-34). The ruvnet-brain 4.3.28 installer (bin/install.mjs, around line 673) deliberately refuses that path when the live KB has private overlays:

if (stores.some((store) => store?.updateManaged === false)) {
  die('fresh-install activation refused because this brain contains a private overlay',
      `Run npx ruvnet-brain --update so the bundle updater preserves those private stores.`);
}

This machine's ~/.cache/ruvnet-brain/kb/SOURCE.json has 8 stores with updateManaged: false. grep -rn "'--update'\|updateManaged" src/ in agentic-kit returns nothing, so ak has no path that can succeed here. The KB is stuck at 4.3.22 while the plugin is at 4.3.28, and the brain's own SessionStart hook raises an "INSTALL ALARM: plugin and knowledge bundle are out of sync" on every session.

Suggested fix: when ~/.cache/ruvnet-brain/kb/SOURCE.json exists, and particularly when any store has updateManaged === false, invoke the updater (--update, together with the relevant --no-* opt-outs) instead of the fresh installer. Alternatively, surface the installer's own remediation text in the status/dashboard card instead of "sync refreshes the KB".

---

Smaller issues found while reviewing the dashboard

5. aqe-embedding: sync and status disagree about severity. Sync prints ✗ aqe-embedding: Local embedding setup incomplete… and lists it under still failing. The dashboard shows the same subsystem as a grey informational · ("backend configured-unverified"), not counted among the 6 warnings. On this machine the cause is environmental: Ollama 0.20.4 is installed at /usr/local/bin/ollama but not running (ollama serve). The message could detect "installed but not running" and say that, instead of "Install Ollama". Status and sync should also agree on whether this is a failure.

6. Permanent warnings with no remediation. Two warning cards count toward "attention advised" but offer no action, and sync cannot change them:

   • ruvnet-brain-plugin: "Automatic hook declarations differ from the exact reviewed 4.3.17/4.3.26 contracts for plugin version 4.3.28". src/lib/brain-hook-contract.mjs deep-equals the hooks against two hard-coded contracts, so every new brain plugin release trips a warning until ak ships a new contract. Consider an info level for "unreviewed newer version", or a documented way to review and accept it.
   • agent-browser: "external agent-browser 0.38.1 is outside Ruflo >=0.27.0 <0.28.0; preserved". This is intentional preservation (Track agent-browser + vibium as managed components — visibility, not a fix request #189), but it is permanently amber with no suggested action.

   Together with issues 1–4, all 6 dashboard warnings on this machine are warnings that ak sync cannot clear. For a user, "attention advised" can then never go green.

7. GET /api/system returns a 22.9 MB JSON payload (22,923,686 bytes; served in about 0.1 s locally). Almost all of it is catalog: catalog.items is 13.8 MB for 1,258 items, catalog.artifacts is 4.2 MB for 4,986 entries, and catalog.consumerBindings is 2.1 MB for 5,841 entries. The server is fast, but the browser has to parse about 23 MB on the System tab. This machine has 73 tracked projects, so the payload will grow with project count. Consider pagination, or lazy-loading items and artifacts on demand.

---

What I did NOT verify

• I did not apply any fix locally. The suggested fixes have not been tested.
• I did not test on Linux, or with a clean npm prefix where agentic-flow is not installed.
• I did not check whether the duplicate MCP registration causes functional conflicts (for example, double hook firing). I only confirmed that both servers connect and both tool sets load.
• aqe-embedding was not retested with Ollama running.
• The dashboard session token is omitted from this report on purpose.

---

Follow-up audit — 2026-09-26: exact ownership, unresolved repairs, and live-source health

This supplements the original report with a fresh read-only audit of installed 4.0.0-alpha.55. It separates product defects from local configuration and tightens the proposed fixes. Related dashboard evidence is tracked in #238. The original measurements above are historical; they were not all repeated in this audit.

Current verification and scope

• macOS 27.0, build 26A428, Apple Silicon; Node v24.18.0; npm 11.16.0.
• Installed Agentic Kit: 4.0.0-alpha.55. Live npm tags: next=4.0.0-alpha.55, latest=4.0.0-alpha.0; no newer published next was found in this check. Do not recommend switching to latest as an upgrade.
• Live npm Ruflo latest=3.45.0; current kit status reports installed Ruflo 3.45.0.
• Brain plugin 4.3.28 / installed KB SOURCE.json brainVersion 4.3.22. Eight entries carry updateManaged:false (private identities omitted).
• The installed KB does contain coverage-integrity.mjs. A missing-validator incident in older sessions must not be assumed to explain this failure.
• Persisted host intent is {claude:true,codex:false,opencode:false}. Codex is nevertheless used independently of Kit.
• Persisted AQE intent is {mode:"endpoint",endpoint:"http://127.0.0.1:11434",provisioning:"ollama"}. GET /api/tags fails with connection refused.
• Both configured advanced-dashboard sources are absent: .claude-flow/live-events.jsonl and .agentic-qe/live-events.jsonl.
• Current launch directory is not a Git repository and has no project memory DB or AQE initialization. ruflo memory search --query ... --path <project>/.swarm/memory.db returned Database not found. This is absence of initialization, not evidence of a broken existing memory store.
• ak sync --dry-run still lists five actions: Brain, AgentDB, MCP, blocks, and AQE embeddings. No mutating sync/setup was run during this follow-up.
• No dashboard listener was found on port 7431 during the follow-up. Browser refresh was unavailable, so the earlier rendered dashboard observations are not presented as fresh screenshots.

A. Confirmed false block drift: minimal reproduction and acceptance test

src/commands/status/sections/blocks.mjs constructs only dualMode and opencodeEnabled. It does not call guidanceContextFromConfig. src/lib/blocks.mjs:reconcileGuidance does call that function and supplies codexEnabled:false from persisted intent. The ruflo-providers-reference detector therefore falls back to executable presence in status, but uses explicit intent during repair.

Read-only comparison:

import { loadKitConfig } from './src/lib/config.mjs';
import { reconcileGuidance } from './src/lib/blocks.mjs';
await reconcileGuidance({
  cwd: process.cwd(), cfg: loadKitConfig(), pkgRoot: process.cwd(), dryRun: true,
});

Run this from the Kit package/source root with equivalent user config. In the affected environment, all returned targets had changed:"", while ak status --json still reported ruflo-providers-reference→upserted.

Fix: share the reconciliation context/target selection among status, nudge, setup, and sync; also align the retiredForTarget known-target arguments. Do not add a providers block simply to silence this false warning.

Acceptance: with Codex installed but explicitly disabled in Kit, status, nudge, and dry-run reconciliation all agree on no drift. Repeat for enabled hosts, explicitly disabled Brain/AQE, and re-scoped custom blocks. Actual changes still produce actionable drift.

B. MCP preservation is correct; promising an automatic repair is not

Current user-scope entries are:

ruflo        command=<npm-global>/bin/ruflo  args=["mcp"]             env={}
claude-flow  command=ruflo                  args=["mcp","start"]    env keys=[AGENT_BROWSER_CONFIG]

src/lib/mcp.mjs:replaceableRufloRegistration accepts only the exact canonical command/argument shape. register can return success because the canonical entry already exists, while leaving the legacy entry. Status's auto-migratable classification is broader than that mutation predicate.

Fix: use one ownership/migratability predicate in planning, status, and execution. Recognize verified equivalent global binary paths and specifically supported legacy arguments only when safe. Otherwise say “custom registration preserved; manual migration required” and disclose both entries. Confirm replacements, retain rollback, and verify final topology.

Safety correction to the original suggestion: basename ruflo or arbitrary arguments beginning with mcp alone are not sufficient authority to remove a registration. Preserve unknown environment variables, wrappers, custom arguments, and foreign registrations.

Acceptance: tests for absolute global paths, mcp versus mcp start, custom env, wrappers, project scope, failed registration with restoration, and canonical-already-present. A preserved entry must never be described as migrated. Duplicate connection/tool counts and cost impact require separate runtime evidence; this follow-up does not remeasure them.

C. Brain repair must distinguish update from replacement

src/commands/sync.mjs invokes heal.installRuvnetBrain({force:true}). src/lib/heal.mjs builds an installer invocation with the selected release and --force, but no --update. An existing private-overlay installation rejects fresh activation. This guard is protecting data and must remain.

Fix: select the supported existing-install update flow; preserve telemetry/nightly opt-outs; verify the requested release is actually applied, rather than stamping it merely because a command exits zero. If the installer cannot honor the selected target or safely preserve overlays, surface the precise blocked condition.

Acceptance: fixture with public and updateManaged:false private stores; update to a different public release; private bytes/provenance unchanged; public bundle/plugin alignment verified; interrupted/failed update retains a usable prior generation; no fallback that overwrites private data. Cover fresh install separately. Existence of the trusted validator must be verified, but should not be misdiagnosed as missing here.

D. AgentDB: command ownership, compatibility, and explicit policy

The current command symlink belongs to agentic-flow/dist/cli/agentdb-proxy.js; no standalone global agentdb package is present. src/lib/agentdb.mjs:present checks only the standalone package. healAgentdb then attempts a global version-pinned install and npm encounters the owned executable.

Fix: inventory executable ownership first. Distinguish standalone package, proxy, compatible required capabilities, and unresolved conflict. A version string is not sufficient to establish that a proxy supports harvest or uses the intended store/schema. Verify required operations against isolated fixtures before accepting it. Provide an explicit opt-out/ownership boundary for installations that mandate Ruflo-only project-memory access and disallow standalone installs/version pinning. That mandate is a local policy conflict, not a universal claim that standalone AgentDB is invalid.

Acceptance: clean prefix, compatible proxy, incompatible proxy, absent target package, foreign executable, and explicit unmanaged/opt-out cases. No blind --force, bin deletion, disconnected store, or repeated doomed install. status, verify, and sync must agree on which capabilities are available and which remain blocked.

E. Additional product defect: missing structured sources can look healthy

The earlier advanced launch used:

ak dashboard --no-open --port 7431 \
  --live-source 'ruflo=.claude-flow/live-events.jsonl' \
  --live-source 'aqe=.agentic-qe/live-events.jsonl'

Both files are absent. Earlier Sources displayed one file / zero events / zero errors / “ok” for each. Source inspection explains why:

• src/lib/live/live-sessions-service.mjs:#add increments files when it registers a tailer, not when an actual file is successfully read.
• #reconcile marks the adapter status:'ok' after tailer.reconcile() returns.
• src/lib/live/jsonl-tailer.mjs:reconcile catches ENOENT and returns without reporting failure or presence state.

Fix: model configured-source count, present/readable-file count, ingestion state, accepted/rejected-record counts, and last accepted event independently. Late creation is legitimate; report “awaiting file” rather than healthy ingestion. Explain that --live-source observes an existing producer and does not enable Ruflo/AQE event production. structured-adapter.mjs requires a session ID, actor ID, and action; expose schema rejection diagnostics without exposing record contents.

Acceptance: absent file, empty file, valid record, schema-invalid record, malformed JSON, permission failure, removal/recreation, truncation, rotation, and multiple sources with mixed health. A missing or non-ingesting source must not be represented as verified operational. Test the adapter with fixtures, then prove a real producer event reaches the UI; synthetic records alone are not an end-to-end acceptance test.

F. Additional product defect: post-sync convergence excludes unresolved repairs

At the end of src/commands/sync.mjs, remaining initially includes rows whose level is fail, plus a special companion case. Recorded apply failures are added later, but a repairable warning that persists despite a successful step result can be omitted. This can produce “converged — no failing subsystems” even though status still proposes repairs.

Fix: separate applied steps, preserved/unmanaged advisories, blocked actions, and unresolved planned repairs. Recompare the post-state to the original plan using shared ownership predicates. Do not simply fail on every amber row: intentionally preserved external versions and unreviewed contracts are different from a promised repair that did not happen.

Acceptance: successful helper result plus persistent actionable warning yields partial/not-converged status and names the unresolved action. An intentionally preserved advisory does not trigger an endless repair loop. A real failure remains nonzero. Two successive runs after repair are idempotent. Pure verification steps, such as embedding verification, may run again, but must not repeatedly attempt a known impossible repair.

Local setup conditions: improve diagnostics; do not automatically mutate

1. Non-Git folder: ak setup --help explicitly says project setup normally requires .git, with --project available. Missing memory/AQE here is therefore expected until opted in, not an initialization bug by itself. Explain machine versus project readiness and point to the exact project initialization action. A dashboard-only launch folder does not need every project feature initialized.
2. Codex used outside Kit: separate installed/authenticated/in-use state from Kit routing intent (details in Dashboard: Codex shown as 'Disabled' while it's the main host in use; Live omits running sessions in non-git folders; 6 more display/diagnostic defects (with screenshots) #238). Do not automatically enable routing because activity is observed.
3. Ollama unavailable: selected loopback endpoint is refused. Explain selected backend, reachability, and synthetic embedding verification separately. Supported in-process mode is an alternative, but dependencies/model cache and existing corpus compatibility must be validated before switching. Do not create login services, migrate vectors, or silently enable a new backend.
4. Dashboard lifecycle: the command intentionally runs foreground and stops with its owning process. The absent listener is not itself a dashboard defect. Document this clearly rather than implying a persistent service.
5. Browser/plugin warnings: compatibility-range or unreviewed-hook warnings do not prove actual runtime failure. Provide an actionable review path and clearly state the evidence limit; do not downgrade or accept contracts just to make the dashboard green.

Recommended maintainer sequence

1. Fix shared status/repair predicates and add regression fixtures for block context, MCP ownership, missing sources, and post-sync convergence.
2. Implement safe Brain update selection and AgentDB conflict handling, preserving foreign/private state.
3. Improve readiness diagnostics for host routing, project initialization, and the chosen embedding backend.
4. Verify on a clean disposable macOS environment and an upgraded environment with existing bins, private overlays, custom MCP entries, and a non-Git launch folder. Keep fixtures isolated from real user data.
5. Publish a forward update with an explicit remediation guide and prove repeat-run idempotence. Measure any claimed performance improvement with a representative workload.

Limits of this follow-up

No suggested patch was implemented or tested. No Keychain, login item, permission, corpus, MCP, or user-guidance changes were made. No new actual ak sync was run; the mutating failures above are from the original report, while source/state/dry-run checks are fresh. No Linux/Windows regression, live embedding result, real structured producer event, fresh browser render, or performance benchmark was established. Paths, private store identities, transcript contents, credentials, and dashboard tokens are omitted.

[stuinfla]

Follow-up from implementing the local configuration remedies

The original issue remains a product report. Local fixes have now separated several environmental conditions from the remaining product limitations:

• Enabled the intended Codex routing, initialized an explicit project, started the already-selected local Ollama backend, and verified real 384-dimensional embeddings. ak x verify aqe passed its selected checks; fleet execution and recovery were not proved.
• A unique Ruflo write with explicit .swarm/memory.db path passed exact-key retrieval and direct SQLite row verification (quick_check=ok). A native sibling also exists; global MCP routing still needs separate proof. This is not a claim that every memory path is correct.
• Deliberately removed the legacy user-scope Claude alias only after both connections and the intended global binary were verified. The canonical connection remained healthy and the independent Codex registration was preserved.
• Targeted guidance reconciliation applied the now-needed dual-host blocks; a second preview was unchanged. The earlier installed-but-disabled detector disagreement still needs the product regression test described above.
• The real browser dashboard now shows an active Codex session, coordinator, worker, and live tool operations after project initialization. The missing explicit Ruflo/AQE JSONL paths were not replaced with fabricated feeds.

Additional valid-TOML compatibility limitation

src/lib/aqe-embedding-toml.mjs:aqeTomlEnvironment rejects valid unrelated dotted assignments before the AQE table. Minimal synthetic input:

tui.status_line = ["model"]
[mcp_servers.agentic-qe]
command = "aqe"
args = ["mcp", "start"]

Calling the exported parser returns dotted or quoted TOML assignments require manual embedding configuration. Preserving unsupported user configuration is appropriate; the limitation is that unrelated valid root syntax prevents automatic AQE projection and leaves a warning even after the intended endpoint is manually configured and verified.

Please distinguish unsupported editor syntax from missing/incorrect runtime environment. Consider recognizing unrelated root keys safely, or provide exact manual instructions and a separate read-only verification path using a complete TOML parser. Cover dotted keys that really alias managed tables, duplicates, quoted names, and multiline values; do not loosen ownership checks blindly.

Brain updater's second blocker, beyond Kit's wrong invocation

A direct existing-install update with RUVNET_BRAIN_NO_UPDATE_FALLBACK=1 safely stopped:

private overlay preflight failed: symbolic link is not a governed regular file: node_modules/.bin/semver — refusing to update.

No fresh-install fallback was attempted. Private content/manifests were hash-compared and preserved; a runtime identity timestamp changed. The KB remains behind the plugin. This preflight belongs to Brain, not necessarily Kit; it demonstrates why changing Kit to --update is necessary but not sufficient for this upgraded installation. Please surface this precise causal blocker and route it to the relevant upstream owner instead of repeatedly promising automatic convergence. Do not bypass the private-store guard or replace dependency files just to satisfy it.

No installed Kit source was patched. The standalone AgentDB/proxy conflict, unsupported global TOML projection, private Brain update failure, and separate compatibility/review advisories remain distinct from the locally corrected host/project/service configuration.

[stuinfla]

Verified follow-up: safe Brain update routing and corpus preservation

This follows the audit in this issue; it separates Kit behavior from dependency defects.

Agentic Kit repair needed

For an existing Brain installation, call the update path rather than force a fresh install. Set RUVNET_BRAIN_NO_UPDATE_FALLBACK=1 on that invocation so a rejected update cannot silently enter the published installer's separate recovery fallback. Remove the sync call's { force: true } override. Stamp only the observed installed release after success, and reject a missing or mismatched target rather than recording the requested version as installed.

A reversible local implementation passed six injected Kit tests. The real Kit updater then rejected the candidate before activation, as intended. A refused repair must remain degraded/refused in health reporting; it must not be presented as a completed upgrade.

Brain dependency findings

The installed private-file inventory walker treated ordinary npm tooling symlinks as forbidden corpus symlinks. Applying the already-committed walker correction restored the private-inventory step while preserving governed RVF protections.

The signed published candidate was authentic, but authenticity did not establish forward corpus freshness. Against 96 live managed public stores, the candidate omitted 14 and had older build timestamps for 74. The remaining eight later timestamps also did not establish eight forward corpus upgrades: four retained identical measured RVF bytes and provenance, three lost commit provenance, and one changed commit without proven ancestry.

A local pre-activation guard now checks all live managed public stores, excludes only live private stores, and rejects missing/older/unknown provenance. Candidate metadata cannot reclassify a public store as private to bypass the check. The real refused update preserved all 211 measured corpus/registry SHA256 hashes and all 52 private-file hashes. Brain checks passed: 16 safety tests and 37 regression tests. No corpus release was activated, and no safe published successor was found.

This is a Brain artifact/install-contract issue in addition to Kit's unsafe routing. Do not repair it by rewriting local release tags or forcing activation. The upstream remedy needs a sealed, forward-qualified corpus and a safe installer path with preserved private overlays.

Other dependencies, separate attribution

Fresh Ruflo MCP memory operations omitted the canonical database path, and embedding synchronization also omitted that path. Local path propagation repairs were verified through a fresh MCP write, exact CLI retrieval, and direct canonical-row proof. The sibling store was preserved. Existing host processes need restarting; package upgrades can overwrite these local patches.

AQE's fleet CLI reports accepted submissions as completed work and initializes its queen without domain plugins. A supported API harness with plugins actually completed two analysis tasks on separate agents and persisted an exact durable result. The fleet CLI remains unrepaired. Kit health should distinguish registered/accepted, executing, and completed states and require terminal task evidence before claiming execution health.

All fixes described here are local, reversible patches, not upstream released fixes. Private corpus, database backups, credentials, and transcripts are excluded from this report.

[stuinfla]

Verified local repairs and recommendations — 2026-09-26

This updates the earlier comments: the previously unrepaired fleet CLI and configuration-inspector problems now have reversible, locally tested corrections. These are installed-package patches, not published upstream fixes. Please retain the historical reports as historical evidence rather than treating their old readiness statements as current.

Attribution: product defects versus local recovery

Observed packages: Agentic Kit 4.0.0-alpha.55, Agentic QE 3.14.3, Ruflo 3.45.0. These are tested installed versions, not a claim about the latest registry release.

Finding	Owner / cause	Correction and evidence
Missing Codex quota could suggest Codex was absent or unauthenticated	Kit dashboard conflated quota availability with host/authentication health	Changed the fallback to say quota is unavailable and request a separate host-health check. Native login status, Kit host status, and a real dashboard provider connection challenge passed. The rendered Limits page showed subscription and weekly usage. No credential repair was needed.
Valid unrelated root TOML settings blocked AQE embedding inspection	Kit inspector rejected dotted/quoted assignments without limiting the check to managed keys	Allow unrelated root settings while conservatively refusing ambiguous managed-server aliases. Preserve unrelated configuration bytes. Regression fixtures cover supported and rejected forms.
Supported absolute AQE executable with exactly ["mcp"] was not recognized	Kit transport inspector's accepted forms were too narrow	Recognize the supported aqe / agentic-qe forms. Four existing host projections converged without rewriting configuration. Do not accept arbitrary wrappers or argument prefixes as ownership evidence.
Fleet accepted submissions were counted as completed work	AQE CLI initialized without the required domain plugins and did not wait for terminal outcomes	Load the requested existing domain, supply actual coverage data for analysis, wait for all worker outcomes, preserve failures, request cancellation on timeout, and persist real results. The active executable completed two coverage tasks on distinct agents; a fresh SDK process retrieved both durable results after CLI exit.
A live RVF lock was followed by a create attempt and misleading fsync failure	AQE shared adapter fell through after detecting a live owner	Return the supported unavailable/fallback outcome at confirmed live LockHeld; do not create, delete, quarantine, or replace the store or lock. Source and active bundle checks pass; genuine independent fsync failure still fails. The actual Kit AQE gate passed while explicitly reporting the busy-owner / unverified-integrity boundary. Store and lock hashes remained unchanged.
Session retained the former folder after rename	Local running-session state	Reopened/resumed in the canonical project; active memory write/read and independent explicit-path retrieval passed. No compatibility symlink needed.
Dashboard and chosen local embedding endpoint stopped across restart	Local foreground-process lifetime	Restarted existing services; verified rendered dashboard and a real 384-dimensional embedding response. No login service or system-preference change made.

The evidence supports integration defects plus ordinary local session/service recovery. It does not establish the exact first trigger of the original incident or show a fundamentally invalid workstation setup.

What was actually tested

• 29 focused Kit dashboard/parser/transport checks, seven fleet-helper checks, and six RVF-lock checks: 42 total, also run successfully through AQE's actual Node runner.
• Passing and deliberately failing runner fixtures produced exit 0 and exit 1.
• Missing coverage and invalid worker counts produced exit 1.
• Real fleet coverage execution, distinct assigned agents, terminal results, and independent post-exit durable retrieval.
• Real provider access, embedding request, rendered quota view, and actual AQE verification gate.
• Both distributed source and the active executable bundle were checked. Editing distributed source alone was insufficient to repair the bundled AQE CLI.

Not accepted: fleet test generation/security operations, generic task-submit execution, a complete multi-provider workflow, full RVF owner integrity/recovery, Linux/Windows behavior, or production-scale performance. A synthetic fixture is not evidence for every workflow.

Recommended product changes

1. One readiness and ownership contract. Status, dashboard, sync planning, repair, and post-repair verification should share predicates and configuration context. Represent installed, enabled, authenticated, reachable, capability-tested, executing, and completed separately. Missing quota, an unreviewed compatibility range, a busy store, and a failed provider challenge are different conditions.

2. Judge sync by verified postconditions. A helper returning success must not imply the promised repair happened. Re-evaluate the original planned actions against fresh state; classify unresolved repair, blocked action, intentionally preserved advisory, and verified result separately. Prevent repeated impossible repair attempts. Provide a per-component scope/exclusion option so another active subsystem can be left alone; --no-upgrade is not a component exclusion. Today's read-only preview still included a Brain refresh, so no broad sync was applied during this repair pass.

3. Make workers prove useful execution. Validate inputs and required domain capabilities before launching. Submission acknowledgment is only acceptance. Require an assigned executor, a terminal outcome, and an operation-appropriate result. Where persistence is part of the contract, verify independent retrieval. Exit nonzero on failure or timeout; report partial completion explicitly. Keep the CLI and shipped bundle behavior equivalent in release tests.

4. Treat contention as a first-class state. A live owner is not corruption. Surface which capability is unavailable and what remains unverified; preserve foreign state. Exercise concurrent owners, stale locks, genuine I/O failure, restart, and durable readback in isolated fixtures. Avoid healing by deleting locks or recreating existing stores.

5. Improve recovery guidance. Say “installed but not running” when that is measured; distinguish machine readiness from project initialization; explain foreground-service lifetime. Give precise guarded remedies for foreign-owned executable conflicts. Do not silently install a second memory store, downgrade user-managed tools, or create startup services merely to clear a warning.

Proposed worker early-warning system

This is a recommendation, not something implemented or verified here:

• Give each worker/task a correlation ID, expected capability, start deadline, absolute completion deadline, and expected result contract.
• Emit structured transitions: registered → accepted → started → terminal success/failure/cancelled. Store persistence verification separately. Never advance a task to success solely because a spawn or submit call succeeded.
• Monitor start acknowledgment, heartbeat, and meaningful progress separately. “Process alive” does not prove useful work. Checkpoints must suit the activity; do not require constant progress from a legitimate long-running operation.
• Raise an immediate diagnostic for missing domain handlers, invalid inputs, unsupported routes, rejected storage access, or inconsistent success/result evidence. Raise a bounded stalled-start/stalled-progress/overdue alert when the task contract is breached.
• Notify the parent coordinator and show a persistent dashboard warning with task ID, last observed state, elapsed/deadline, causal diagnostic, and a safe next action. CLI users should receive a concise stderr summary and truthful exit status. Use rate limiting and deduplication.
• Start with local notifications. External reporting should be opt-in, redacted, and minimal: versions, capability, state transitions, elapsed times, error category, and result-validation outcome. Exclude prompts, transcripts, credentials, dashboard tokens, project contents, and private paths.
• Request cancellation on deadline, verify whether it stopped, and label any remaining worker as still active/unconfirmed. Fence late callbacks so they cannot overwrite timeout/cancellation. Retry only safely repeatable operations with a bounded policy; do not launch replacement swarms indefinitely or reinterpret missing evidence as success.

Acceptance fixtures should include: accepted task that never starts; alive worker making no meaningful progress; slow legitimate task; missing plugin; failed child; timeout with cancellation refusal; claimed success with empty result; result lost after process exit; and healthy successful completion. Test notification delivery, not merely event generation. Then prove the monitor against a real producer/executor path.

Remaining upstream and local boundaries

Local patches can be overwritten by upgrades. Portable Kit and AQE source patches and the reproduction report have been retained in my private setup repository and can be supplied for maintainer review; private logs/databases are excluded. Please coordinate dependency fixes with AQE/Ruflo owners and avoid representing them as Kit-only defects.

Historical sibling memory stores remain preserved; the canonical active route was verified. Optional standalone harvesting remains disabled under this workstation's single-store policy. External browser compatibility remains an advisory with runtime acceptance outstanding.

Brain is being handled separately. This update neither repairs nor revalidates its corpus, and does not supersede the earlier private-state preservation concerns.

Subsequent non-Brain repair pass: native diagnostics and generic task execution

Two additional defects are now locally corrected and tested:

• Kit previously described every unsuccessful native load probe as a WASM fallback and discarded its cause. Sixteen fresh probes passed; the original intermittent failure cause remains unproved. The correction distinguishes native/unavailable/inconclusive and retains the cause. Unknown and unavailable results still fail verification; only an explicit timeout retries once. No package replacement was needed.
• Generic AQE task-submit initialized without a capable domain and could finish failed/timed-out work without a failing exit status. The source and active bundle now validate secure JSON/options, load a capable domain, require --wait for this process-local queue, wait for terminal outcomes, bound cancellation, and persist/read-back actual results. Twenty-eight focused tests and six real no-API CLI checks passed. Independent database reads after process exit confirmed completed and failed results. Other task types remain outside acceptance.

The combined 80-test suite passed through AQE's actual Node runner. Two actual ak sync --no-upgrade runs exited 0 with no failing subsystems; provider/security checks passed. The enabled-host catalog refresh succeeded, and active MCP memory writes were read back independently from the canonical project database (integrity check passed).

The dashboard still combines five different advisories: two excluded Brain conditions, partial historical Codex usage parsing, two preserved memory-store files despite the verified active route, and an external browser newer than the reviewed compatibility range. These must not be presented as five failed runtime checks, nor cleared by deleting history, downgrading external tools, or concealing evidence limits. The remaining browser compatibility is unverified. Brain was not changed during this pass. Local source patches remain subject to being overwritten by upgrades.

[stuinfla]

Proposed resolution and attached local patches (non-Brain scope)

Please keep this issue open until the relevant fixes are merged, published, and verified after upgrading an affected installation. A GitHub commit alone does not repair the installed npm packages. Kit self-update replaces its package files; dependency reinstall/upgrade can likewise replace AQE/Ruflo local corrections.

Closure criteria

• Kit dashboard distinguishes missing quota from authentication failure; embedding inspection accepts unrelated valid TOML and supported exact transports while preserving ambiguous/foreign configuration.
• Native diagnostics preserve the cause and distinguish unavailable/inconclusive from a demonstrated fallback. Unknown results remain failures; timeout handling is bounded.
• AQE source and shipped executable agree: required handlers are loaded, acceptance is separate from completion, invalid/failing/timeout work exits nonzero, cancellation is bounded, and completed/failed results survive process exit. Detached process-local submissions must not claim durable execution.
• Live RVF contention preserves owner/data/lock; genuine I/O failures still fail.
• Resolve the original shared status/repair predicate and ownership conflicts, including disabled-host context, custom MCP preservation, and foreign executable handling. Sync verifies promised postconditions rather than helper success alone.
• Provide a safe component exclusion for sync, and a release note identifying which Kit/AQE/Ruflo versions contain each correction. Do not classify preserved advisories as failed execution or suppress them to claim convergence.
• Test a clean installation AND an upgraded installation; test the packaged executable, real task completion, post-exit retrieval, and repeat-run convergence. Verify the new release against the affected machine before closing.

The local 80-test suite and real sync/provider/security/coverage checks pass, but they do not establish every task type, browser compatibility, or cross-platform behavior. These patches are review inputs, not an upstream release or a blanket acceptance claim. Please route dependency changes to the respective AQE/Ruflo owners. The earlier Ruflo path-propagation finding remains in the prior comment; the attachments below cover the later Kit/AQE corrections.

The workstation now has a verified recovery copy and a guarded checker. It detects replaced files and refuses blind replay over a newer release or unknown edits; it is not an automatic upgrade blocker. Brain remains outside this resolution pass.

agentic-kit-dashboard-and-inspector.patch

--- a/src/lib/aqe-embedding-toml.mjs
+++ b/src/lib/aqe-embedding-toml.mjs
@@ -30,6 +30,15 @@
   const match = new RegExp(`^${key}\\s*=\\s*("(?:[^"\\\\]|\\\\.)*")\\s*(?:#.*)?$`).exec(text);
   if (!match) throw new Error(`unsupported AQE ${key} encoding`);
   return parseEmbeddingJson(match[1]);
+}
+
+// Only root mcp_servers assignments can alias the managed server. Decode the
+// first segment so quoted/escaped aliases receive the same conservative guard.
+function assignmentRoot(text) {
+  const match = /^("(?:[^"\\]|\\.)*"|'[^']*'|[A-Za-z0-9_-]+)\s*(?:\.|=)/.exec(text);
+  if (!match) throw new Error('unsupported TOML assignment');
+  const raw = match[1];
+  return raw.startsWith('"') ? parseEmbeddingJson(raw) : raw.startsWith("'") ? raw.slice(1, -1) : raw;
 }
 
 function transportAssignment(text, transport, rest) {
@@ -71,6 +80,11 @@
     const text = line.text.trim();
     if (!text || text.startsWith('#')) continue;
     if (table === 'unrelated') continue;
+    if (table === '' || table === 'mcp_servers') {
+      const managedRoot = table === '' ? 'mcp_servers' : 'agentic-qe';
+      if (assignmentRoot(text) !== managedRoot) continue;
+      throw new Error('inline, dotted or quoted AQE registrations require manual embedding configuration');
+    }
     // Dotted/quoted keys can alias a managed table: refuse rather than guessing.
     if (!/^[A-Za-z0-9_-]+\s*=/.test(text)) throw new Error('dotted or quoted TOML assignments require manual embedding configuration');
     if (table === BASE) transportAssignment(text, transport, source.slice(line.start));
--- a/src/lib/dashboard/client/usage.mjs
+++ b/src/lib/dashboard/client/usage.mjs
@@ -1153,8 +1153,8 @@
       codexEl.innerHTML=html;
     }else{
       if(xn)xn.textContent="no data";
-      codexEl.innerHTML='<div class="empty">no Codex limit data &mdash; codex is not installed, not logged in, '
-        +"or app-server did not answer.</div>";
+      codexEl.innerHTML='<div class="empty">Codex quota unavailable &mdash; app-server did not return usable limit data. '
+        +"Check local host health; missing quota data does not establish a login failure.</div>";
     }
 
   }
--- a/src/lib/aqe-embedding-transport.mjs
+++ b/src/lib/aqe-embedding-transport.mjs
@@ -5,6 +5,9 @@
   if (typeof command !== 'string' || !Array.isArray(args)) return false;
   const binary = path.basename(command);
   if (['aqe-mcp', 'aqe-mcp.cmd'].includes(binary)) return args.length === 0;
+  if (['aqe', 'aqe.cmd', 'agentic-qe', 'agentic-qe.cmd'].includes(binary)) {
+    return JSON.stringify(args) === JSON.stringify(['mcp']);
+  }
   return ['npx', 'npx.cmd'].includes(binary)
     && JSON.stringify(args) === JSON.stringify(['-y', 'agentic-qe@latest', 'mcp']);
 }

agentic-kit-native-probe.patch

--- a/src/lib/natives.mjs
+++ b/src/lib/natives.mjs
@@ -135,18 +135,34 @@
 // running SELECT 1 in a child process is the real WASM-vs-native answer — not a
 // file-existence guess. Kept in a child process so a broken addon can't crash ak.
 const RUNTIME_PROBE =
-  "const D=require(require.resolve('better-sqlite3',{paths:[process.argv[1]]}));"
+  "try{const D=require(require.resolve('better-sqlite3',{paths:[process.argv[1]]}));"
   + "const db=new D(':memory:');const r=db.prepare('SELECT 1 AS ok').get();db.close();"
-  + 'process.exit(r&&r.ok===1?0:3);';
+  + "if(!r||r.ok!==1)throw new Error('Native SELECT 1 probe failed');}"
+  + "catch(e){console.error('AK_NATIVE_FAILURE:'+JSON.stringify({message:e.message}));process.exit(2);}";
 
 /** Load-test better-sqlite3 as resolved from `dir`. Injectable runner keeps the
  *  test spawn-free. Returns {ok} or {ok:false, reason}. */
 export async function probeBsq3Runtime(dir, { runner = run } = {}) {
-  // Generous timeout for a cold `node` spawn on CI; a real native require returns
-  // well under the status budget (probes run in parallel, see rufloRuntimeNatives).
-  const r = await runner('node', ['-e', RUNTIME_PROBE, dir], { cwd: dir, timeout: 8000 });
-  if (r.code === 0) return { ok: true };
-  return { ok: false, reason: (r.stderr || `exit ${r.code}`).trim().split('\n').pop().slice(0, 160) };
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    // Keep timeout evidence here: run() normalizes away the child error flags.
+    const signal = AbortSignal.timeout(8000);
+    let r;
+    try { r = await runner('node', ['-e', RUNTIME_PROBE, dir], { cwd: dir, timeout: 9000, signal }); }
+    catch (error) { r = { code: 1, stderr: error.message }; }
+    if (r.code === 0) return { ok: true, state: 'native', attempts: attempt };
+    const stderr = String(r.stderr ?? '');
+    const diagnostic = stderr.split('\n').find(line => line.startsWith('AK_NATIVE_FAILURE:'));
+    if (diagnostic) {
+      try {
+        const { message } = JSON.parse(diagnostic.slice('AK_NATIVE_FAILURE:'.length));
+        if (typeof message === 'string') return { ok: false, state: 'unavailable', attempts: attempt, reason: message.split('\n')[0].slice(0, 160) };
+      } catch { /* malformed output is inconclusive */ }
+    }
+    const timedOut = signal.aborted || /\b(?:ETIMEDOUT|timed out|timeout)\b/i.test(stderr);
+    if (timedOut && attempt === 1) continue;
+    return { ok: false, state: 'inconclusive', attempts: attempt,
+      reason: timedOut ? 'native probe timed out after two attempts' : (stderr.trim().split('\n')[0] || `probe exit ${r.code}`).slice(0, 160) };
+  }
 }
 
 /** Per-context native-binding truth for ruflo's memory runtime. {installed:false}
@@ -158,7 +174,7 @@
   if (!installed) return { installed: false, contexts: [] };
   const contexts = await Promise.all(rufloMemoryContexts().map(async ({ context, dir }) => {
     const res = await probeBsq3Runtime(dir, { runner });
-    return { context, dir, ok: res.ok, reason: res.reason };
+    return { context, dir, ...res };
   }));
   return { installed: true, contexts };
 }
--- a/src/commands/status/sections/natives.mjs
+++ b/src/commands/status/sections/natives.mjs
@@ -1,6 +1,15 @@
 // natives (better-sqlite3 in agentdb locations + aqe)
 import { nativesStatus, rufloRuntimeNatives } from '../../../lib/natives.mjs';
 import { row } from '../row.mjs';
+
+export function runtimeNativeRows(rt) {
+  if (!rt.installed || !rt.contexts.length) return [];
+  const failed = rt.contexts.filter(c => !c.ok);
+  if (!failed.length) return [row('natives', 'ok', `ruflo memory runtime native (${rt.contexts.map(c => c.context).join(', ')})`)];
+  return failed.map(c => row('natives', 'fail',
+    `ruflo native probe ${c.state === 'unavailable' ? 'failed' : 'inconclusive'} (@claude-flow/${c.context}): ${c.reason || 'no diagnostic available'}`,
+    c.state === 'unavailable' ? 'inspect the native binding load error before repair' : 'retry the native probe; runtime backend is unverified'));
+}
 
 export default {
   id: 'natives',
@@ -25,16 +34,7 @@
       // the binding as resolved from ruflo's own memory runtime (@claude-flow/memory
       // + /cli), or the row reads ✓ while memory store runs on the WASM fallback.
       const rt = await rufloRuntimeNatives();
-      if (rt.installed && rt.contexts.length) {
-        const wasm = rt.contexts.filter((c) => !c.ok);
-        if (wasm.length) {
-          rows.push(row('natives', 'fail',
-            `ruflo memory runtime on WASM fallback (${wasm.map((c) => `@claude-flow/${c.context}`).join(', ')}) — memory and orchestration may degrade`,
-            'sync builds the native binding'));
-        } else {
-          rows.push(row('natives', 'ok', `ruflo memory runtime native (${rt.contexts.map((c) => c.context).join(', ')})`));
-        }
-      }
+      rows.push(...runtimeNativeRows(rt));
     } catch (e) {
       rows.push(row('natives', 'warn', `native check unavailable: ${e.message}`));
     }

agentic-qe-fleet-completion.patch

--- a/dist/cli/commands/fleet.js
+++ b/dist/cli/commands/fleet.js
@@ -219,80 +219,13 @@
         .option('-t, --target <path>', 'Target path', '.')
         .option('--parallel <count>', 'Number of parallel agents', '4')
         .action(async (operation, options) => {
-        if (!await ensureInitialized())
-            return;
         try {
-            const parallelCount = parseInt(options.parallel, 10);
-            console.log(chalk.blue(`\n Fleet Operation: ${operation}\n`));
-            const progress = new FleetProgressManager({
-                title: `${operation.charAt(0).toUpperCase() + operation.slice(1)} Progress`,
-                showEta: true,
-            });
-            progress.start(parallelCount);
-            const domainMap = {
-                test: 'test-generation',
-                analyze: 'coverage-analysis',
-                scan: 'security-compliance',
-            };
-            const domain = domainMap[operation] || 'test-generation';
-            const agentOperations = Array.from({ length: parallelCount }, (_, i) => {
-                const agentId = `${operation}-agent-${i + 1}`;
-                return {
-                    id: agentId,
-                    name: `${operation}-worker-${i + 1}`,
-                    domain,
-                };
-            });
-            for (const op of agentOperations) {
-                progress.addAgent({
-                    id: op.id,
-                    name: op.name,
-                    status: 'pending',
-                    progress: 0,
-                });
-            }
-            const results = await Promise.all(agentOperations.map(async (op, index) => {
-                await new Promise(resolve => setTimeout(resolve, index * 200));
-                progress.updateAgent(op.id, 0, { status: 'running' });
-                try {
-                    for (let p = 10; p <= 90; p += 20) {
-                        await new Promise(resolve => setTimeout(resolve, secureRandomFloat(300, 500)));
-                        progress.updateAgent(op.id, p, {
-                            eta: Math.round((100 - p) * 50),
-                        });
-                    }
-                    const taskResult = await context.queen.submitTask({
-                        type: operation === 'test' ? 'generate-tests' :
-                            operation === 'analyze' ? 'analyze-coverage' :
-                                'scan-security',
-                        priority: 'p1',
-                        targetDomains: [domain],
-                        payload: { target: options.target, workerId: op.id },
-                        timeout: 60000,
-                    });
-                    progress.completeAgent(op.id, taskResult.success);
-                    return { id: op.id, success: taskResult.success };
-                }
-                catch {
-                    progress.completeAgent(op.id, false);
-                    return { id: op.id, success: false };
-                }
-            }));
-            progress.stop();
-            const successful = results.filter(r => r.success).length;
-            const failed = results.filter(r => !r.success).length;
-            console.log(chalk.blue('\n Operation Summary:'));
-            console.log(chalk.gray(`   Operation: ${operation}`));
-            console.log(chalk.gray(`   Target: ${options.target}`));
-            console.log(chalk.green(`   Successful: ${successful}`));
-            if (failed > 0) {
-                console.log(chalk.red(`   Failed: ${failed}`));
-            }
-            console.log('');
-            await cleanupAndExit(failed > 0 ? 1 : 0);
-        }
-        catch (error) {
-            console.error(chalk.red('\n Fleet operation failed:'), error);
+            const { validateFleetOptions, runFleetOperation } = await import('./fleet-local-run.js');
+            validateFleetOptions(operation, options);
+            if (!await ensureInitialized()) return;
+            await cleanupAndExit(await runFleetOperation(context, operation, options));
+        } catch (error) {
+            console.error('Fleet operation failed:', error.message ?? String(error));
             await cleanupAndExit(1);
         }
     });
--- /dev/null
+++ b/dist/cli/commands/fleet-local-run.js
@@ -0,0 +1,69 @@
+import { loadCoverageData } from '../../coordination/handlers/handler-utils.js';
+
+const operations = {
+  test: ['test-generation', 'generate-tests'],
+  analyze: ['coverage-analysis', 'analyze-coverage'],
+  scan: ['security-compliance', 'scan-security'],
+};
+
+export function validateFleetOptions(operation, options) {
+  if (!Object.hasOwn(operations, operation)) throw new Error('Operation must be test, analyze, or scan.');
+  if (!/^[1-9]\d*$/.test(String(options.parallel))) throw new Error('Parallel count must be an integer from 1 to 15.');
+  const count = Number(options.parallel);
+  if (!Number.isSafeInteger(count) || count > 15) throw new Error('Parallel count must be an integer from 1 to 15.');
+  return count;
+}
+
+export async function waitForTerminalTask(queen, id, timeoutMs = 60000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const task = queen.getTaskStatus(id);
+    if (task && ['completed', 'failed', 'cancelled'].includes(task.status)) return task;
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+  const current = queen.getTaskStatus(id);
+  if (current && ['completed', 'failed', 'cancelled'].includes(current.status)) return current;
+  const cancelled = await queen.cancelTask(id);
+  if (!cancelled.success) throw new Error(`Task ${id} timed out; cancellation failed: ${cancelled.error?.message ?? 'unknown error'}`);
+  return { ...queen.getTaskStatus(id), error: `Task ${id} timed out and was cancelled.` };
+}
+
+export async function runFleetOperation(context, operation, options) {
+  const count = validateFleetOptions(operation, options);
+  const [domain, type] = operations[operation];
+  let analysisPayload = {};
+  if (operation === 'analyze') {
+    const coverageData = await loadCoverageData(options.target);
+    if (!coverageData?.files?.length) throw new Error('Fleet analyze requires an existing instrumented coverage report. Generate coverage first.');
+    analysisPayload = { coverageData, includeFileDetails: true };
+  }
+  if (!await context.kernel.getDomainAPIAsync(domain)) throw new Error(`Domain ${domain} could not be loaded.`);
+  const plugin = context.kernel.plugins.getPlugin(domain);
+  if (!plugin?.canHandleTask(type)) throw new Error(`Domain ${domain} has no handler for ${type}.`);
+  context.queen.domainPlugins ??= new Map();
+  context.queen.domainPlugins.set(domain, plugin);
+  const results = await Promise.all(Array.from({ length: count }, async (_, index) => {
+    const accepted = await context.queen.submitTask({
+      type, priority: 'p1', targetDomains: [domain],
+      payload: { target: options.target, workerId: `${operation}-worker-${index + 1}`, ...analysisPayload },
+      timeout: 60000,
+    });
+    if (!accepted.success) throw accepted.error ?? new Error('Task submission failed.');
+    const taskId = accepted.value;
+    let execution;
+    try { execution = await waitForTerminalTask(context.queen, taskId); }
+    catch (error) { execution = { ...context.queen.getTaskStatus(taskId), error: error.message }; }
+    const success = execution?.status === 'completed' && execution.result !== undefined && !execution.error;
+    const result = { taskId, operation, target: options.target, success, execution, measuredAt: new Date().toISOString() };
+    await context.kernel.memory.set(`fleet-result:${taskId}`, result, { namespace: 'fleet-results', persist: true });
+    console.log(`Task ${taskId}: ${success ? 'completed' : 'failed'}; agents: ${execution?.assignedAgents?.join(', ') || 'none'}`);
+    if (!success) console.error(execution?.error || `Task ended in ${execution?.status ?? 'unknown'} state.`);
+    return result;
+  }).map(work => work.catch(error => {
+    console.error(error.message ?? String(error));
+    return { success: false, error: error.message ?? String(error) };
+  })));
+  const successful = results.filter(result => result.success).length;
+  console.log(`Operation: ${operation}\nTarget: ${options.target}\nSuccessful: ${successful}\nFailed: ${count - successful}`);
+  return successful === count ? 0 : 1;
+}

agentic-qe-live-lock.patch

--- a/dist/integrations/ruvector/shared-rvf-adapter.js
+++ b/dist/integrations/ruvector/shared-rvf-adapter.js
@@ -149,6 +149,9 @@
             if (fs.existsSync(lockPath) && isLockHeldByLiveProcess(rvfPath)) {
                 console.warn(`[RVF] ${rvfPath} is locked by a live process (pid ${readLockOwnerPid(rvfPath)}) — ` +
                     'not breaking the lock; degrading to SQLite for this run.');
+                // A live owner is expected contention, not a failed store.
+                // Do not attempt create/quarantine while that owner holds it.
+                return null;
             }
             else if (fs.existsSync(lockPath)) {
                 fs.unlinkSync(lockPath);
@@ -326,4 +329,4 @@
     }
     initAttempted = false;
 }
-//# sourceMappingURL=shared-rvf-adapter.js.map+//# sourceMappingURL=shared-rvf-adapter.js.map

agentic-qe-task-submit.patch

--- a/dist/cli/handlers/task-handler.js
+++ b/dist/cli/handlers/task-handler.js
@@ -1,3 +1,4 @@
+import { validateTaskOptions, executeLocalTask } from './task-submit-local.js';
 /**
  * Agentic QE v3 - Task Command Handler
  *
@@ -32,7 +33,7 @@
             .option('-d, --domain <domain>', 'Target domain')
             .option('-t, --timeout <ms>', 'Task timeout in ms', '300000')
             .option('--payload <json>', 'Task payload as JSON', '{}')
-            .option('--wait', 'Wait for task completion with progress')
+            .option('--wait', 'Required: wait for execution and persist its terminal result')
             .option('--no-progress', 'Disable progress indicator')
             .action(async (type, options) => {
             await this.executeSubmit(type, options, context);
@@ -67,77 +68,14 @@
         });
     }
     async executeSubmit(type, options, context) {
-        if (!await this.ensureInitialized())
-            return;
-        try {
-            const taskType = type;
-            const payload = parseJsonOption(options.payload, 'payload');
-            const targetDomains = options.domain ? [options.domain] : [];
-            console.log(chalk.blue(`\n  Submitting task: ${taskType}\n`));
-            // Use spinner for submit operation
-            const spinner = options.progress !== false
-                ? createTimedSpinner(`Submitting ${taskType} task`)
-                : null;
-            const result = await context.queen.submitTask({
-                type: taskType,
-                priority: options.priority,
-                targetDomains,
-                payload,
-                timeout: parseInt(options.timeout, 10),
-            });
-            if (spinner) {
-                if (result.success) {
-                    spinner.succeed(`Task submitted successfully`);
-                }
-                else {
-                    spinner.fail(`Failed to submit task`);
-                }
-            }
-            if (result.success) {
-                console.log(chalk.cyan(`   ID: ${result.value}`));
-                console.log(chalk.gray(`   Type: ${taskType}`));
-                console.log(chalk.gray(`   Priority: ${options.priority}`));
-                // If --wait flag is provided, poll for task completion with progress
-                if (options.wait) {
-                    console.log('');
-                    const taskId = result.value;
-                    const waitSpinner = createTimedSpinner('Waiting for task completion');
-                    const timeout = parseInt(options.timeout, 10);
-                    const startTime = Date.now();
-                    let completed = false;
-                    while (!completed && (Date.now() - startTime) < timeout) {
-                        const taskStatus = context.queen.getTaskStatus(taskId);
-                        if (taskStatus) {
-                            if (taskStatus.status === 'completed') {
-                                waitSpinner.succeed('Task completed successfully');
-                                completed = true;
-                            }
-                            else if (taskStatus.status === 'failed') {
-                                waitSpinner.fail(`Task failed: ${taskStatus.error || 'Unknown error'}`);
-                                completed = true;
-                            }
-                            else {
-                                // Update spinner with progress info
-                                waitSpinner.spinner.text = `Task ${taskStatus.status}... (${Math.round((Date.now() - startTime) / 1000)}s)`;
-                            }
-                        }
-                        if (!completed) {
-                            await new Promise(resolve => setTimeout(resolve, 500));
-                        }
-                    }
-                    if (!completed) {
-                        waitSpinner.fail('Task timed out');
-                    }
-                }
-            }
-            else {
-                console.log(chalk.red(`   Error: ${result.error.message}`));
-            }
-            console.log('');
-        }
-        catch (error) {
-            console.error(chalk.red('\n  Failed to submit task:'), error);
-            await this.cleanupAndExit(1);
+        try {
+            const request = validateTaskOptions(type, options);
+            if (!await this.ensureInitialized()) return await this.cleanupAndExit(1);
+            const result = await executeLocalTask(context, request);
+            return await this.cleanupAndExit(result.success ? 0 : 1);
+        } catch (error) {
+            console.error('Task submission failed:', error.message ?? String(error));
+            return await this.cleanupAndExit(1);
         }
     }
     async executeList(options, context) {
--- a/dist/cli/chunks/task-handler-L7E2I267.js
+++ b/dist/cli/chunks/task-handler-L7E2I267.js
@@ -1,8 +1,6 @@
+import { validateTaskOptions, executeLocalTask } from '../handlers/task-submit-local.js';
 import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.14.3");process.exit(0)}
-import{d as p,e as g}from"./chunk-5BLFXQEB.js";import{b as y}from"./chunk-STRDSVH3.js";import{a as m,b}from"./chunk-G5C2XVZC.js";import"./chunk-XXCYQXK3.js";import{c as T}from"./chunk-YAKS3CAB.js";import"./chunk-Y2DVFVGI.js";import a from"chalk";var f=class{name="task";description="Manage QE tasks";cleanupAndExit;ensureInitialized;constructor(o,e){this.cleanupAndExit=o,this.ensureInitialized=e}register(o,e){let s=o.command("task").description(this.description);s.command("submit <type>").description("Submit a task to the Queen Coordinator").option("-p, --priority <priority>","Task priority (p0|p1|p2|p3)","p1").option("-d, --domain <domain>","Target domain").option("-t, --timeout <ms>","Task timeout in ms","300000").option("--payload <json>","Task payload as JSON","{}").option("--wait","Wait for task completion with progress").option("--no-progress","Disable progress indicator").action(async(t,i)=>{await this.executeSubmit(t,i,e)}),s.command("list").description("List all tasks").option("-s, --status <status>","Filter by status").option("-p, --priority <priority>","Filter by priority").option("-d, --domain <domain>","Filter by domain").option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async t=>{await this.executeList(t,e)}),s.command("cancel <taskId>").description("Cancel a task").action(async t=>{await this.executeCancel(t,e)}),s.command("status <taskId>").description("Get task status").option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async(t,i)=>{await this.executeTaskStatus(t,i,e)})}async executeSubmit(o,e,s){if(await this.ensureInitialized())try{let t=o,i=T(e.payload,"payload"),r=e.domain?[e.domain]:[];console.log(a.blue(`
-  Submitting task: ${t}
-`));let d=e.progress!==!1?y(`Submitting ${t} task`):null,n=await s.queen.submitTask({type:t,priority:e.priority,targetDomains:r,payload:i,timeout:parseInt(e.timeout,10)});if(d&&(n.success?d.succeed("Task submitted successfully"):d.fail("Failed to submit task")),n.success){if(console.log(a.cyan(`   ID: ${n.value}`)),console.log(a.gray(`   Type: ${t}`)),console.log(a.gray(`   Priority: ${e.priority}`)),e.wait){console.log("");let w=n.value,c=y("Waiting for task completion"),h=parseInt(e.timeout,10),S=Date.now(),l=!1;for(;!l&&Date.now()-S<h;){let u=s.queen.getTaskStatus(w);u&&(u.status==="completed"?(c.succeed("Task completed successfully"),l=!0):u.status==="failed"?(c.fail(`Task failed: ${u.error||"Unknown error"}`),l=!0):c.spinner.text=`Task ${u.status}... (${Math.round((Date.now()-S)/1e3)}s)`),l||await new Promise(A=>setTimeout(A,500))}l||c.fail("Task timed out")}}else console.log(a.red(`   Error: ${n.error.message}`));console.log("")}catch(t){console.error(a.red(`
-  Failed to submit task:`),t),await this.cleanupAndExit(1)}}async executeList(o,e){if(await this.ensureInitialized())try{let s=e.queen.listTasks({status:o.status,priority:o.priority,domain:o.domain});if((o.format||"text")==="json"){let i=s.map(r=>({taskId:r.taskId,type:r.task.type,status:r.status,priority:r.task.priority,domain:r.assignedDomain||null,startedAt:r.startedAt?.toISOString()||null}));p(g(i),o.output);return}if(console.log(a.blue(`
+import{d as p,e as g}from"./chunk-5BLFXQEB.js";import{b as y}from"./chunk-STRDSVH3.js";import{a as m,b}from"./chunk-G5C2XVZC.js";import"./chunk-XXCYQXK3.js";import{c as T}from"./chunk-YAKS3CAB.js";import"./chunk-Y2DVFVGI.js";import a from"chalk";var f=class{name="task";description="Manage QE tasks";cleanupAndExit;ensureInitialized;constructor(o,e){this.cleanupAndExit=o,this.ensureInitialized=e}register(o,e){let s=o.command("task").description(this.description);s.command("submit <type>").description("Submit a task to the Queen Coordinator").option("-p, --priority <priority>","Task priority (p0|p1|p2|p3)","p1").option("-d, --domain <domain>","Target domain").option("-t, --timeout <ms>","Task timeout in ms","300000").option("--payload <json>","Task payload as JSON","{}").option("--wait","Required: wait for execution and persist its terminal result").option("--no-progress","Disable progress indicator").action(async(t,i)=>{await this.executeSubmit(t,i,e)}),s.command("list").description("List all tasks").option("-s, --status <status>","Filter by status").option("-p, --priority <priority>","Filter by priority").option("-d, --domain <domain>","Filter by domain").option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async t=>{await this.executeList(t,e)}),s.command("cancel <taskId>").description("Cancel a task").action(async t=>{await this.executeCancel(t,e)}),s.command("status <taskId>").description("Get task status").option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async(t,i)=>{await this.executeTaskStatus(t,i,e)})}async executeSubmit(type,options,context){try{const request=validateTaskOptions(type,options);if(!await this.ensureInitialized())return await this.cleanupAndExit(1);const result=await executeLocalTask(context,request);return await this.cleanupAndExit(result.success?0:1)}catch(error){console.error('Task submission failed:',error.message??String(error));return await this.cleanupAndExit(1)}}async executeList(o,e){if(await this.ensureInitialized())try{let s=e.queen.listTasks({status:o.status,priority:o.priority,domain:o.domain});if((o.format||"text")==="json"){let i=s.map(r=>({taskId:r.taskId,type:r.task.type,status:r.status,priority:r.task.priority,domain:r.assignedDomain||null,startedAt:r.startedAt?.toISOString()||null}));p(g(i),o.output);return}if(console.log(a.blue(`
   Tasks (${s.length})
 `)),s.length===0)console.log(a.gray("  No tasks found"));else for(let i of s)console.log(`  ${a.cyan(i.taskId)}`),console.log(`    Type: ${i.task.type}`),console.log(`    Status: ${m(i.status)}`),console.log(`    Priority: ${i.task.priority}`),i.assignedDomain&&console.log(`    Domain: ${i.assignedDomain}`),i.startedAt&&console.log(a.gray(`    Started: ${i.startedAt.toISOString()}`)),console.log("")}catch(s){console.error(a.red(`
   Failed to list tasks:`),s),await this.cleanupAndExit(1)}}async executeCancel(o,e){if(await this.ensureInitialized())try{let s=await e.queen.cancelTask(o);s.success?console.log(a.green(`
@@ -32,7 +30,7 @@
   -d, --domain <domain>       Target domain
   -t, --timeout <ms>          Task timeout in milliseconds (default: 300000)
   --payload <json>            Task payload as JSON
-  --wait                      Wait for task completion with progress
+  --wait                      Required: wait for execution and persist its terminal result
   --no-progress               Disable progress indicator
 
 List Options:
--- /dev/null
+++ b/dist/cli/handlers/task-submit-local.js
@@ -0,0 +1,88 @@
+import { TASK_DOMAIN_MAP } from '../../coordination/queen-types.js';
+import { loadCoverageData } from '../../coordination/handlers/handler-utils.js';
+import { parseJsonOption } from '../helpers/safe-json.js';
+
+export function validateTaskOptions(type, options) {
+  if (!options.wait) throw new Error('This CLI owns an in-process task queue. Use --wait; detached background execution is not supported.');
+  if (!Object.hasOwn(TASK_DOMAIN_MAP, type)) throw new Error(`Unknown task type: ${type}`);
+  if (!['p0', 'p1', 'p2', 'p3'].includes(options.priority)) throw new Error('Priority must be p0, p1, p2, or p3.');
+  if (!/^[1-9]\d*$/.test(String(options.timeout))) throw new Error('Timeout must be a positive integer in milliseconds.');
+  const timeout = Number(options.timeout);
+  if (!Number.isSafeInteger(timeout) || timeout > 2147483647) throw new Error('Timeout exceeds the supported timer range.');
+  const payload = parseJsonOption(options.payload, 'payload');
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) throw new Error('Payload must be a JSON object.');
+  const compatible = TASK_DOMAIN_MAP[type];
+  if (options.domain && !compatible.includes(options.domain)) throw new Error(`Domain ${options.domain} cannot handle ${type}.`);
+  const domains = options.domain ? [options.domain] : [...compatible];
+  if (!domains.length) throw new Error(`No direct domain execution mapping is available for ${type}.`);
+  return { type, priority: options.priority, timeout, payload, domains };
+}
+
+export async function waitForLocalTask(queen, taskId, timeout) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const task = queen.getTaskStatus(taskId);
+    if (task && ['completed', 'failed', 'cancelled'].includes(task.status)) return { execution: task, timedOut: false };
+    await new Promise(resolve => setTimeout(resolve, Math.min(50, Math.max(1, deadline - Date.now()))));
+  }
+  let cancellation;
+  let timer;
+  try {
+    const result = await Promise.race([
+      Promise.resolve().then(() => queen.cancelTask(taskId)),
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), 1000); }),
+    ]);
+    cancellation = result === null ? 'requested but unconfirmed within one second'
+      : result.success ? 'requested' : `failed: ${result.error?.message ?? 'unknown error'}`;
+  } catch (error) { cancellation = `failed: ${error.message}`; }
+  finally { clearTimeout(timer); }
+  return { execution: queen.getTaskStatus(taskId) ?? null, timedOut: true,
+    error: `Task wait deadline expired; cancellation ${cancellation}. Execution shutdown is not proven.` };
+}
+
+function nonempty(value) {
+  if (value === null || value === undefined) return false;
+  if (typeof value === 'string' || Array.isArray(value)) return value.length > 0;
+  return typeof value !== 'object' || Object.keys(value).length > 0;
+}
+
+export async function executeLocalTask(context, request) {
+  const payload = { ...request.payload };
+  if (request.type === 'analyze-coverage') {
+    if (!payload.coverageData && typeof payload.target === 'string' && payload.target.trim()) {
+      payload.coverageData = await loadCoverageData(payload.target);
+    }
+    if (!payload.coverageData?.files?.length) throw new Error('analyze-coverage requires coverageData or payload.target pointing to existing instrumented coverage.');
+  }
+  let domain, plugin;
+  for (const candidate of request.domains) {
+    if (!await context.kernel.getDomainAPIAsync(candidate)) continue;
+    const loaded = context.kernel.plugins.getPlugin(candidate);
+    if (typeof loaded?.executeTask === 'function' && loaded.canHandleTask?.(request.type)) {
+      domain = candidate; plugin = loaded; break;
+    }
+  }
+  if (!plugin) throw new Error(`No registered direct execution handler for ${request.type}.`);
+  context.queen.domainPlugins ??= new Map();
+  context.queen.domainPlugins.set(domain, plugin);
+  const accepted = await context.queen.submitTask({ type: request.type, priority: request.priority,
+    targetDomains: [domain], payload, timeout: request.timeout });
+  if (!accepted.success) throw accepted.error ?? new Error('Task submission rejected.');
+  const taskId = accepted.value;
+  if (typeof taskId !== 'string' || !taskId) throw new Error('Task submission returned no task identifier.');
+  console.log(`Task ${taskId}: accepted; waiting for execution.`);
+  const observed = await waitForLocalTask(context.queen, taskId, request.timeout);
+  // Freeze evidence against a late cancellation/completion callback.
+  const execution = observed.execution ? JSON.parse(JSON.stringify(observed.execution)) : null;
+  const success = !observed.timedOut && execution?.status === 'completed' && !execution.error && nonempty(execution.result);
+  const error = observed.error ?? execution?.error ?? (!success ? `Task ended ${execution?.status ?? 'unknown'} without a nonempty successful result.` : null);
+  const record = { taskId, type: request.type, domain, success, execution, timedOut: observed.timedOut,
+    error, measuredAt: new Date().toISOString() };
+  const key = `task-result:${taskId}`;
+  await context.kernel.memory.set(key, record, { namespace: 'task-results', persist: true });
+  const stored = await context.kernel.memory.get(key, { namespace: 'task-results' });
+  if (!stored || JSON.stringify(stored) !== JSON.stringify(record)) throw new Error(`Task ${taskId} finished but durable result read-back failed.`);
+  console.log(`Task ${taskId}: ${success ? 'completed' : 'failed'}; result recorded as task-results/${key}`);
+  if (error) console.error(error);
+  return record;
+}

[pacphi]

Closed by #241 (merged 2026-09-27 as 476717b). Thank you for the detailed report and the patches.

Every claim here was verified against 847486c, and each has a verdict in the verification and decisions record. The record also covers the maintainer decisions (including how the five attached patches were handled), what #241 implemented, and which items went upstream to Ruflo, Agentic QE, AgentDB, RuVector and the RuvNet Brain, with links. Related work that remains is planned in the remediation program.