Repository navigation
feat(acp): onboard MiMo Code as an enforced ACP backend - #24732
Conversation
Design Review (Opus 5.5, fork) — ✅ PASSDesign-level review of Design-Verdict: PASS Nothing blocks: the new harness is a separate, opt-in backend id with the same enforcement as OpenCode, and the shared paths it changes only run when Notes
[DESIGN-REVIEWED] cea97be Description read[DESCRIPTION-READ] e30512309278e450fb51025a1c5b80f55f4c60f7ae88eae63e384809a3c52b1f That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
First Principles Review (Opus 5.5, fork) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Nothing blocks. Two small surfaces have no consumer of their own; both are notes. Notes
What this change shipsInventory (10 items) — 8 justifiedIntent: let a user pick MiMo Code as their agent harness and run Crew sessions on it with Crew's tool gate enforced. ADDITION.
[FIRST-PRINCIPLES-REVIEWED] cea97be Description read[DESCRIPTION-READ] e08730ff9348e444fdc8a0af162049c44df21105edeeca6c7a85d3abff6322e0 That sha256 names the PR description this verdict read. Recompute it with |
Opus 5.5 Review (fork) — ✅ no blocking findingsReviewed |
GPT 6.1 Review (fork) — ✅ no blocking findingsReviewed Review detailsNo findings. |
8fc50df to
063953c
Compare
|
063953c to
072afbe
Compare
UX Review (Opus 5.5, fork) — ✅ PASSUX-level review of UX-Verdict: PASS Nothing blocks. The six committed screenshots show every control this PR adds or changes, but no first-time reader has seen them because a fork gets no blind read. A maintainer can push the branch here to get one. Notes
[UX-REVIEWED] cea97be Description read[DESCRIPTION-READ] ba60266e77469d2a3c931ca6bb6c05041ecb5798f551a86b03fb9363f91e4ef4 That sha256 names everything this verdict read: the PR description, plus the 9 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
072afbe to
bcade7f
Compare
|
bcade7f to
7389cfb
Compare
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Requesting changes on a52bdb5. This replaces my approval of 44a3453, which carries the same patch. The GPT 6.1 lane found something on this head that I missed, and after reading the source I agree with it.
The finding holds. A write that MiMo Code makes inside its memory tree never reaches Kiro Crew's gate, so an operator ceiling on filesystem.write is not applied to it.
- The memory tree is
$XDG_DATA_HOME/mimocode/memory, or~/.local/share/mimocode/memory(acp/harness/mimocode.py:161). It sits outside the session's working directory. - MiMo Code's edit tools write there without asking. The launch records the tree (
mimocode.py:1069), and the unasked-call check then treats such a write as expected:_unasked_call_is_expectedreturns true when every target is inside it (acp/client_permissions.py:1346). - Crew applies
filesystem.writewhen a permission request arrives. A write that is never asked about has no request, so no rule is read for it. - The only launch refusal is for the
mcpscope (_mimocode_governed_mcp_issue,mimocode.py:790). Nothing refuses a session whenfilesystem.writeis constrained.
So under a ceiling such as "writes only inside the workspace", the model can still create and change files under the memory tree, and those files are read back into later sessions. The check that runs afterwards cannot undo the write, and it does not flag it either.
How wide it is. It needs an operator who constrains filesystem.write. With the default open ceiling nothing changes. The reach is one directory: the path is resolved before the comparison, and test_a_memory_path_that_resolves_outside_the_tree_trips covers a link that points out of it. That limits the harm. It does not make the ceiling hold.
This is the same class the PR already solved for mcp. There the gate cannot see a call's identity, so the session is refused at launch and re-checked live. The memory tree is the second place where this harness acts without the gate seeing it, and it needs the same treatment.
What I am asking for.
- At launch, ask the governance evaluator whether a
filesystem.writeto the memory tree would be allowed outright under the installed ceiling and the configured profiles. If the answer is anything but allow, or cannot be resolved, refuse the session with a remedy, the way_mimocode_governed_mcp_issuedoes. - Ask again live, on the same two paths the
mcpre-check uses, because a ceiling can be installed after the start. - Tests: an allow-mode
filesystem.writeceiling that does not cover the memory tree refuses the launch; one that covers it does not; a ceiling installed mid-session stops the session; an unresolved store refuses. - Use the evaluator's own path matcher for this. Please do not add a pattern of your own for it.
If MiMo Code has a setting that makes memory edits ask, seeding that instead would be simpler and I would take it, with a read-back that proves it is in force.
Not verified by me. I read the source and did not run MiMo Code. I did not test whether the OS sandbox lets the child write to that directory; if it does not, memory would not work at all, so I assume it does.
Everything else in my earlier review stands, including the actor script check.
|
@buluoray Thanks, agreed: the memory-tree exception let a write past a The setting. What changed.
Cost. MiMo Code's own memory files are not written in a Crew session, and its checkpoint rebuild falls back to compaction (the harness says so in the chat). Reading existing memory still works, and Crew keeps its own memory as before. Not driven live: the hosted model returns empty turns from this host, so the evidence is the read-back above and the bundle's code path. |
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Approving on e0bc07a. This supersedes my change request on a52bdb5: the memory-tree gap is closed, and closed the simpler way.
What I checked against the source on this head.
- The seed.
_mimocode_routing_configsetsmemory.disable_writetoTrueand keeps any othermemorykeys the operator has (acp/harness/mimocode.py:627). An ambientfalseis overridden. - The read-back.
_verify_mimocode_routingrefuses the session unless the resolved config carriesmemory.disable_writeas exactlyTrue(mimocode.py:762). A missing key,false, and the string"true"all refuse. It reads the config MiMo Code itself resolved, so a later source that turns writing back on is caught. - The exception is gone.
_unasked_call_is_expectedno longer passes a file write._unasked_write_outside_memory,_any_outside,_mimocode_memory_rootand the client field are removed, and nothing insrc/refers to them. An unasked write that completes now stops the session wherever it lands. - No new pattern matching. The change adds no regex. The four in the PR are the same four as before.
Because the harness no longer writes there at all, the answer is the same under every ceiling. So the filesystem.write evaluation and the live re-check I asked for are not needed, and I agree with leaving them out.
Tests on this head. The test files this PR touches: 2092 passed, 1 failed. The one failure is test_harness_parity.py::test_is_kiro_cli_is_positive, which fails the same way on plain main on the machine I used.
What changed since a52bdb5. The branch was rebased onto main at 9cc553f. Fourteen files differ from the patch I last read, all for this fix: the two source files above, four more source files that carried the removed field or its wording, three specs, one user doc, and four test files.
The cost, stated so nobody is surprised later. MiMo Code's own memory files are not written in a Kiro Crew session, and its checkpoint rebuild falls back to compaction. Reading existing memory still works. Kiro Crew's own memory is unaffected.
Not verified by me.
- I did not run MiMo Code. That
memory.disable_writemakes every edit tool refuse a path under the memory tree is the author's reading of 0.1.15, which I could not check. The unasked-call check is the second line behind it: if a later release ignored the setting, the first such write would stop the session. - CI on this head had only started when I posted this.
Not blocking, for later: #35740 proposes moving per-harness state and branches onto the adapters, and this harness would move with OpenCode there.
|
@buluoray Thanks for the approval at
Could you take another look? Sorry for the extra round. |
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Approving on 3fa8023. The push reset my approval of e0bc07a, so this is a read of what moved.
What moved. The branch was rebased onto main at df73916, after #31950 added a codex tool table. I compared the patch file by file against the one I approved. Three files differ and the rest are identical:
src/kiro_crew/acp/harness_tool_names.py:HARNESS_TOOL_MATCH_VOCABULARYnow keeps codex beside claude.test/test_spec_hook_kas_tool_names.py: the same two facts pinned.docs/system-specs/modules/agent-host-contract.md: the conflict in two table rows.
The one change beyond conflict resolution is right. This PR narrows the vocabulary so MiMo Code's ids are left out, because its spec hooks are withheld. Main's new codex table would have been dropped by that filter. I built the set on both sides:
- On this head: 35 ids. The ids left out are exactly
actor,notebook_editandview_image. - On main (df73916): 35 ids, and the two sets are equal.
So every id that quiets the "names no tool" warning on main still does, codex's included, and only MiMo Code's own three still warn.
Tests on this head. The test files this PR touches, plus test_harness_tool_names.py: 2135 passed, 1 failed. The one failure is test_harness_parity.py::test_is_kiro_cli_is_positive, which fails the same way on plain main on the machine I used.
Everything in my review of e0bc07a stands, including what I could not verify there: I did not run MiMo Code itself.
CI on this head had only started when I posted this.
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Requesting changes on 3fa8023 for one sentence. This replaces the approval I posted on this head earlier today. The Opus 5.5 lane found it, I checked it against the source, and it is right. I missed it.
A shipped user doc says a control runs that does not run.
src/kiro_crew/docs/agent-spec-fields.md:212 says:
mimocode is mirrored and enforced like opencode, and the refusal does run on its sessions, but some of MiMo Code's own tools (memory, history, task) never send a permission request, so they stay callable under tools: []
The code does the opposite:
ACP_BACKENDS_HONOR_ZERO_TOOL_BAN(agent_sdk/backends_mcp.py:428) subtractsACP_BACKENDS_UNASKED_NATIVE_TOOLS, and MiMo Code is that set's one member (:337).- So
AcpClient._enforces_zero_tool_ban(acp/client_class.py:910) is false on a MiMo Code session, and_deny_zero_toolsreturns before it refuses anything. - The spec says so correctly:
agent-host-contract.md:781reads "gap: the refusal does not run (honors_zero_tool_banis False)".
An operator who reads the user doc will believe that "tools": [] on MiMo Code leaves only memory, history and task callable. In fact a bash, write or edit request is answered like any other request, and approved under auto-approve. The two docs in this PR disagree, and the one that ships to users is the wrong one.
What I am asking for. One of:
- Change the sentence to say the refusal does not run on MiMo Code and that an agent spec relying on
tools: []there is not enforced, in the same words the codex paragraph above it uses. This is the smaller change and it matches the code. - Or keep
_deny_zero_toolsrunning on MiMo Code for the calls that do ask, and say in both docs thatmemory,historyandtaskstill run. That is the stronger behaviour, but it changes what membership inACP_BACKENDS_HONOR_ZERO_TOOL_BANmeans, so I would not ask for it in this PR.
I will re-approve as soon as either lands.
Lanes on this head. Design, UX and First Principles pass. Opus 5.5 blocks on the point above. GPT 6.1 reports "review incomplete", which is the lane not finishing and carries no finding.
Everything else in my review of this head stands, including the vocabulary check.
|
Opus 5.5 Review on
@buluoray This push changes only that paragraph of |
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Approving on d650c94. This supersedes my change request on 3fa8023: the sentence I asked about now says what the code does.
The fix. src/kiro_crew/docs/agent-spec-fields.md:212 now says the tools: [] refusal does not run on MiMo Code sessions, that a call which asks is judged like any other, and that an agent spec relying on tools: [] there is not enforced. That matches ACP_BACKENDS_HONOR_ZERO_TOOL_BAN, AcpClient._enforces_zero_tool_ban, and the row in agent-host-contract.md. The two docs agree now.
I agree with leaving the code as it is. Refusing only the calls that ask would still let memory, history and task run, so it could not make a zero-tool spec hold, and a partial ban described as a ban is worse than a stated gap.
What moved since 3fa8023. The branch was rebased onto main at 6e9c7c8. I compared the patch file by file against the one I read on the last head. One file differs, agent-spec-fields.md, and only in that paragraph. Every other file's patch is identical.
Tests. I did not re-run the suite for a one-paragraph doc change. My run on 3fa8023 stands for the code: 2135 passed, with one failure that also fails on plain main on the machine I used. This head sits on a newer main, and I did not run the tests on that base myself; CI on this head covers it and had only started when I posted this.
Everything else in my earlier reviews stands, including what I could not verify: I did not run MiMo Code itself.
|
@buluoray Thanks for the approval at The rebase pushed the diff a few bytes past the 1 MB review cap, so I shortened some MiMo Code prose that restates other docs in this PR. These are three host-contract cells and the worked example's residual row and closing paragraph in On |
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Approving on cea97be. The push reset my approval of d650c94, so this is a read of what moved.
What moved. The branch was rebased onto main at cec6f7a. I compared the patch file by file against the one I approved. Two files differ, both docs, and every other file's patch is identical. There is no code or test change.
docs/system-specs/modules/agent-host-contract.md: main's new text for the Codex session-store cells and the KAS hooks cell is taken as it is, and three MiMo Code cells are shortened.docs/system-specs/modules/harness-onboarding.md: the worked example's residual row and its closing paragraph are shortened.
The facts I care about are still there. The host contract still says the tools: [] refusal does not run on MiMo Code, and both docs still name memory.disable_write and why it is seeded.
Tests. No code moved, so I did not re-run the suite. My run on 3fa8023 stands for the code: 2135 passed, with one failure that also fails on plain main on the machine I used. I did not run the tests on this newer base myself; CI on this head covers it and had only started when I posted this.
Lanes. GPT 6.1 reported "review incomplete" on the last two heads, which is the lane not finishing. Its last finished read was on e0bc07a, with no findings. It runs again on this push.
Everything else in my earlier reviews stands, including what I could not verify: I did not run MiMo Code itself.
MiMo Code (npm @mimo-ai/cli, `mimo acp`) is a fork of OpenCode with its own config variable, tools and loopback listener, so pointing the opencode backend at it never delivers Crew's permission seed. Add it as its own backend, `mimocode`, selectable and enforced through VERIFIED_SEEDED_SETTINGS. The launch (acp/harness/mimocode.py) and mirror (providers/mirrors/mimocode.py) import nothing from the opencode modules. The launch seeds `permission: "ask"` through MIMOCODE_CONFIG_CONTENT, reads it back from `mimo debug config`, gates the 0.1 line, refuses MIMOCODE_HOME, strips the switches the read-back cannot see and pins cron, the experimental toolsets and codex mode off. Where the fork differs from OpenCode on the wire, the difference lives in a per-backend table: its tool ids (`use_subagent` is `actor`) and argument spellings (`notebook_path`, `patch_text`), so the shared readers are unchanged. A tripwire stops the harness when a call completes unasked, other than the few tools the harness never asks for and writes inside its memory tree, or when a call completes before Crew answered its ask: what the listener's unauthenticated skip-all and reply routes produce. `always` is sent as `once` so no stored grant hides an asked call. Some native tools (memory, history, task) never ask, so the backend sits outside the zero-tool honor set. agent.env refuses MIMOCODE_*, and the fork's credential, global config and project config are on the write-only tier. Seven live captures off 0.1.15 cover all seven frame classes. Part of kirodotdev#24711
|
@buluoray Thanks for the approval at
Could you take another look? Sorry for the repeated rounds; main is moving fast today. |
buluoray
left a comment
There was a problem hiding this comment.
🤖 Kiro Crew Auto-Pipeline [operator: buluoray]:
Approving on 32bf88a. The push reset my approval of cea97be, so this is a read of what moved.
What moved. The branch was rebased onto main at 0fc3b49. I compared the patch file by file against the one I approved. Nine files differ, and every other file's patch is identical.
- One code change, required by main. #35838 added a pin that every known harness is counted from usage rows or from a transcript. MiMo Code joins
_SHARD_COUNTED_HARNESSESinsrc/kiro_crew/dashboard/handlers/usage_store.py, beside OpenCode, with the matching name in the type-checking list inusage.pyand inlearn-cron-dashboard.md. That is the right set for a harness with no transcript the Session Activity parse reads. src/kiro_crew/acp/harness/mimocode.py: comments only. I compared the added lines that are not comments on both heads, and they are the same.- Docs. The host-contract table takes main's new codex text from #35508, with the MiMo Code cells unchanged, and its Format cell now names
memory.disable_write. The MiMo Code paragraph inagent-spec-fields.mdis the same as on the last head. The rest is MiMo Code prose shortened inacp-client.md,agent-host-contract.md,harness-onboarding.md, the fixture README, and one comment block intest_acp_mimocode_turn.py.
Tests on this head. The test files this PR touches, plus test_usage_harness_sessions.py and test_harness_tool_names.py: 2150 passed, 1 failed. The one failure is test_harness_parity.py::test_is_kiro_cli_is_positive, which fails the same way on plain main on the machine I used.
Everything else in my earlier reviews stands, including what I could not verify: I did not run MiMo Code itself.
CI on this head had only started when I posted this.
Problem / Motivation
Goal: A user can pick MiMo Code under Settings → Agent Harness and run Kiro Crew sessions on it with Crew's tool gate enforced.
MiMo Code (npm
@mimo-ai/cli,mimo acp) is a fork of OpenCode. Kiro Crew cannot select it today, and pointingOPENCODE_BINatmimodoes not work: the fork readsMIMOCODE_CONFIG_CONTENT, notOPENCODE_CONFIG_CONTENT, so Crew'spermission: "ask"seed never arrives and the session runs on the harness's own approval settings. The fork also differs from OpenCode on the wire in ways the gate depends on: its own tool names, native tools that never ask, and a loopback listener that can switch approvals off.Why it matters
MiMo Code is the harness for Xiaomi's MiMo models and provider. Without a backend of its own, a user who wants it either cannot use Crew or runs it behind a re-pointed id with no enforcement at all, which is worse than not offering it.
Not a goal
session/promptwith an emptyend_turn).memory,historyandtasknever ask and have no switch, so the backend is excluded instead.POST /permission/skip-all,POST /permission/:id/reply): that needs an upstream change; this PR detects their effect.actorsubagents: they fail closed under Crew, because they inherit only stored grants and Crew stores none; one whose never-asking call spans a turn boundary can stop the session (the tool name is cleared at each turn start).exec/wait): pinned off, not supported.allow_onceto an OpenCode-family harness (shared code; no production caller reaches it on either backend).What changed (motivation → approach → change)
MiMo Code becomes its own backend,
mimocode, enforced like OpenCode (VERIFIED_SEEDED_SETTINGS): Crew seedspermission: "ask", reads it back before the first prompt, and refuses the session when it does not hold. Re-pointing theopencodeid was rejected (the seed variable differs, and a shipped id is not re-pointed), and so was subclassing the opencode modules, because the two harnesses already diverge on tools, listener routes and config names; the new modules import nothing from them. Every MiMo Code helper that reads like an opencode one is therefore a deliberate copy, not only in the launch and the mirror but in the two shared modules too:client_turn.py's shell-permission reorder (_defer_mimocode_shell_permission, keyed on the two ask titles that carry no command, which opencode's is not) andharness_tool_names.py's name helpers (mimocode_rewrites_name,_mimocode_mcp_splits,mimocode_spelling, which write a character outside the BMP as__the way the harness's UTF-16replacedoes;_opencode_mcp_splitswrites one_). Each is written to MiMo Code 0.1.15's measured frames, so a later change to opencode's code cannot change what MiMo Code enforces, andtest/test_acp_mimocode_backend.pypins that neither module imports the other's.acp/harness/mimocode.pymimo debug config), judged by MiMo Code's own rule algebra (permission/evaluate.ts,index.tsdisabled()): the last matching rule wins, a tool is hidden by its own id or by its edit/read group, and agent rules follow the top level, so an agent printed aspermission: {}inherits; the 0.1 line version gate,MIMOCODE_HOMErefused before any child runs, cron / experimental toolsets / codex mode pinned off, the switches the read-back cannot see stripped; a server switched off in Crew that the harness mounts from its own config refuses the sessionproviders/mirrors/mimocode.py"deny"where MiMo Code's schema takes only a string); the array merged by name, the later entry winning, as the harness does; only ids that collide with its edit/read groups (apply_patch,view_image) withhold a server whole; spec hooks withheldacp/harness_tool_names.pyuse_subagentisactor;notebook_pathandpatch_textread asfile_pathandpatchText, applied inpermission_requests.pyto mimocode events only; an MCP call is handled as the opencode backend already handles it: no(server, tool)pair is read off its fused<server>_<tool>title, the gate judges the title, and_mimocode_mcp_splits(MiMo Code's copy of_opencode_mcp_splits, in its UTF-16 spelling) gives the hooks that match a harness id the title's@server/toolsplitsacp/client_permissions.pyHARNESS_UNASKED_TOOL_IDS, withactorpassing only when its input starts no subagent,mimocode_actor_asks_nothing, and writes inside its memory tree), or completes before Crew answered its ask;alwaysis sent asonceacp/client_turn.pybashandexternal_directory: MiMo Code sendsrawInput: {}and the command only on the following update,tool/bash.ts);bash_deletecarries its command and is not heldagent_sdk/ACP_BACKENDS_UNASKED_NATIVE_TOOLS(keeps it out of the zero-tool honor set) andACP_BACKENDS_MODEL_SELECT_UNCHECKED(the harness accepts any model value, so Crew checks it);acp/client_model_selection.pydrops<provider>/from MiMo Code's<provider>/<model> (<variant>)labels, which the picker cut off before the variant (mimocode_model_rows; kept whole if two rows would read alike, ids unchanged)agent.envrefusesMIMOCODE_*(config/sections_agent_env.py); the token, global config and project config are fenced (agent_sdk/host_auth.py,agent_sdk/native_allow_stores.py, the aws-control builder's standalone list,src/kiro_crew/apps/builtins/aws_control/crew/packaging/pipeline/sensitive.py)test/fixtures/acp_frames/mimocode, all seven frame classesMCP governance follows the opencode precedent on purpose. On main the opencode backend names no server or tool for an MCP call (its mirror's
DENIED_TOOLSruling: "the harness sends only a fused<server>_<tool>title";hook_runtime/gate_tiers.pylists opencode among the harnesses that name no server), so governance'smcpscope is not asked for such a call and a rule written for a real tool name (@ops/repo.delete) does not meet the rewritten titleops_repo_delete; the spec's per-tool denies reach the harness through its own config instead. MiMo Code sends the same title, so this backend takes the same position and the same residual, stated inacp-client.mdand in the onboarding residual row. Where that would leave a governance control unapplied, the session is refused instead: when the installed ceiling or any configured profile constrainsmcpat all (mcp_scope_governed_nowinplatform/governance.py, its profile halfany_configured_profile_constrainsinplatform/governance_profiles.py, both fail-closed), a MiMo Code session that would mount any server -- Crew's array or the harness's own config -- is refused after the read-back with a remedy naming the servers; a session with nothing to mount starts, and a host with nomcpcontrol is unchanged. Closing the gap itself would be one change for both backends.The registrations follow the existing seams:
acp_backends.py,acp/types.py,acp/harness/__init__.py,providers/acp.py,providers/mirrors/registry.py, the parity gate's expected agent name and its classification of the two new sets inscripts/check_harness_parity.py, the dashboard's harness name (website/src/api/acpBackend.ts, oneagentBackendTab.mimocodekey per catalog inwebsite/src/i18n/locales, as Strands has, andMiMo Codeon the do-not-translate list inwebsite/src/i18n/glossary.json, which the i18n gate asks for a name every locale keeps as written), and the owning docs underdocs/andsrc/kiro_crew/docs(host contract, onboarding worked example, acp-client, security, governance, harness parity, model selection, configuration, agent spec fields). Session Activity counts its sessions from usage rows (dashboard/handlers/usage_store.py,usage.py).Backwards compatibility
Compatible: every behaviour change is scoped to the new
mimocodeid, and the shared readers it feeds keep their results on every other backend (the shared tool vocabulary is unchanged, and the related suites pass).Reader: src/kiro_crew/acp/harness/mimocode.py:MimoCodeLaunch.resolve_spawn -- chat -- the new
extra_hidden_dirsmasks apply only to MiMo Code's own children (version probe, read-back, session); test_acp_mimocode_backend.py::test_the_read_back_and_the_version_probe_run_wrapped_and_off_the_loopReader: src/kiro_crew/config/sections_agent_env.py:agent_env_refusal -- chat --
MIMOCODE_*names no variable any backend read before this one, so no workingagent.envloses an effect; test_acp_mimocode_backend.py::test_agent_env_drops_a_mimocode_nameReader: src/kiro_crew/security/paths.py:sensitive_write_path_refusal -- subagent -- refuses only the agent's file-edit tools on files only MiMo Code reads (
~/.config/mimocode/*, a project'smimocode.json,.mimocode/); reads and gateway writers are unchanged; test_native_allow_stores.py::test_every_store_is_refused_for_file_edits_and_stays_readableReader: src/kiro_crew/security/paths.py:is_sensitive_path -- cron -- the one new read refusal is MiMo Code's OAuth token
~/.local/share/mimocode/auth.json, the same class as OpenCode's; test_acp_mimocode_backend.py::test_the_token_leaf_is_fenced_at_home_and_under_its_overrideTests
test/test_acp_mimocode_backend.pytest/test_acp_mimocode_launch.py@ops/repo.deleterefuses a session that would mount a server; a profile-only rule counts; no server, or nomcpcontrol, starts)test/test_acp_mimocode_config.pytest/test_acp_mimocode_turn.py_dispatch_events,always→once; the captured MCP call names no server, as on opencode (both backends run through one test), its title splits back for the hooks (a dotted server name and an astral one), and a rule on the fused title denies itShared enumerating tests gain their
mimocoderow;test_native_allow_stores.pyexempts it from the single-variable override check for the same reason as opencode (config underXDG_CONFIG_HOME, token underXDG_DATA_HOME).Determinism: the three new files of that revision and
test/test_native_allow_stores.py(401 tests) passed 20 consecutive-n0runs; all 18 changed test files (1659 tests) passed 5 runs under-n 4 --dist loadgroupand one run in a shuffled order (seed 24711,-n0); after the MCP handling moved to the opencode precedent, the three new files andtest/test_native_allow_stores.py(455 tests) passed 5 more consecutive-n0runs.Manual verification
Driven live on
mimo acp0.1.15 with thexiaomi/mimo-v2.6-flash/lowmodel through the worktree'sAcpClient:notebook_editrefused before the argument alias, allowed after it (the cell changed).actorsubagent: both asks reach Crew; a background one fails closed.POST /permission/:id/replyanswer and askip-alledit each stopped the harness; a write in the memory tree did not.cron,workflow,sessionorexec.mimocode.jsongivingagent.buildonly amodel(printed back aspermission: {}) starts a session; a{"*": "deny"}under a string-only key such asdoom_loopmakes MiMo Code reject the whole config, which is why the seed writes a bare"deny".xiaomi/mimo-v2.6-flash/low, a session run with a shell call approved from its card.Screenshots / video
Committed under
temp-screenshots/24732-mimocode-harness/(fork PR:--attachis unavailable to me; the maintainer drops the directory after merge). Settings → Agent Harness, light theme, 1440×1000, taken from a pod running this head.The list with the new row (
MiMo Code, between goose and OpenCode, status badge from the probe):The row opened, MiMo Code installed: Experimental badge, the "Use MiMo Code" button, the sign-in note, the 4-of-7 capability list and the agent-config notes:
The row opened, MiMo Code not installed: the install command, "Check again", and the disabled Use button:
The chat failure states, same theme and size, each from a real session in a pod running this branch:
A session refused because the host's security policy carries an
mcprule while the chat mounts MCP servers (the governance refusal,_mimocode_governed_mcp_issue):The harness stopped mid-session by the unasked-call tripwire, after a
POST /permission/skip-allto its own loopback listener made it run a shell command without asking:A chat with an invalid MiMo credential (
auth.jsonremoved before the process started and for the whole turn). MiMo Code 0.1.15 writesInvalid API Keyonly to its own log file and ends the turnend_turnwith no content and no error frame, so the dashboard shows its empty-turn notice. A chat therefore never reachessigned_out_messageon this harness today (the sign-in note on the detail card issign_in_remedy); naming a sign-in failure in chat needs a signal the harness does not send, left for a follow-up:Related Issues
Closes #24711
Checklist
feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)