blomios/IdeA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad1f2257e65727f2fccce7d5a5c4cc64fc37c73d
IdeA/crates/application/tests/agent_lifecycle.rs
Blomios 7ddf4d46b9 chore(fmt): appliquer rustfmt sur agent_lifecycle.rs 
Reformate `launch_opencode_omits_api_key_when_profile_has_none` selon
rustfmt (le fichier committé échouait `cargo fmt --check`). Aucun
changement de comportement, purement du formatage.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-13 17:59:26 +02:00

3633 lines
128 KiB
Rust
Raw Blame History

//! L6 tests for the agent lifecycle use cases (`CreateAgentFromScratch`,
//! `ListAgents`, `ReadAgentContext`, `UpdateAgentContext`, `DeleteAgent`,
//! `LaunchAgent`).
//!
//! Every port is faked in-memory so the use cases run without real I/O:
//! - [`FakeContexts`] — an [`AgentContextStore`] holding the manifest + a
//! `md_path → content` map,
//! - [`FakeProfiles`] — a [`ProfileStore`] returning a fixed profile list,
//! - [`FakeRuntime`] — an [`AgentRuntime`] whose `prepare_invocation` records the
//! call into a shared **trace** and returns a configurable injection plan,
//! - [`FakeFs`] — a [`FileSystem`] recording writes into the same trace,
//! - [`FakePty`] — a [`PtyPort`] recording `spawn` into the trace,
//! - [`SpyBus`], [`SeqIds`] — event recorder and deterministic id generator.
//!
//! The shared trace lets us assert the **call ordering** contract of
//! `LaunchAgent`: `prepare_invocation` → injection (fs write) → `pty.spawn`.
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use domain::agent::{Agent, AgentManifest, AgentOrigin, ManifestEntry};
use domain::events::DomainEvent;
use domain::ids::{AgentId, ProfileId, ProjectId};
use domain::markdown::MarkdownDoc;
use domain::permission::{
EffectivePermissions, PermissionProjection, PermissionProjector, Posture, ProjectedFile,
ProjectionContext, ProjectorKey,
};
use domain::ports::{
AgentContextStore, AgentRuntime, ContextInjectionPlan, DirEntry, EventBus, EventStream,
ExitStatus, FileSystem, FsError, IdGenerator, MemoryError, MemoryQuery, MemoryRecall,
OutputStream, PermissionStore, PreparedContext, ProfileStore, PtyError, PtyHandle, PtyPort,
RemotePath, RuntimeError, SessionPlan, SkillStore, SpawnSpec, StoreError,
};
use domain::profile::{
AgentProfile, ContextInjection, McpCapability, McpConfigStrategy, McpTransport, OpenCodeConfig,
SessionStrategy, StructuredAdapter,
};
use domain::project::{Project, ProjectPath};
use domain::remote::RemoteRef;
use domain::skill::{Skill, SkillScope};
use domain::{MemoryIndexEntry, MemorySlug, MemoryType};
use domain::{PermissionSet, ProjectPermissions};
use domain::{PtySize, SessionId, SkillId, SkillRef};
use uuid::Uuid;
use application::{
CreateAgentFromScratch, CreateAgentInput, DeleteAgent, DeleteAgentInput, LaunchAgent,
LaunchAgentInput, ListAgents, ListAgentsInput, PermissionProjectorRegistry, ReadAgentContext,
ReadAgentContextInput, TerminalSessions, UpdateAgentContext, UpdateAgentContextInput,
};
// ---------------------------------------------------------------------------
// Shared trace (ordering)
// ---------------------------------------------------------------------------
type Trace = Arc<Mutex<Vec<String>>>;
/// A recorded list of `(target, bytes)` writes, keyed by whatever addresses the
/// target (a path for the fs, a [`SessionId`] for the pty).
type WriteLog<K> = Arc<Mutex<Vec<(K, Vec<u8>)>>>;
fn trace() -> Trace {
Arc::new(Mutex::new(Vec::new()))
}
// ---------------------------------------------------------------------------
// FakeContexts (AgentContextStore)
// ---------------------------------------------------------------------------
#[derive(Default)]
struct ContextsInner {
manifest: AgentManifest,
contents: HashMap<String, String>,
}
#[derive(Clone)]
struct FakeContexts(Arc<Mutex<ContextsInner>>);
impl FakeContexts {
fn new() -> Self {
Self(Arc::new(Mutex::new(ContextsInner {
manifest: AgentManifest {
version: 1,
entries: Vec::new(),
orchestrator: None,
},
contents: HashMap::new(),
})))
}
fn with_agent(agent: &Agent, content: &str) -> Self {
let me = Self::new();
{
let mut inner = me.0.lock().unwrap();
inner
.manifest
.entries
.push(ManifestEntry::from_agent(agent));
inner
.contents
.insert(agent.context_path.clone(), content.to_owned());
}
me
}
fn manifest(&self) -> AgentManifest {
self.0.lock().unwrap().manifest.clone()
}
fn content(&self, md_path: &str) -> Option<String> {
self.0.lock().unwrap().contents.get(md_path).cloned()
}
fn md_path_of(&self, agent: &AgentId) -> Option<String> {
self.0
.lock()
.unwrap()
.manifest
.entries
.iter()
.find(|e| &e.agent_id == agent)
.map(|e| e.md_path.clone())
}
}
#[async_trait]
impl AgentContextStore for FakeContexts {
async fn read_context(
&self,
_project: &Project,
agent: &AgentId,
) -> Result<MarkdownDoc, StoreError> {
let md_path = self.md_path_of(agent).ok_or(StoreError::NotFound)?;
self.content(&md_path)
.map(MarkdownDoc::new)
.ok_or(StoreError::NotFound)
}
async fn write_context(
&self,
_project: &Project,
agent: &AgentId,
md: &MarkdownDoc,
) -> Result<(), StoreError> {
let md_path = self.md_path_of(agent).ok_or(StoreError::NotFound)?;
self.0
.lock()
.unwrap()
.contents
.insert(md_path, md.as_str().to_owned());
Ok(())
}
async fn load_manifest(&self, _project: &Project) -> Result<AgentManifest, StoreError> {
Ok(self.manifest())
}
async fn save_manifest(
&self,
_project: &Project,
manifest: &AgentManifest,
) -> Result<(), StoreError> {
self.0.lock().unwrap().manifest = manifest.clone();
Ok(())
}
}
// ---------------------------------------------------------------------------
// FakeProfiles (ProfileStore)
// ---------------------------------------------------------------------------
#[derive(Clone)]
struct FakeProfiles(Arc<Vec<AgentProfile>>);
impl FakeProfiles {
fn new(profiles: Vec<AgentProfile>) -> Self {
Self(Arc::new(profiles))
}
}
#[async_trait]
impl ProfileStore for FakeProfiles {
async fn list(&self) -> Result<Vec<AgentProfile>, StoreError> {
Ok((*self.0).clone())
}
async fn save(&self, _profile: &AgentProfile) -> Result<(), StoreError> {
Ok(())
}
async fn delete(&self, _id: ProfileId) -> Result<(), StoreError> {
Ok(())
}
async fn is_configured(&self) -> Result<bool, StoreError> {
Ok(true)
}
async fn mark_configured(&self) -> Result<(), StoreError> {
Ok(())
}
}
// ---------------------------------------------------------------------------
// FakeSkills (SkillStore) — an in-memory store seeded with a few skills
// ---------------------------------------------------------------------------
#[derive(Clone, Default)]
struct FakeSkills(Arc<Vec<Skill>>);
impl FakeSkills {
fn with(skills: Vec<Skill>) -> Self {
Self(Arc::new(skills))
}
}
#[async_trait]
impl SkillStore for FakeSkills {
async fn list(&self, scope: SkillScope, _root: &ProjectPath) -> Result<Vec<Skill>, StoreError> {
Ok(self
.0
.iter()
.filter(|s| s.scope == scope)
.cloned()
.collect())
}
async fn get(
&self,
scope: SkillScope,
_root: &ProjectPath,
id: SkillId,
) -> Result<Skill, StoreError> {
self.0
.iter()
.find(|s| s.scope == scope && s.id == id)
.cloned()
.ok_or(StoreError::NotFound)
}
async fn save(&self, _skill: &Skill, _root: &ProjectPath) -> Result<(), StoreError> {
Ok(())
}
async fn delete(
&self,
_scope: SkillScope,
_root: &ProjectPath,
_id: SkillId,
) -> Result<(), StoreError> {
Ok(())
}
}
// ---------------------------------------------------------------------------
// FakeRecall (MemoryRecall) — returns a canned index, or fails (best-effort test)
// ---------------------------------------------------------------------------
/// In-memory [`MemoryRecall`] fake for the launch tests: empty by default
/// (⇒ no memory section, behaviour unchanged), configurable with canned entries,
/// or set to fail so the best-effort degradation at activation can be asserted.
#[derive(Clone, Default)]
struct FakeRecall {
entries: Arc<Vec<MemoryIndexEntry>>,
fail: bool,
}
impl FakeRecall {
fn returning(entries: Vec<MemoryIndexEntry>) -> Self {
Self {
entries: Arc::new(entries),
fail: false,
}
}
fn failing() -> Self {
Self {
entries: Arc::default(),
fail: true,
}
}
}
#[async_trait]
impl MemoryRecall for FakeRecall {
async fn recall(
&self,
_root: &ProjectPath,
_query: &MemoryQuery,
) -> Result<Vec<MemoryIndexEntry>, MemoryError> {
if self.fail {
return Err(MemoryError::Io("recall boom".to_owned()));
}
Ok((*self.entries).clone())
}
}
/// Builds a memory index entry for the launch tests.
fn mem_entry(slug: &str, title: &str, hook: &str, kind: MemoryType) -> MemoryIndexEntry {
MemoryIndexEntry {
slug: MemorySlug::new(slug).unwrap(),
title: title.to_owned(),
hook: hook.to_owned(),
r#type: kind,
}
}
// ---------------------------------------------------------------------------
// FakeRuntime (AgentRuntime) — records prepare + returns a configured plan
// ---------------------------------------------------------------------------
struct FakeRuntime {
trace: Trace,
plan: Option<ContextInjectionPlan>,
/// The last [`SessionPlan`] handed to `prepare_invocation`, captured so tests
/// can assert the launch resolved the right Assign/Resume/None intention (T4).
last_session: Arc<Mutex<Option<SessionPlan>>>,
}
impl FakeRuntime {
fn new(trace: Trace, plan: Option<ContextInjectionPlan>) -> Self {
Self {
trace,
plan,
last_session: Arc::new(Mutex::new(None)),
}
}
/// Shared handle to inspect the captured session plan after a launch.
fn session_probe(&self) -> Arc<Mutex<Option<SessionPlan>>> {
Arc::clone(&self.last_session)
}
}
#[async_trait]
impl AgentRuntime for FakeRuntime {
async fn detect(&self, _profile: &AgentProfile) -> Result<bool, RuntimeError> {
Ok(true)
}
fn prepare_invocation(
&self,
profile: &AgentProfile,
_ctx: &PreparedContext,
cwd: &ProjectPath,
session: &SessionPlan,
) -> Result<SpawnSpec, RuntimeError> {
*self.last_session.lock().unwrap() = Some(session.clone());
self.trace.lock().unwrap().push("prepare".to_owned());
Ok(SpawnSpec {
command: profile.command.clone(),
args: profile.args.clone(),
cwd: cwd.clone(),
env: Vec::new(),
context_plan: self.plan.clone(),
sandbox: None,
})
}
}
// ---------------------------------------------------------------------------
// FakeFs (FileSystem) — records writes into the trace
// ---------------------------------------------------------------------------
#[derive(Clone)]
struct FakeFs {
trace: Trace,
writes: WriteLog<String>,
created_dirs: Arc<Mutex<Vec<String>>>,
project_context: Arc<Mutex<Option<String>>>,
/// Paths reported as **already existing** by [`FileSystem::exists`] (the
/// default empty set keeps the historical `exists == false` behaviour). Used
/// by the MCP non-clobbering test.
existing: Arc<Mutex<Vec<String>>>,
/// Paths whose [`FileSystem::write`] must fail with an I/O error (nothing is
/// recorded for them). Used by the MCP best-effort test to prove that an MCP
/// config write failure never fails the launch.
fail_writes_for: Arc<Mutex<Vec<String>>>,
/// Canned `path → contents` returned by [`FileSystem::read`] when no later write
/// to that path exists. Used by the `MergeToml` projection test to seed a
/// pre-existing `.codex/config.toml` carrying unmanaged user keys.
seeded_reads: Arc<Mutex<HashMap<String, String>>>,
}
impl FakeFs {
fn new(trace: Trace) -> Self {
Self {
trace,
writes: Arc::new(Mutex::new(Vec::new())),
created_dirs: Arc::new(Mutex::new(Vec::new())),
project_context: Arc::new(Mutex::new(None)),
existing: Arc::new(Mutex::new(Vec::new())),
fail_writes_for: Arc::new(Mutex::new(Vec::new())),
seeded_reads: Arc::new(Mutex::new(HashMap::new())),
}
}
fn set_project_context(&self, content: &str) {
*self.project_context.lock().unwrap() = Some(content.to_owned());
}
/// Seeds a canned content for `path` so [`FileSystem::read`] returns it until a
/// later [`FileSystem::write`] supersedes it (last-write-wins).
fn seed_read(&self, path: &str, content: &str) {
self.seeded_reads
.lock()
.unwrap()
.insert(path.to_owned(), content.to_owned());
}
/// All writes whose path ends with `suffix` (e.g. the projected Codex config).
fn writes_ending_with(&self, suffix: &str) -> Vec<(String, Vec<u8>)> {
self.writes()
.into_iter()
.filter(|(p, _)| p.ends_with(suffix))
.collect()
}
/// Marks a path as already existing on disk, so [`FileSystem::exists`] returns
/// `true` for it (non-clobbering scenarios).
fn mark_existing(&self, path: &str) {
self.existing.lock().unwrap().push(path.to_owned());
}
/// Makes any [`FileSystem::write`] whose path ends with `suffix` fail
/// (best-effort scenarios — e.g. the MCP `.mcp.json` config file).
fn fail_write_suffix(&self, suffix: &str) {
self.fail_writes_for.lock().unwrap().push(suffix.to_owned());
}
fn writes(&self) -> Vec<(String, Vec<u8>)> {
self.writes.lock().unwrap().clone()
}
fn created_dirs(&self) -> Vec<String> {
self.created_dirs.lock().unwrap().clone()
}
/// Convention-file / context writes only (excludes the Claude permission seed),
/// so injection assertions stay focused on the agent's `.md`.
fn context_writes(&self) -> Vec<(String, Vec<u8>)> {
self.writes()
.into_iter()
.filter(|(p, _)| !p.ends_with("/.claude/settings.local.json"))
.collect()
}
/// Only the Claude permission seed writes (`.claude/settings.local.json`).
fn seed_writes(&self) -> Vec<(String, Vec<u8>)> {
self.writes()
.into_iter()
.filter(|(p, _)| p.ends_with("/.claude/settings.local.json"))
.collect()
}
/// Created run dirs excluding the seed's `.claude` subdir.
fn created_run_dirs(&self) -> Vec<String> {
self.created_dirs()
.into_iter()
.filter(|p| !p.ends_with("/.claude"))
.collect()
}
}
#[async_trait]
impl FileSystem for FakeFs {
async fn read(&self, path: &RemotePath) -> Result<Vec<u8>, FsError> {
let p = path.as_str();
// Last-write-wins: a previously written file reads back its latest content
// (so the MergeToml merge/idempotence test observes its own prior write).
if let Some((_, bytes)) = self.writes().into_iter().rev().find(|(wp, _)| wp == p) {
return Ok(bytes);
}
// Then any canned seed for this exact path.
if let Some(content) = self.seeded_reads.lock().unwrap().get(p) {
return Ok(content.clone().into_bytes());
}
if p.ends_with("/.ideai/CONTEXT.md") {
return self
.project_context
.lock()
.unwrap()
.clone()
.map(|s| s.into_bytes())
.ok_or_else(|| FsError::NotFound(p.to_owned()));
}
Err(FsError::NotFound(p.to_owned()))
}
async fn write(&self, path: &RemotePath, data: &[u8]) -> Result<(), FsError> {
let p = path.as_str();
if self
.fail_writes_for
.lock()
.unwrap()
.iter()
.any(|suffix| p.ends_with(suffix.as_str()))
{
return Err(FsError::Io(format!("forced write failure for {p}")));
}
self.trace.lock().unwrap().push("fs.write".to_owned());
self.writes
.lock()
.unwrap()
.push((p.to_owned(), data.to_vec()));
Ok(())
}
async fn exists(&self, path: &RemotePath) -> Result<bool, FsError> {
let p = path.as_str();
Ok(self.existing.lock().unwrap().iter().any(|e| e == p))
}
async fn create_dir_all(&self, path: &RemotePath) -> Result<(), FsError> {
self.created_dirs
.lock()
.unwrap()
.push(path.as_str().to_owned());
Ok(())
}
async fn list(&self, _path: &RemotePath) -> Result<Vec<DirEntry>, FsError> {
Ok(Vec::new())
}
async fn symlink(&self, _src: &RemotePath, _dst: &RemotePath) -> Result<(), FsError> {
Ok(())
}
}
// ---------------------------------------------------------------------------
// FakePty (PtyPort) — records spawn into the trace
// ---------------------------------------------------------------------------
#[derive(Clone)]
struct FakePty {
trace: Trace,
next_id: SessionId,
spawns: Arc<Mutex<Vec<SpawnSpec>>>,
writes: WriteLog<SessionId>,
}
impl FakePty {
fn new(trace: Trace, next_id: SessionId) -> Self {
Self {
trace,
next_id,
spawns: Arc::new(Mutex::new(Vec::new())),
writes: Arc::new(Mutex::new(Vec::new())),
}
}
fn spawns(&self) -> Vec<SpawnSpec> {
self.spawns.lock().unwrap().clone()
}
fn writes(&self) -> Vec<(SessionId, Vec<u8>)> {
self.writes.lock().unwrap().clone()
}
}
#[async_trait]
impl PtyPort for FakePty {
async fn spawn(&self, spec: SpawnSpec, _size: PtySize) -> Result<PtyHandle, PtyError> {
self.trace.lock().unwrap().push("spawn".to_owned());
self.spawns.lock().unwrap().push(spec);
Ok(PtyHandle {
session_id: self.next_id,
})
}
fn write(&self, handle: &PtyHandle, data: &[u8]) -> Result<(), PtyError> {
self.writes
.lock()
.unwrap()
.push((handle.session_id, data.to_vec()));
Ok(())
}
fn resize(&self, _handle: &PtyHandle, _size: PtySize) -> Result<(), PtyError> {
Ok(())
}
fn subscribe_output(&self, _handle: &PtyHandle) -> Result<OutputStream, PtyError> {
Ok(Box::new(std::iter::empty()))
}
fn scrollback(&self, _handle: &PtyHandle) -> Result<Vec<u8>, PtyError> {
Ok(Vec::new())
}
async fn kill(&self, _handle: &PtyHandle) -> Result<ExitStatus, PtyError> {
Ok(ExitStatus { code: Some(0) })
}
}
// ---------------------------------------------------------------------------
// SpyBus + SeqIds
// ---------------------------------------------------------------------------
#[derive(Default, Clone)]
struct SpyBus(Arc<Mutex<Vec<DomainEvent>>>);
impl SpyBus {
fn events(&self) -> Vec<DomainEvent> {
self.0.lock().unwrap().clone()
}
}
impl EventBus for SpyBus {
fn publish(&self, event: DomainEvent) {
self.0.lock().unwrap().push(event);
}
fn subscribe(&self) -> EventStream {
Box::new(std::iter::empty())
}
}
struct SeqIds(Mutex<u128>);
impl SeqIds {
fn new() -> Self {
Self(Mutex::new(1))
}
}
impl IdGenerator for SeqIds {
fn new_uuid(&self) -> Uuid {
let mut n = self.0.lock().unwrap();
let id = Uuid::from_u128(*n);
*n += 1;
id
}
}
// ---------------------------------------------------------------------------
// Builders
// ---------------------------------------------------------------------------
fn pid(n: u128) -> ProfileId {
ProfileId::from_uuid(Uuid::from_u128(n))
}
fn aid(n: u128) -> AgentId {
AgentId::from_uuid(Uuid::from_u128(n))
}
fn sid(n: u128) -> SessionId {
SessionId::from_uuid(Uuid::from_u128(n))
}
fn project() -> Project {
Project::new(
ProjectId::from_uuid(Uuid::from_u128(1000)),
"demo",
ProjectPath::new("/home/me/proj").unwrap(),
RemoteRef::local(),
1_700_000_000_000,
)
.unwrap()
}
fn profile(id: ProfileId, injection: ContextInjection) -> AgentProfile {
AgentProfile::new(
id,
"Claude Code",
"claude",
Vec::new(),
injection,
Some("claude --version".to_owned()),
"{agentRunDir}",
None,
)
.unwrap()
}
fn scratch_agent(id: AgentId, name: &str, md: &str, profile_id: ProfileId) -> Agent {
Agent::new(id, name, md, profile_id, AgentOrigin::Scratch, false).unwrap()
}
// ---------------------------------------------------------------------------
// CreateAgentFromScratch
// ---------------------------------------------------------------------------
#[tokio::test]
async fn create_persists_manifest_entry_and_initial_context() {
let contexts = FakeContexts::new();
let bus = SpyBus::default();
let create = CreateAgentFromScratch::new(
Arc::new(contexts.clone()),
Arc::new(SeqIds::new()),
Arc::new(bus.clone()),
);
let out = create
.execute(CreateAgentInput {
project: project(),
name: "Backend Dev".to_owned(),
profile_id: pid(9),
initial_content: Some("# Backend".to_owned()),
})
.await
.expect("create succeeds");
// md_path is slugified from the name.
assert_eq!(out.agent.context_path, "agents/backend-dev.md");
assert_eq!(out.agent.profile_id, pid(9));
assert!(matches!(out.agent.origin, AgentOrigin::Scratch));
assert!(!out.agent.synchronized);
// Manifest has exactly one entry for this agent; context stored under md_path.
let manifest = contexts.manifest();
assert_eq!(manifest.entries.len(), 1);
assert_eq!(manifest.entries[0].agent_id, out.agent.id);
assert_eq!(
contexts.content("agents/backend-dev.md").as_deref(),
Some("# Backend")
);
}
#[tokio::test]
async fn create_disambiguates_md_path_on_name_collision() {
// Seed a project that already has `agents/backend.md`.
let existing = scratch_agent(aid(50), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&existing, "old");
let create = CreateAgentFromScratch::new(
Arc::new(contexts.clone()),
Arc::new(SeqIds::new()),
Arc::new(SpyBus::default()),
);
let out = create
.execute(CreateAgentInput {
project: project(),
name: "Backend".to_owned(),
profile_id: pid(9),
initial_content: None,
})
.await
.unwrap();
assert_eq!(out.agent.context_path, "agents/backend-2.md");
assert_eq!(contexts.manifest().entries.len(), 2);
}
// ---------------------------------------------------------------------------
// ListAgents / Read / Update / Delete
// ---------------------------------------------------------------------------
#[tokio::test]
async fn list_reconstructs_agents_from_manifest() {
let a = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&a, "ctx");
let list = ListAgents::new(Arc::new(contexts));
let out = list
.execute(ListAgentsInput { project: project() })
.await
.unwrap();
assert_eq!(out.agents, vec![a]);
}
#[tokio::test]
async fn read_then_update_context_roundtrips() {
let a = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&a, "original");
let read = ReadAgentContext::new(Arc::new(contexts.clone()));
let update = UpdateAgentContext::new(Arc::new(contexts.clone()));
let before = read
.execute(ReadAgentContextInput {
project: project(),
agent_id: a.id,
})
.await
.unwrap();
assert_eq!(before.content.as_str(), "original");
update
.execute(UpdateAgentContextInput {
project: project(),
agent_id: a.id,
content: "edited".to_owned(),
})
.await
.unwrap();
assert_eq!(
contexts.content("agents/backend.md").as_deref(),
Some("edited")
);
}
#[tokio::test]
async fn delete_removes_entry_then_unknown_is_not_found() {
let a = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&a, "ctx");
let delete = DeleteAgent::new(Arc::new(contexts.clone()), Arc::new(SpyBus::default()));
delete
.execute(DeleteAgentInput {
project: project(),
agent_id: a.id,
})
.await
.unwrap();
assert!(contexts.manifest().entries.is_empty());
// Second delete: the agent is gone → NotFound.
let err = delete
.execute(DeleteAgentInput {
project: project(),
agent_id: a.id,
})
.await
.unwrap_err();
assert_eq!(err.code(), "NOT_FOUND", "got {err:?}");
}
// ---------------------------------------------------------------------------
// LaunchAgent
// ---------------------------------------------------------------------------
/// Everything a launch test needs to drive `LaunchAgent` and assert over the
/// fakes: the use case, the seeded agent, the recording fs/pty, the event spy,
/// the session registry and the shared ordering trace.
type LaunchFixture = (
LaunchAgent,
Agent,
FakeFs,
FakePty,
SpyBus,
Arc<TerminalSessions>,
Trace,
Arc<Mutex<Option<SessionPlan>>>,
);
/// Wires a LaunchAgent over fakes for a given injection strategy/plan.
fn launch_fixture(
injection: ContextInjection,
plan: Option<ContextInjectionPlan>,
) -> LaunchFixture {
launch_fixture_with_profile(profile(pid(9), injection), plan)
}
/// Like [`launch_fixture`] but takes a fully-built profile (so session-strategy
/// variants can be exercised). The seeded agent uses the profile's id.
fn launch_fixture_with_profile(
profile: AgentProfile,
plan: Option<ContextInjectionPlan>,
) -> LaunchFixture {
launch_fixture_with_profile_and_recall(profile, plan, FakeRecall::default())
}
/// Like [`launch_fixture_with_profile`] but also takes the [`MemoryRecall`] fake,
/// so the memory-injection feature can be exercised. The default callers pass an
/// empty [`FakeRecall`] ⇒ no memory section ⇒ behaviour unchanged.
fn launch_fixture_with_profile_and_recall(
profile: AgentProfile,
plan: Option<ContextInjectionPlan>,
recall: FakeRecall,
) -> LaunchFixture {
let agent = scratch_agent(aid(1), "Backend", "agents/backend.md", profile.id);
let contexts = FakeContexts::with_agent(&agent, "# ctx body");
let profiles = FakeProfiles::new(vec![profile]);
let tr = trace();
let runtime = FakeRuntime::new(Arc::clone(&tr), plan);
let session_probe = runtime.session_probe();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let sessions = Arc::new(TerminalSessions::new());
let bus = SpyBus::default();
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(runtime),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::clone(&sessions),
Arc::new(bus.clone()),
Arc::new(SeqIds::new()),
Arc::new(recall),
None,
);
(launch, agent, fs, pty, bus, sessions, tr, session_probe)
}
fn launch_input(agent_id: AgentId) -> LaunchAgentInput {
LaunchAgentInput {
project: project(),
agent_id,
rows: 24,
cols: 80,
node_id: None,
conversation_id: None,
mcp_runtime: None,
allow_structured_alongside_pty: false,
}
}
#[tokio::test]
async fn launch_orders_prepare_then_injection_then_spawn() {
// conventionFile strategy → an fs.write must happen between prepare and spawn.
let (launch, agent, fs, pty, bus, sessions, tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let out = launch
.execute(launch_input(agent.id))
.await
.expect("launch");
// Ordering contract (lot LP3-3): prepare → injection (convention file) → spawn.
// The permission projection no longer runs here — no projector registry is wired
// in this fixture (`LaunchAgent::new` without `with_permission_projectors`), so no
// extra `fs.write` precedes prepare. With a registry, the projection write would
// appear *after* the injection write and before spawn (see `apply_permission_projection`).
assert_eq!(
*tr.lock().unwrap(),
vec![
"prepare".to_owned(),
"fs.write".to_owned(),
"spawn".to_owned()
],
"prepare → injection → spawn"
);
// The conventionFile was written inside the agent's isolated run directory
// (`.ideai/run/<agent-id>/CLAUDE.md`) — NOT at the project root. Its content
// is the *composed* document: an absolute project-root header followed by the
// agent persona `.md`.
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let writes = fs.context_writes();
assert_eq!(writes.len(), 1);
assert_eq!(writes[0].0, format!("{run_dir}/CLAUDE.md"));
let written = String::from_utf8(writes[0].1.clone()).unwrap();
assert!(
written.contains("/home/me/proj"),
"convention file must carry the absolute project root, got: {written}"
);
assert!(
written.contains("# ctx body"),
"convention file must carry the agent persona, got: {written}"
);
// Lot LP3-3: the Claude permission seed is no longer written unconditionally
// here. It is now produced by the Claude permission projector and written only
// when a projector registry is wired (`with_permission_projectors`) — absent in
// this fixture — so no seed is written. (Projection coverage lives in the infra
// projector tests (LP3-2) and the LP3-3 projection wiring tests, QA.)
assert!(
fs.seed_writes().is_empty(),
"no projector registry wired ⇒ no permission seed written"
);
// The run directory was created before spawn.
assert_eq!(fs.created_run_dirs(), vec![run_dir.clone()]);
// Spawn happened at the isolated run dir with the profile command.
let spawns = pty.spawns();
assert_eq!(spawns.len(), 1);
assert_eq!(spawns[0].command, "claude");
assert_eq!(spawns[0].cwd.as_str(), run_dir);
// The session adopts the PTY id, is Running, and is registered as an agent.
assert_eq!(out.session.id, sid(777));
assert!(matches!(
out.session.kind,
domain::SessionKind::Agent { agent_id } if agent_id == agent.id
));
assert!(sessions.session(&sid(777)).is_some());
// AgentLaunched announced.
assert_eq!(
bus.events(),
vec![DomainEvent::AgentLaunched {
agent_id: agent.id,
session_id: sid(777),
}]
);
}
#[tokio::test]
async fn launch_injects_shared_project_context_from_ideai_context_md() {
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
fs.set_project_context("# Shared project\n\nUse pnpm.");
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
let writes = fs.context_writes();
assert_eq!(writes.len(), 1);
let doc = String::from_utf8(writes[0].1.clone()).unwrap();
assert!(doc.contains("# Contexte projet"));
assert!(doc.contains("Use pnpm."));
let project_context_at = doc.find("# Contexte projet").unwrap();
let persona_at = doc.find("# ctx body").unwrap();
assert!(
project_context_at < persona_at,
"project context must precede the agent persona"
);
}
/// Inserts a live agent session into the registry, simulating an already-running
/// agent pinned on `node`. Returns the session id.
fn seed_live_agent_session(
sessions: &TerminalSessions,
agent_id: AgentId,
node: domain::NodeId,
session_id: SessionId,
) {
let size = PtySize::new(24, 80).unwrap();
let mut session = domain::TerminalSession::starting(
session_id,
node,
ProjectPath::new("/home/me/proj/.ideai/run/x").unwrap(),
domain::SessionKind::Agent { agent_id },
size,
);
session.status = domain::SessionStatus::Running;
sessions.insert(PtyHandle { session_id }, session);
}
fn nid(n: u128) -> domain::NodeId {
domain::NodeId::from_uuid(Uuid::from_u128(n))
}
/// **Singleton invariant (R0a, décision « 1 agent = 1 employé »)**: a *fresh*
/// launch (no `conversation_id`) targeting **another** cell of an agent already
/// live in cell A is a genuine second launch ⇒ it is **refused** with
/// `AppError::AgentAlreadyRunning { node_id: A, agent_id }`. The session is NOT
/// silently moved, the PTY is never spawned, and the registry is unchanged.
#[tokio::test]
async fn launch_new_in_other_cell_refuses_when_agent_live_elsewhere() {
let (launch, agent, _fs, pty, _bus, sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
// The agent is already live in cell A.
let host = nid(1);
seed_live_agent_session(&sessions, agent.id, host, sid(42));
let before = sessions.len();
// Fresh launch (conversation_id: None) of the same running agent in a
// *different* cell B ⇒ must be refused, not silently rebound.
let mut input = launch_input(agent.id);
let target = nid(2);
input.node_id = Some(target);
let err = launch
.execute(input)
.await
.expect_err("fresh second launch elsewhere is refused");
match err {
application::AppError::AgentAlreadyRunning { agent_id, node_id } => {
assert_eq!(agent_id, agent.id, "reports the live agent");
assert_eq!(node_id, host, "reports the live HOST node A, not target B");
}
other => panic!("expected AgentAlreadyRunning, got {other:?}"),
}
// No silent move, no respawn, registry untouched.
assert_eq!(
sessions.node_for_agent(&agent.id),
Some(host),
"session stays pinned on its host node"
);
assert_eq!(sessions.len(), before, "registry size is unchanged");
assert!(pty.spawns().is_empty(), "no PTY spawn on a refused launch");
}
/// A launch with an unspecified node (`node_id: None`) for an already-live agent
/// is a background/idempotent no-op: return the existing session without
/// respawning or changing its current host.
#[tokio::test]
async fn launch_existing_agent_with_no_node_is_background_noop() {
let (launch, agent, _fs, pty, _bus, sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
seed_live_agent_session(&sessions, agent.id, nid(1), sid(42));
// node_id defaults to None in launch_input.
let out = launch
.execute(launch_input(agent.id))
.await
.expect("background relaunch is idempotent");
assert_eq!(out.session.id, sid(42));
assert_eq!(out.session.node_id, nid(1));
assert!(pty.spawns().is_empty());
}
/// Idempotence on the SAME node: a double-launch of the very same cell returns
/// the already-registered session without respawning, and assigns no new
/// conversation id.
#[tokio::test]
async fn launch_same_node_is_idempotent_no_respawn() {
let (launch, agent, _fs, pty, _bus, sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let host = nid(7);
seed_live_agent_session(&sessions, agent.id, host, sid(42));
let before = sessions.len();
let mut input = launch_input(agent.id);
input.node_id = Some(host);
let out = launch.execute(input).await.expect("idempotent launch");
assert_eq!(out.session.id, sid(42), "returns the existing session");
assert!(
out.assigned_conversation_id.is_none(),
"nothing new assigned"
);
assert_eq!(sessions.len(), before, "no new session registered");
assert!(pty.spawns().is_empty(), "no respawn on same-node relaunch");
}
/// **Legitimate explicit reattach (R0a)**: launching an agent that is live in
/// cell A onto a *different* cell B but carrying a `conversation_id` is an
/// explicit view reattach (the cell knows the agent was running) ⇒ rebind, no
/// error, no respawn, same session id.
#[tokio::test]
async fn launch_other_cell_with_conversation_id_rebinds_no_respawn() {
let (launch, agent, _fs, pty, _bus, sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let host = nid(1);
seed_live_agent_session(&sessions, agent.id, host, sid(42));
let before = sessions.len();
// Different cell B, but an explicit reattach signal (conversation_id present).
let mut input = launch_input(agent.id);
let target = nid(2);
input.node_id = Some(target);
input.conversation_id = Some("conv-live".to_owned());
let out = launch
.execute(input)
.await
.expect("explicit reattach succeeds");
assert_eq!(out.session.id, sid(42), "returns the existing session");
assert_eq!(out.session.node_id, target, "view rebound to target cell");
assert_eq!(sessions.node_for_agent(&agent.id), Some(target));
assert_eq!(sessions.len(), before, "registry size is unchanged");
assert!(pty.spawns().is_empty(), "no PTY spawn on explicit reattach");
}
/// After the live session is removed (cell closed / agent exited), a fresh launch
/// succeeds — the guard only blocks while the agent is actually live.
#[tokio::test]
async fn launch_succeeds_after_session_removed() {
let (launch, agent, _fs, pty, _bus, sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
// Live, then removed (close/exit).
seed_live_agent_session(&sessions, agent.id, nid(1), sid(42));
sessions.remove(&sid(42));
assert!(sessions.session_for_agent(&agent.id).is_none());
let mut input = launch_input(agent.id);
input.node_id = Some(nid(2));
let out = launch.execute(input).await.expect("relaunch must succeed");
assert_eq!(out.session.id, sid(777), "spawned a fresh PTY session");
assert_eq!(
pty.spawns().len(),
1,
"exactly one spawn after the agent died"
);
}
/// **Anti-collision (ARCHITECTURE §14.1)**: two distinct agents of the *same*
/// profile on the *same* project root must launch into two **distinct** cwd —
/// each its own `.ideai/run/<agent-id>/` — and each writes its convention file
/// inside its own run dir, never colliding at the project root.
#[tokio::test]
async fn two_agents_same_root_get_distinct_run_dirs_no_collision() {
let injection = ContextInjection::convention_file("CLAUDE.md").unwrap();
let plan = Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
});
// Two agents, same profile (pid(9)), same project root.
let agent_a = scratch_agent(aid(1), "Alpha", "agents/alpha.md", pid(9));
let agent_b = scratch_agent(aid(2), "Bravo", "agents/bravo.md", pid(9));
let contexts = FakeContexts::with_agent(&agent_a, "# alpha");
{
let mut inner = contexts.0.lock().unwrap();
inner
.manifest
.entries
.push(ManifestEntry::from_agent(&agent_b));
inner
.contents
.insert(agent_b.context_path.clone(), "# bravo".to_owned());
}
let profiles = FakeProfiles::new(vec![profile(pid(9), injection)]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let sessions = Arc::new(TerminalSessions::new());
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(Arc::clone(&tr), plan)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::clone(&sessions),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
launch.execute(launch_input(agent_a.id)).await.unwrap();
launch.execute(launch_input(agent_b.id)).await.unwrap();
let dir_a = format!("/home/me/proj/.ideai/run/{}", agent_a.id);
let dir_b = format!("/home/me/proj/.ideai/run/{}", agent_b.id);
assert_ne!(
dir_a, dir_b,
"the two agents must map to different run dirs"
);
// Two distinct run dirs were created (ignoring each seed's `.claude` subdir).
assert_eq!(fs.created_run_dirs(), vec![dir_a.clone(), dir_b.clone()]);
// Two spawns at two distinct cwd — the core anti-collision guarantee.
let spawns = pty.spawns();
assert_eq!(spawns.len(), 2);
assert_eq!(spawns[0].cwd.as_str(), dir_a);
assert_eq!(spawns[1].cwd.as_str(), dir_b);
assert_ne!(spawns[0].cwd, spawns[1].cwd);
// Two convention files, each inside its own run dir (no shared root file).
let writes = fs.context_writes();
assert_eq!(writes.len(), 2);
assert_eq!(writes[0].0, format!("{dir_a}/CLAUDE.md"));
assert_eq!(writes[1].0, format!("{dir_b}/CLAUDE.md"));
assert_ne!(writes[0].0, writes[1].0);
// Neither writes to the project root.
assert!(writes.iter().all(|(p, _)| p != "/home/me/proj/CLAUDE.md"));
// Each convention file carries its own persona.
assert!(String::from_utf8(writes[0].1.clone())
.unwrap()
.contains("# alpha"));
assert!(String::from_utf8(writes[1].1.clone())
.unwrap()
.contains("# bravo"));
}
#[tokio::test]
async fn launch_conventionfile_injects_assigned_skills_in_order() {
// An agent with two assigned global skills; the generated convention file must
// carry both skill bodies, after the persona, in assignment order (§14.2).
let skill_id = |n: u128| SkillId::from_uuid(Uuid::from_u128(n));
let skill = |n: u128, name: &str, body: &str| {
Skill::new(
skill_id(n),
name,
MarkdownDoc::new(body),
SkillScope::Global,
)
.unwrap()
};
let mut agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
agent.assign_skill(SkillRef::new(skill_id(1), SkillScope::Global));
agent.assign_skill(SkillRef::new(skill_id(2), SkillScope::Global));
let contexts = FakeContexts::with_agent(&agent, "# persona");
let profiles = FakeProfiles::new(vec![profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let skills = FakeSkills::with(vec![
skill(1, "refactor", "REFAC_BODY"),
skill(2, "review", "REVIEW_BODY"),
]);
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(
Arc::clone(&tr),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(skills),
Arc::new(TerminalSessions::new()),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
launch.execute(launch_input(agent.id)).await.unwrap();
let writes = fs.context_writes();
assert_eq!(writes.len(), 1);
let doc = String::from_utf8(writes[0].1.clone()).unwrap();
assert!(doc.contains("# persona"), "persona present: {doc}");
assert!(doc.contains("REFAC_BODY"), "first skill body present");
assert!(doc.contains("REVIEW_BODY"), "second skill body present");
// Deterministic order: persona before skills, skill 1 before skill 2.
let persona_at = doc.find("# persona").unwrap();
let refac_at = doc.find("REFAC_BODY").unwrap();
let review_at = doc.find("REVIEW_BODY").unwrap();
assert!(
persona_at < refac_at && refac_at < review_at,
"ordering: {doc}"
);
}
#[tokio::test]
async fn launch_conventionfile_injects_project_memory_in_order() {
// A non-empty recall ⇒ the generated convention file must carry a
// `# Mémoire projet` section with one line per entry, in the recalled order
// and the exact `- [Title](slug.md) — hook (type)` format (§14.5.4).
let recall = FakeRecall::returning(vec![
mem_entry(
"git-optional",
"Git optionnel",
"git reste un simple tool",
MemoryType::Project,
),
mem_entry(
"perm-archi",
"Permissions",
"sandbox OS + résumé injecté",
MemoryType::Reference,
),
]);
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) =
launch_fixture_with_profile_and_recall(
profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
recall,
);
launch.execute(launch_input(agent.id)).await.unwrap();
let writes = fs.context_writes();
assert_eq!(writes.len(), 1);
let doc = String::from_utf8(writes[0].1.clone()).unwrap();
assert!(
doc.contains("# Mémoire projet"),
"memory section present: {doc}"
);
assert!(
doc.contains(
"- [Git optionnel](.ideai/memory/git-optional.md) — git reste un simple tool (project)"
),
"first memory line exact format: {doc}"
);
assert!(
doc.contains(
"- [Permissions](.ideai/memory/perm-archi.md) — sandbox OS + résumé injecté (reference)"
),
"second memory line exact format: {doc}"
);
// Recalled order preserved; section after the persona.
let persona_at = doc.find("# ctx body").unwrap();
let section_at = doc.find("# Mémoire projet").unwrap();
let first_at = doc.find("[Git optionnel]").unwrap();
let second_at = doc.find("[Permissions]").unwrap();
assert!(persona_at < section_at, "memory after persona: {doc}");
assert!(
first_at < second_at,
"entries kept in recalled order: {doc}"
);
}
#[tokio::test]
async fn launch_conventionfile_without_memory_omits_section() {
// The default empty recall ⇒ no `# Mémoire projet` section (behaviour unchanged).
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let doc = String::from_utf8(fs.context_writes()[0].1.clone()).unwrap();
assert!(
!doc.contains("# Mémoire projet"),
"no memory ⇒ no section: {doc}"
);
}
#[tokio::test]
async fn launch_recall_error_degrades_to_no_section_without_failing() {
// A failing recall must NOT fail the launch (best-effort, §14.5.4): the launch
// succeeds and the convention file simply carries no memory section.
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) =
launch_fixture_with_profile_and_recall(
profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
FakeRecall::failing(),
);
// Launch still succeeds despite the recall error.
launch
.execute(launch_input(agent.id))
.await
.expect("launch must succeed");
let doc = String::from_utf8(fs.context_writes()[0].1.clone()).unwrap();
assert!(
!doc.contains("# Mémoire projet"),
"recall error ⇒ no section, launch unaffected: {doc}"
);
}
#[tokio::test]
async fn launch_env_strategy_injects_no_memory_section() {
// For the `env` strategy IdeA writes no convention file, so no memory section is
// injected — aligned with how skills are only injected for `conventionFile`.
let recall = FakeRecall::returning(vec![mem_entry("note", "Note", "a hook", MemoryType::User)]);
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) =
launch_fixture_with_profile_and_recall(
profile(pid(9), ContextInjection::env("IDEA_CONTEXT").unwrap()),
Some(ContextInjectionPlan::Env {
var: "IDEA_CONTEXT".to_owned(),
}),
recall,
);
launch.execute(launch_input(agent.id)).await.unwrap();
// The env strategy writes no convention file at all (only the run-dir seed).
assert!(
fs.context_writes().is_empty(),
"env strategy must not write a convention file"
);
}
#[tokio::test]
async fn launch_skips_dangling_skill_ref_without_failing() {
// The agent references a skill that no longer exists in the store: launch must
// still succeed and simply omit it (no Skills section for a sole dangling ref).
let mut agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
agent.assign_skill(SkillRef::new(
SkillId::from_uuid(Uuid::from_u128(99)),
SkillScope::Global,
));
let contexts = FakeContexts::with_agent(&agent, "# persona");
let profiles = FakeProfiles::new(vec![profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(
Arc::clone(&tr),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()), // empty store ⇒ the ref is dangling
Arc::new(TerminalSessions::new()),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch must succeed");
let doc = String::from_utf8(fs.context_writes()[0].1.clone()).unwrap();
assert!(
!doc.contains("# Skills"),
"no Skills section for a dangling ref: {doc}"
);
}
#[tokio::test]
async fn launch_non_claude_convention_does_not_seed_permissions() {
// A CLI whose convention file is NOT CLAUDE.md (e.g. Codex → AGENTS.md) must
// get its convention file but NO Claude permission seed (Bug #5 is per-CLI).
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("AGENTS.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
// The convention file was written, but no permission seed.
assert_eq!(fs.context_writes().len(), 1);
assert!(
fs.seed_writes().is_empty(),
"no Claude seed for a non-Claude CLI"
);
assert!(
!fs.created_dirs().iter().any(|p| p.ends_with("/.claude")),
"no .claude dir created for a non-Claude CLI"
);
}
#[tokio::test]
async fn launch_stdin_strategy_pipes_context_after_spawn() {
let (launch, agent, fs, pty, _bus, _sessions, tr, _session) =
launch_fixture(ContextInjection::stdin(), Some(ContextInjectionPlan::Stdin));
launch.execute(launch_input(agent.id)).await.unwrap();
// No file written for stdin; content is piped to the PTY post-spawn.
assert!(fs.writes().is_empty(), "stdin must not write a file");
assert_eq!(
*tr.lock().unwrap(),
vec!["prepare".to_owned(), "spawn".to_owned()]
);
let writes = pty.writes();
assert_eq!(writes.len(), 1);
assert_eq!(writes[0].0, sid(777));
assert_eq!(writes[0].1, b"# ctx body");
}
#[tokio::test]
async fn launch_unknown_agent_is_not_found() {
let (launch, _agent, _fs, pty, _bus, _sessions, _tr, _session) =
launch_fixture(ContextInjection::stdin(), Some(ContextInjectionPlan::Stdin));
let err = launch.execute(launch_input(aid(404))).await.unwrap_err();
assert_eq!(err.code(), "NOT_FOUND", "got {err:?}");
assert!(pty.spawns().is_empty(), "no spawn for unknown agent");
}
#[tokio::test]
async fn launch_unknown_profile_is_not_found() {
// The agent references pid(9) but the store only knows pid(1).
let agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&agent, "ctx");
let profiles = FakeProfiles::new(vec![profile(pid(1), ContextInjection::stdin())]);
let tr = trace();
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(
Arc::clone(&tr),
Some(ContextInjectionPlan::Stdin),
)),
Arc::new(FakeFs::new(Arc::clone(&tr))),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::new(TerminalSessions::new()),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
let err = launch.execute(launch_input(agent.id)).await.unwrap_err();
assert_eq!(err.code(), "NOT_FOUND", "got {err:?}");
assert!(pty.spawns().is_empty(), "no spawn when profile unresolved");
}
// ---------------------------------------------------------------------------
// LaunchAgent — MCP config injection (M1, cadrage v3 Décision 3)
// ---------------------------------------------------------------------------
/// Builds a CLAUDE.md-convention profile carrying an [`McpCapability`], so the
/// MCP injection path (`apply_mcp_config`) is exercised during a launch.
fn profile_with_mcp(id: ProfileId, config: McpConfigStrategy) -> AgentProfile {
profile(id, ContextInjection::convention_file("CLAUDE.md").unwrap())
.with_mcp(McpCapability::new(config, McpTransport::Stdio))
}
fn opencode_profile(id: ProfileId) -> AgentProfile {
profile(id, ContextInjection::convention_file("AGENTS.md").unwrap())
.with_structured_adapter(StructuredAdapter::OpenCode)
.with_opencode(
OpenCodeConfig::new(
"http://localhost:8080/v1",
Some("sk-no-key".to_owned()),
"qwen3-coder-30b",
None,
None,
)
.unwrap(),
)
.with_mcp(McpCapability::new(
McpConfigStrategy::open_code_config("opencode.json").unwrap(),
McpTransport::Stdio,
))
}
/// Returns the writes whose path ends with the given suffix (e.g. `/.mcp.json`).
fn writes_ending_with(fs: &FakeFs, suffix: &str) -> Vec<(String, Vec<u8>)> {
fs.writes()
.into_iter()
.filter(|(p, _)| p.ends_with(suffix))
.collect()
}
#[tokio::test]
async fn launch_without_mcp_writes_no_mcp_config_and_leaves_spec_untouched() {
// Test 1 — profile.mcp = None ⇒ no MCP file written, spec.args/env unchanged.
// The profile has empty args and the runtime adds no env, so a clean launch
// must leave the spawned spec's args/env exactly empty (no MCP flag/env).
let (launch, agent, fs, pty, _bus, _sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
// No MCP-style config file anywhere.
assert!(
writes_ending_with(&fs, "/.mcp.json").is_empty(),
"no MCP config file when profile.mcp is None"
);
// Exactly the convention file write (+ the Claude seed), nothing MCP-related.
assert_eq!(
fs.context_writes().len(),
1,
"only the convention file is written"
);
// Spec args/env carry nothing MCP-related (here: empty).
let spawns = pty.spawns();
assert_eq!(spawns.len(), 1);
assert!(spawns[0].args.is_empty(), "no MCP flag pushed to args");
assert!(spawns[0].env.is_empty(), "no MCP var pushed to env");
}
#[tokio::test]
async fn launch_mcp_config_file_writes_declaration_at_run_dir_target() {
// Test 2 — ConfigFile { target: ".mcp.json" } ⇒ a file is written at
// <run_dir>/.mcp.json with a non-empty, coherent MCP server declaration.
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let mcp = writes_ending_with(&fs, "/.mcp.json");
assert_eq!(mcp.len(), 1, "exactly one MCP config file written");
assert_eq!(
mcp[0].0,
format!("{run_dir}/.mcp.json"),
"written at run dir"
);
let body = String::from_utf8(mcp[0].1.clone()).unwrap();
assert!(!body.trim().is_empty(), "MCP declaration is non-empty");
// Coherent MCP server declaration (an `mcpServers`/`idea` server entry).
assert!(
body.contains("mcpServers") && body.contains("idea"),
"MCP declaration must declare the IdeA MCP server, got: {body}"
);
// It is valid JSON.
let _: serde_json::Value = serde_json::from_str(&body).expect("MCP declaration is valid JSON");
}
#[tokio::test]
async fn launch_mcp_config_file_is_non_clobbering() {
// Test 3 — if <run_dir>/.mcp.json already exists, the launch must NOT overwrite
// it: no write is recorded against that path.
let profile = profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap());
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile,
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
// Pre-existing MCP config file on disk.
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
fs.mark_existing(&format!("{run_dir}/.mcp.json"));
launch.execute(launch_input(agent.id)).await.unwrap();
assert!(
writes_ending_with(&fs, "/.mcp.json").is_empty(),
"an existing MCP config file must not be clobbered"
);
}
#[tokio::test]
async fn launch_mcp_config_file_write_failure_is_best_effort() {
// Test 4 — a write failure on the MCP config file must NOT fail the launch.
let profile = profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap());
let (launch, agent, fs, pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile,
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
// Force the MCP config write to fail.
fs.fail_write_suffix("/.mcp.json");
// The launch still succeeds and spawns the CLI.
let out = launch
.execute(launch_input(agent.id))
.await
.expect("MCP write failure must not fail the launch");
assert!(out.structured.is_none());
assert_eq!(pty.spawns().len(), 1, "the CLI is still spawned");
}
#[tokio::test]
async fn launch_opencode_writes_isolated_config_and_env() {
let profile = opencode_profile(pid(9));
let (launch, agent, fs, pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let opencode = writes_ending_with(&fs, "/opencode.json");
assert_eq!(opencode.len(), 1, "one OpenCode config is written");
assert_eq!(opencode[0].0, format!("{run_dir}/opencode.json"));
let body: serde_json::Value = serde_json::from_slice(&opencode[0].1).unwrap();
assert_eq!(body["model"], "llamacpp/qwen3-coder-30b");
assert_eq!(
body["provider"]["llamacpp"]["options"]["baseURL"],
"http://localhost:8080/v1"
);
assert_eq!(
body["provider"]["llamacpp"]["options"]["apiKey"],
"sk-no-key"
);
assert_eq!(
body["provider"]["llamacpp"]["models"]["qwen3-coder-30b"]["name"],
"llamacpp/qwen3-coder-30b"
);
assert_eq!(
body["provider"]["llamacpp"]["models"]["qwen3-coder-30b"]["tool_call"],
true
);
assert_eq!(
body["provider"]["llamacpp"]["models"]["qwen3-coder-30b"]["reasoning"],
true
);
assert_eq!(
body["provider"]["llamacpp"]["models"]["qwen3-coder-30b"]["attachment"],
false
);
assert_eq!(
body["disabled_providers"],
serde_json::json!(["anthropic", "openai", "gemini", "ollama"])
);
assert_eq!(body["mcp"]["idea"]["type"], "local");
assert_eq!(body["mcp"]["idea"]["command"][0], "idea");
let spawn = pty
.spawns()
.pop()
.expect("spawned via PTY fallback in this fixture");
let env: std::collections::HashMap<_, _> = spawn.env.into_iter().collect();
assert_eq!(
env.get("OPENCODE_CONFIG").map(String::as_str),
Some(format!("{run_dir}/opencode.json").as_str())
);
assert_eq!(
env.get("HOME").map(String::as_str),
Some(format!("{run_dir}/.opencode").as_str())
);
assert_eq!(
env.get("XDG_CONFIG_HOME").map(String::as_str),
Some(format!("{run_dir}/.opencode/config").as_str())
);
assert_eq!(
env.get("XDG_DATA_HOME").map(String::as_str),
Some(format!("{run_dir}/.opencode/data").as_str())
);
assert_eq!(
env.get("XDG_CACHE_HOME").map(String::as_str),
Some(format!("{run_dir}/.opencode/cache").as_str())
);
assert_eq!(
env.get("OPENCODE_DISABLE_AUTOUPDATE").map(String::as_str),
Some("1")
);
}
#[tokio::test]
async fn launch_mcp_flag_appends_flag_and_path_to_args() {
// Test 5 — Flag { flag: "--mcp-config" } ⇒ spec.args carries the flag followed
// by the run-dir config path.
let (launch, agent, _fs, pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::flag("--mcp-config").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let spawns = pty.spawns();
assert_eq!(spawns.len(), 1);
let args = &spawns[0].args;
let pos = args
.iter()
.position(|a| a == "--mcp-config")
.expect("the MCP flag must be present in args");
assert_eq!(
args.get(pos + 1),
Some(&run_dir),
"the MCP flag is followed by the run-dir config path"
);
}
#[tokio::test]
async fn launch_mcp_env_appends_var_and_path_to_env() {
// Test 6 — Env { var: "IDEA_MCP" } ⇒ spec.env carries (IDEA_MCP, <run_dir>).
let (launch, agent, _fs, pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::env("IDEA_MCP").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let spawns = pty.spawns();
assert_eq!(spawns.len(), 1);
assert!(
spawns[0]
.env
.iter()
.any(|(k, v)| k == "IDEA_MCP" && v == &run_dir),
"spec.env must carry (IDEA_MCP, run_dir), got: {:?}",
spawns[0].env
);
}
// ---------------------------------------------------------------------------
// LaunchAgent — MCP runtime declaration (M5d, cadrage v5 §2)
// ---------------------------------------------------------------------------
/// A `LaunchAgentInput` carrying an injected [`McpRuntime`], otherwise identical
/// to [`launch_input`]. Lets the M5d tests drive the real declaration path while
/// reusing the M1 harness (`launch_fixture_with_profile`, `FakeFs` write trace).
fn launch_input_with_runtime(
agent_id: AgentId,
runtime: application::McpRuntime,
) -> LaunchAgentInput {
LaunchAgentInput {
mcp_runtime: Some(runtime),
..launch_input(agent_id)
}
}
/// Reads the single `.mcp.json` written by a launch, parsing it as JSON. Panics
/// with a clear message if zero or several were written, so an unexpected write
/// shape is surfaced rather than silently picked.
fn read_single_mcp_json(fs: &FakeFs) -> serde_json::Value {
let mcp = writes_ending_with(fs, "/.mcp.json");
assert_eq!(mcp.len(), 1, "exactly one .mcp.json must be written");
let body = String::from_utf8(mcp[0].1.clone()).unwrap();
serde_json::from_str(&body)
.unwrap_or_else(|e| panic!("written .mcp.json must be valid JSON ({e}): {body}"))
}
#[tokio::test]
async fn launch_mcp_runtime_writes_real_declaration_with_ordered_args() {
// M5d-1 — ConfigFile{".mcp.json"} + an injected McpRuntime ⇒ the written
// declaration is the REAL one: command == exe, and args == the ordered
// ["mcp-server","--endpoint",endpoint,"--project",project_id,"--requester",
// requester]. Structure-asserted via parsed JSON (not a fragile string match).
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let exe = "/abs/idea";
let endpoint = "/run/idea-mcp/abc.sock";
// project_id in the hyphen-free 32-hex `simple` form consumed by the M5c guard
// (`as_uuid().simple()` — see the coherence note / M5e smoke e2e below).
let project_id = "0123456789abcdef0123456789abcdef";
let requester = "agent-7";
let runtime = application::McpRuntime {
exe: exe.to_owned(),
endpoint: endpoint.to_owned(),
project_id: project_id.to_owned(),
requester: requester.to_owned(),
};
launch
.execute(launch_input_with_runtime(agent.id, runtime))
.await
.unwrap();
let doc = read_single_mcp_json(&fs);
let server = &doc["mcpServers"]["idea"];
assert_eq!(
server["command"].as_str(),
Some(exe),
"command must be the injected exe, got: {doc}"
);
let args: Vec<&str> = server["args"]
.as_array()
.expect("args must be a JSON array")
.iter()
.map(|v| v.as_str().expect("each arg is a JSON string"))
.collect();
assert_eq!(
args,
vec![
"mcp-server",
"--endpoint",
endpoint,
"--project",
project_id,
"--requester",
requester,
],
"args must carry the ordered mcp-server flags, got: {args:?}"
);
}
#[tokio::test]
async fn launch_mcp_runtime_special_chars_stay_valid_json() {
// M5d-2 — an exe/endpoint with a space and a backslash ⇒ the .mcp.json stays
// valid JSON (parse OK, asserted by read_single_mcp_json) and the values are
// faithfully preserved (correct escaping, no corruption).
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let exe = r"C:\Program Files\IdeA\idea.exe";
let endpoint = r"/tmp/idea mcp/a b\c.sock";
let runtime = application::McpRuntime {
exe: exe.to_owned(),
endpoint: endpoint.to_owned(),
project_id: "0123456789abcdef0123456789abcdef".to_owned(),
requester: "agent X".to_owned(),
};
launch
.execute(launch_input_with_runtime(agent.id, runtime))
.await
.unwrap();
// Parsing already proves the JSON is valid despite the special chars.
let doc = read_single_mcp_json(&fs);
let server = &doc["mcpServers"]["idea"];
assert_eq!(
server["command"].as_str(),
Some(exe),
"exe with backslashes/spaces must round-trip faithfully"
);
let args: Vec<&str> = server["args"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap())
.collect();
assert_eq!(
args.get(2).copied(),
Some(endpoint),
"endpoint with a space and a backslash must round-trip faithfully, got: {args:?}"
);
}
#[tokio::test]
async fn launch_mcp_runtime_none_writes_minimal_declaration() {
// M5d-3 — mcp_runtime = None + an MCP profile ⇒ the minimal declaration is
// written: command == "idea", args == ["mcp-server"]. Still valid JSON.
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
// launch_input has mcp_runtime: None.
launch.execute(launch_input(agent.id)).await.unwrap();
let doc = read_single_mcp_json(&fs);
let server = &doc["mcpServers"]["idea"];
assert_eq!(
server["command"].as_str(),
Some("idea"),
"the minimal declaration must use the `idea` command, got: {doc}"
);
let args: Vec<&str> = server["args"]
.as_array()
.expect("args must be a JSON array")
.iter()
.map(|v| v.as_str().unwrap())
.collect();
assert_eq!(
args,
vec!["mcp-server"],
"the minimal declaration must carry only the mcp-server subcommand, got: {args:?}"
);
}
#[tokio::test]
async fn launch_mcp_runtime_with_no_mcp_profile_writes_nothing() {
// M5d-4 — a profile WITHOUT MCP ⇒ no .mcp.json is written, even though a
// runtime is supplied (unchanged from M1: mcp == None short-circuits).
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture(
ContextInjection::convention_file("CLAUDE.md").unwrap(),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let runtime = application::McpRuntime {
exe: "/abs/idea".to_owned(),
endpoint: "/run/idea-mcp/abc.sock".to_owned(),
project_id: "0123456789abcdef0123456789abcdef".to_owned(),
requester: "agent-7".to_owned(),
};
launch
.execute(launch_input_with_runtime(agent.id, runtime))
.await
.unwrap();
assert!(
writes_ending_with(&fs, "/.mcp.json").is_empty(),
"no MCP config file when the profile carries no McpCapability"
);
}
#[tokio::test]
async fn launch_mcp_runtime_clobbers_stale_config_with_fresh_declaration() {
// M5d-5 — with a real injected runtime, a pre-existing .mcp.json MUST be
// regenerated and CLOBBERED on every (re)launch: its `command` (the IdeA exe
// path) and endpoint drift between runs (the AppImage internal mount path
// changes at each remount/reboot), so a stale declaration would point the bridge
// at a dead binary/socket. `.mcp.json` is IdeA-managed, so clobbering is safe.
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
// A stale file already on disk (e.g. written by a previous run pointing at a
// now-dead AppImage mount).
fs.mark_existing(&format!("{run_dir}/.mcp.json"));
let exe = "/abs/idea";
let endpoint = "/run/idea-mcp/abc.sock";
let runtime = application::McpRuntime {
exe: exe.to_owned(),
endpoint: endpoint.to_owned(),
project_id: "0123456789abcdef0123456789abcdef".to_owned(),
requester: "agent-7".to_owned(),
};
launch
.execute(launch_input_with_runtime(agent.id, runtime))
.await
.unwrap();
// The fresh declaration is written despite the pre-existing file, and it carries
// the current exe path / endpoint.
let doc = read_single_mcp_json(&fs);
let server = &doc["mcpServers"]["idea"];
assert_eq!(
server["command"].as_str(),
Some(exe),
"a stale .mcp.json must be clobbered with the fresh exe path, got: {doc}"
);
let args: Vec<&str> = server["args"]
.as_array()
.expect("args must be a JSON array")
.iter()
.map(|v| v.as_str().unwrap())
.collect();
assert_eq!(
args.get(2).copied(),
Some(endpoint),
"the clobbered declaration must carry the fresh endpoint, got: {args:?}"
);
}
#[tokio::test]
async fn launch_mcp_runtime_none_is_non_clobbering() {
// M5d-5b — WITHOUT a runtime (orchestrator / hot-swap / tests) only the degraded
// minimal declaration is available, so a pre-existing .mcp.json must NOT be
// overwritten: we never replace a real declaration with the minimal one.
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
fs.mark_existing(&format!("{run_dir}/.mcp.json"));
// launch_input has mcp_runtime: None.
launch.execute(launch_input(agent.id)).await.unwrap();
assert!(
writes_ending_with(&fs, "/.mcp.json").is_empty(),
"without a runtime, an existing .mcp.json must not be clobbered with the minimal decl"
);
}
#[tokio::test]
async fn launch_mcp_runtime_remount_clobbers_with_run_specific_facts() {
// M5d-5c (QA) — direct reproduction of the AppImage-remount bug: across two
// independent app sessions (= two reboots, each with a *different* mount path
// and a *different* loopback socket), each launch must clobber a pre-existing
// stale `.mcp.json` with the facts of THAT run. This proves the file is rebuilt
// per-launch from the live runtime — never frozen on a previous run's dead
// binary/socket. Two fixtures are used on purpose: relaunching the *same* live
// agent would short-circuit through the reattach guard (no respawn), so it
// would not exercise a second `apply_mcp_config`.
let launch_once = |exe: &'static str, endpoint: &'static str| async move {
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile_with_mcp(pid(9), McpConfigStrategy::config_file(".mcp.json").unwrap()),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
);
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
// A stale declaration left by the previous boot is already on disk.
fs.mark_existing(&format!("{run_dir}/.mcp.json"));
let runtime = application::McpRuntime {
exe: exe.to_owned(),
endpoint: endpoint.to_owned(),
project_id: "0123456789abcdef0123456789abcdef".to_owned(),
requester: "agent-7".to_owned(),
};
launch
.execute(launch_input_with_runtime(agent.id, runtime))
.await
.unwrap();
let doc = read_single_mcp_json(&fs);
let server = &doc["mcpServers"]["idea"];
let command = server["command"].as_str().unwrap().to_owned();
let args: Vec<String> = server["args"]
.as_array()
.expect("args must be a JSON array")
.iter()
.map(|v| v.as_str().unwrap().to_owned())
.collect();
(command, args)
};
// Boot #1: mount path A + socket A.
let exe_a = "/tmp/.mount_IdeA_AAA/idea";
let endpoint_a = "/run/idea-mcp/boot-a.sock";
let (command_a, args_a) = launch_once(exe_a, endpoint_a).await;
assert_eq!(command_a, exe_a, "boot #1 must carry mount path A");
assert_eq!(args_a.get(2).map(String::as_str), Some(endpoint_a));
// Boot #2: a *new* mount path + a *new* socket (the very drift that caused the
// bug). The declaration must follow the live facts, not the previous boot's.
let exe_b = "/tmp/.mount_IdeA_BBB/idea";
let endpoint_b = "/run/idea-mcp/boot-b.sock";
let (command_b, args_b) = launch_once(exe_b, endpoint_b).await;
assert_eq!(command_b, exe_b, "boot #2 must carry the NEW mount path");
assert_eq!(args_b.get(2).map(String::as_str), Some(endpoint_b));
// And nothing from the stale boot #1 leaks into the boot #2 declaration.
assert_ne!(
command_b, exe_a,
"boot #2 must not reuse boot #1's dead exe"
);
assert!(
!args_b.iter().any(|a| a == endpoint_a),
"boot #2 must not reuse boot #1's dead endpoint, got: {args_b:?}"
);
}
#[test]
fn mcp_runtime_project_id_uses_simple_uuid_form() {
// M5d-6 (coherence, pure) — app-tauri builds the McpRuntime.project_id as
// `project.id.as_uuid().simple().to_string()` (commands.rs::launch_agent),
// i.e. the hyphen-free 32-hex `simple` form the M5c handshake guard
// (`serve_peer`) compares against. The McpRuntime construction is inlined in
// the Tauri command (not an extractable pure fn), so we cannot unit-test the
// wiring here without an AppState. Instead we PIN the format contract the M5d
// tests above rely on, and flag that the end-to-end injection coherence
// (--endpoint == mcp_endpoint(..).as_cli_arg() and --project == this form) is
// exercised by the M5e smoke e2e.
let uuid = Uuid::from_u128(0x0123_4567_89ab_cdef_0123_4567_89ab_cdef);
let simple = uuid.as_simple().to_string();
assert_eq!(simple, "0123456789abcdef0123456789abcdef");
assert!(
!simple.contains('-') && simple.len() == 32,
"the `simple` form is hyphen-free 32-hex, matching the project_id used in the M5d tests"
);
}
// ---------------------------------------------------------------------------
// LaunchAgent — session resume (T4)
// ---------------------------------------------------------------------------
/// Builds a stdin profile carrying a [`SessionStrategy`] (assign + resume flags).
fn profile_with_session(
id: ProfileId,
assign_flag: Option<&str>,
resume_flag: &str,
) -> AgentProfile {
let session =
SessionStrategy::new(assign_flag.map(str::to_owned), resume_flag.to_owned()).unwrap();
AgentProfile::new(
id,
"Claude Code",
"claude",
Vec::new(),
ContextInjection::stdin(),
Some("claude --version".to_owned()),
"{agentRunDir}",
Some(session),
)
.unwrap()
}
#[tokio::test]
async fn launch_first_time_with_assign_flag_mints_and_exposes_conversation_id() {
// Fresh cell (conversation_id = None), profile WITH an assign_flag.
let (launch, agent, _fs, _pty, _bus, _sessions, _tr, session) = launch_fixture_with_profile(
profile_with_session(pid(9), Some("--session-id"), "--resume"),
Some(ContextInjectionPlan::Stdin),
);
let out = launch
.execute(launch_input(agent.id))
.await
.expect("launch");
// SeqIds yields Uuid::from_u128(1) on its first call.
let expected = Uuid::from_u128(1).to_string();
// The use case exposes the assigned id (caller persists it on the leaf).
assert_eq!(
out.assigned_conversation_id.as_deref(),
Some(expected.as_str())
);
// The runtime received an Assign plan carrying exactly that id.
assert_eq!(
*session.lock().unwrap(),
Some(SessionPlan::Assign {
conversation_id: expected
}),
);
}
#[tokio::test]
async fn launch_reopen_with_existing_conversation_id_resumes_without_new_id() {
// The cell already carries a conversation id ⇒ Resume, no new id minted.
let (launch, agent, _fs, _pty, _bus, _sessions, _tr, session) = launch_fixture_with_profile(
profile_with_session(pid(9), Some("--session-id"), "--resume"),
Some(ContextInjectionPlan::Stdin),
);
let mut input = launch_input(agent.id);
input.conversation_id = Some("conv-existing".to_owned());
let out = launch.execute(input).await.expect("launch");
// Nothing newly assigned (the id pre-existed): caller has nothing to persist.
assert_eq!(out.assigned_conversation_id, None);
// Resume plan with the existing id; SeqIds was never consulted.
assert_eq!(
*session.lock().unwrap(),
Some(SessionPlan::Resume {
conversation_id: "conv-existing".to_owned()
}),
);
}
#[tokio::test]
async fn launch_profile_without_session_block_passes_none() {
// Non-regression: a profile with no session block behaves exactly as before.
let (launch, agent, _fs, _pty, _bus, _sessions, _tr, session) =
launch_fixture(ContextInjection::stdin(), Some(ContextInjectionPlan::Stdin));
let out = launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert_eq!(out.assigned_conversation_id, None);
assert_eq!(*session.lock().unwrap(), Some(SessionPlan::None));
}
#[tokio::test]
async fn launch_degraded_mode_without_assign_flag_first_launch_is_none() {
// Profile HAS a session block but NO assign_flag (degraded): a first launch
// (no cell id) must NOT mint an id and must pass SessionPlan::None.
let (launch, agent, _fs, _pty, _bus, _sessions, _tr, session) = launch_fixture_with_profile(
profile_with_session(pid(9), None, "--continue"),
Some(ContextInjectionPlan::Stdin),
);
let out = launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert_eq!(
out.assigned_conversation_id, None,
"degraded mode mints no id"
);
assert_eq!(*session.lock().unwrap(), Some(SessionPlan::None));
}
// ---------------------------------------------------------------------------
// LaunchAgent — handoff resume injection (lot P7)
// ---------------------------------------------------------------------------
use application::HandoffProvider;
use domain::{ConversationId, ConversationParty, Handoff, HandoffStore, TurnId};
/// In-memory [`HandoffStore`] for the P7 launch tests: holds at most one handoff
/// per [`ConversationId`]. `load` returns `Ok(None)` for an unknown conversation
/// (the store-without-handoff case), so the best-effort `resolve_handoff` degrades
/// to "no section".
#[derive(Clone, Default)]
struct FakeHandoffStore(Arc<Mutex<HashMap<ConversationId, Handoff>>>);
impl FakeHandoffStore {
fn with(conv: ConversationId, handoff: Handoff) -> Self {
let me = Self::default();
me.0.lock().unwrap().insert(conv, handoff);
me
}
}
#[async_trait]
impl HandoffStore for FakeHandoffStore {
async fn load(&self, conversation: ConversationId) -> Result<Option<Handoff>, StoreError> {
Ok(self.0.lock().unwrap().get(&conversation).cloned())
}
async fn save(&self, conversation: ConversationId, handoff: Handoff) -> Result<(), StoreError> {
self.0.lock().unwrap().insert(conversation, handoff);
Ok(())
}
}
/// [`HandoffProvider`] that hands back the same store for any root (the launch
/// tests use a single project root).
#[derive(Clone)]
struct FakeHandoffProvider(Arc<dyn HandoffStore>);
impl HandoffProvider for FakeHandoffProvider {
fn handoff_store_for(&self, _root: &ProjectPath) -> Option<Arc<dyn HandoffStore>> {
Some(Arc::clone(&self.0))
}
}
/// Builds a `conventionFile` LaunchAgent wired with an **optional** handoff
/// provider, returning the launcher and the recording fs (the only port the P7
/// resume assertions read). When `provider` is `None`, no handoff is wired —
/// exactly the legacy launch path.
fn launch_with_handoff(provider: Option<Arc<dyn HandoffProvider>>) -> (LaunchAgent, Agent, FakeFs) {
let injection = ContextInjection::convention_file("CLAUDE.md").unwrap();
let agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&agent, "# ctx body");
let profiles = FakeProfiles::new(vec![profile(pid(9), injection)]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let mut launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(
Arc::clone(&tr),
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
}),
)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::new(TerminalSessions::new()),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
if let Some(p) = provider {
launch = launch.with_handoff_provider(p);
}
(launch, agent, fs)
}
fn conv_id(n: u128) -> ConversationId {
ConversationId::from_uuid(Uuid::from_u128(n))
}
fn handoff_for(summary: &str, objective: Option<&str>) -> Handoff {
Handoff::new(
summary,
TurnId::from_uuid(Uuid::from_u128(7)),
objective.map(ToOwned::to_owned),
)
}
/// Reads the (single) convention file written by the launch.
fn convention_doc(fs: &FakeFs) -> String {
let writes = fs.context_writes();
assert_eq!(writes.len(), 1, "exactly one convention file");
String::from_utf8(writes[0].1.clone()).unwrap()
}
#[tokio::test]
async fn launch_injects_handoff_resume_when_provider_and_conversation_match() {
// Happy path: a wired provider, a cell conversation_id that parses to a known
// ConversationId with a stored handoff ⇒ the convention file carries the
// `# Reprise de la conversation` section (objective + summary).
let conv = conv_id(123);
let store = FakeHandoffStore::with(
conv,
handoff_for("On a terminé l'étape A.", Some("Finir le lot P7")),
);
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
// The cell carries the conversation id of the known pair (UUID string form).
input.conversation_id = Some(Uuid::from_u128(123).to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
doc.contains("# Reprise de la conversation"),
"resume section materialised in the run dir: {doc}"
);
assert!(
doc.contains("**Objectif :** Finir le lot P7"),
"objective injected: {doc}"
);
assert!(
doc.contains("On a terminé l'étape A."),
"summary injected: {doc}"
);
}
#[tokio::test]
async fn launch_without_handoff_provider_omits_resume_section() {
// No provider wired (legacy path) ⇒ no resume section, even with a cell
// conversation_id present.
let (launch, agent, fs) = launch_with_handoff(None);
let mut input = launch_input(agent.id);
input.conversation_id = Some(Uuid::from_u128(123).to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
!doc.contains("# Reprise de la conversation"),
"no provider ⇒ no resume section: {doc}"
);
}
#[tokio::test]
async fn launch_with_no_conversation_id_omits_resume_section() {
// Provider wired and a handoff stored, but the cell has NO conversation_id ⇒
// nothing to resolve ⇒ no section, launch unaffected.
let store = FakeHandoffStore::with(conv_id(123), handoff_for("x", Some("y")));
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
// launch_input leaves conversation_id = None.
launch
.execute(launch_input(agent.id))
.await
.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
!doc.contains("# Reprise de la conversation"),
"no conversation_id ⇒ no resume section: {doc}"
);
}
#[tokio::test]
async fn launch_with_invalid_uuid_conversation_id_omits_resume_section() {
// A non-UUID conversation_id (legacy CLI id / corrupt data) must NOT crash the
// launch and must inject no resume section (parse failure ⇒ best-effort None).
let store = FakeHandoffStore::with(conv_id(123), handoff_for("x", Some("y")));
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
input.conversation_id = Some("not-a-uuid".to_owned());
launch
.execute(input)
.await
.expect("invalid uuid must not fail the launch");
let doc = convention_doc(&fs);
assert!(
!doc.contains("# Reprise de la conversation"),
"invalid uuid ⇒ no resume section: {doc}"
);
}
#[tokio::test]
async fn launch_opencode_omits_api_key_when_profile_has_none() {
let profile = profile(
pid(91),
ContextInjection::convention_file("AGENTS.md").unwrap(),
)
.with_structured_adapter(StructuredAdapter::OpenCode)
.with_opencode(
OpenCodeConfig::new(
"http://localhost:8080/v1",
None,
"qwen3-coder-30b",
None,
None,
)
.unwrap(),
)
.with_mcp(McpCapability::new(
McpConfigStrategy::open_code_config("opencode.json").unwrap(),
McpTransport::Stdio,
));
let (launch, agent, fs, _pty, _bus, _sessions, _tr, _session) = launch_fixture_with_profile(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
);
launch.execute(launch_input(agent.id)).await.unwrap();
let opencode = writes_ending_with(&fs, "/opencode.json");
assert_eq!(opencode.len(), 1, "one OpenCode config is written");
let body: serde_json::Value = serde_json::from_slice(&opencode[0].1).unwrap();
assert_eq!(
body["provider"]["llamacpp"]["options"]["baseURL"],
"http://localhost:8080/v1"
);
assert!(
body["provider"]["llamacpp"]["options"]
.as_object()
.expect("llamacpp options are an object")
.get("apiKey")
.is_none(),
"apiKey must be omitted, not serialized as null"
);
}
#[tokio::test]
async fn launch_with_store_without_handoff_omits_resume_section() {
// Provider wired, valid conversation_id, but the store holds NO handoff for it
// (load ⇒ Ok(None)) ⇒ no section, launch succeeds.
let store = FakeHandoffStore::default(); // empty
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
input.conversation_id = Some(Uuid::from_u128(999).to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
!doc.contains("# Reprise de la conversation"),
"store without handoff ⇒ no resume section: {doc}"
);
}
/// LS5 — un `handoff.md` **legacy surdimensionné** (écrit avant LS5, non borné) chargé
/// au lancement ⇒ la borne défensive de `resolve_handoff` ramène le `summary_md` injecté
/// sous [`domain::HANDOFF_SUMMARY_MAX_CHARS`], sans migration de données ni crash. On
/// vérifie sur la section `# Reprise de la conversation` réellement écrite dans le run dir.
#[tokio::test]
async fn launch_bounds_oversize_legacy_handoff_resume_section() {
// Handoff legacy géant : 500 lignes-tours bien formées, objectif absent (⇒ la section
// injectée = le seul summary, comparable directement au plafond).
let mut summary = String::new();
for i in 0..500u32 {
if i > 0 {
summary.push('\n');
}
summary.push_str(&format!(
"- **Response:** tour numero {i} {}",
"x".repeat(30)
));
}
assert!(
summary.chars().count() > domain::HANDOFF_SUMMARY_MAX_CHARS,
"pré-condition : le handoff legacy dépasse le plafond ({})",
summary.chars().count()
);
let conv = conv_id(123);
let store = FakeHandoffStore::with(conv, handoff_for(&summary, None));
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
input.conversation_id = Some(Uuid::from_u128(123).to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
// La section de reprise est la DERNIÈRE du document (ordre composeur). Son contenu
// (après l'entête) = le summary injecté, qui doit être borné.
let section = doc
.split("# Reprise de la conversation\n\n")
.nth(1)
.expect("resume section present")
.trim_end();
assert!(
section.chars().count() <= domain::HANDOFF_SUMMARY_MAX_CHARS,
"summary legacy injecté borné, obtenu {}",
section.chars().count()
);
// Distillation : les lignes les plus récentes survivent, les plus anciennes droppées.
assert!(section.contains("tour numero 499"), "le plus récent reste");
assert!(
!section.contains("tour numero 0 "),
"le plus ancien droppé : {section}"
);
// Reparsable : chaque ligne conservée garde le préfixe de tour.
for line in section.lines().filter(|l| !l.is_empty()) {
assert!(line.starts_with("- **"), "ligne reparsable : {line}");
}
}
/// LS5 — zéro régression : un handoff **normal** (sous le plafond) est injecté
/// **verbatim** (la borne est l'identité), objectif et summary intacts.
#[tokio::test]
async fn launch_normal_handoff_injects_summary_verbatim() {
let summary = "**Objectif :** livrer LS5\n\n- **Prompt:** a\n- **Response:** b";
assert!(summary.chars().count() <= domain::HANDOFF_SUMMARY_MAX_CHARS);
let conv = conv_id(123);
let store = FakeHandoffStore::with(conv, handoff_for(summary, Some("livrer LS5")));
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
input.conversation_id = Some(Uuid::from_u128(123).to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
// Le summary normal est injecté tel quel (la borne ne l'a pas touché).
assert!(
doc.contains(summary),
"handoff normal injecté verbatim (borne = identité) : {doc}"
);
assert!(doc.contains("**Objectif :** livrer LS5"));
}
// ---------------------------------------------------------------------------
// Bloc 2 — cohérence end-to-end de la clé de conversation (LE test de vérité).
//
// Round-trip réel « sauve sous resolve / charge au lancement » :
// 1. SAUVEGARDE — côté orchestrateur, le handoff est rangé sous la clé que
// `resolve_conversation(None, agent)` renvoie ; avec un registre câblé c'est
// `reg.resolve(User, agent).id`, qui (scellé Bloc 1 :
// `resolve_id_equals_for_pair_user_agent`) vaut `ConversationId::for_pair(User,
// agent)`. On dérive donc la clé de SAUVEGARDE via ce **même** `for_pair` —
// sans tirer `infrastructure` comme dépendance de la couche application (règle
// hexagonale ; l'égalité registre↔for_pair est prouvée côté infra).
// 2. PERSISTANCE (P8a) — au 1er lancement d'une cellule neuve, IdeA **persiste**
// `for_pair(User, agent)` sur `LeafCell.conversation_id`. Donc à la réouverture
// la cellule **porte** cette clé.
// 3. CHARGEMENT (P7) — `resolve_handoff` charge le handoff sous
// `LaunchAgentInput.conversation_id` (la clé persistée que la cellule porte).
//
// Ce test joue (2)+(3) fidèlement : la cellule porte la clé que P8a a persistée
// (`for_pair`), et on prouve qu'elle retrouve le handoff sauvé sous la clé de (1).
// C'est l'invariant que Main a rattrapé : si l'une des trois clés dérivait, la
// section de reprise serait absente et ce test échouerait.
// ---------------------------------------------------------------------------
#[tokio::test]
async fn reopened_cell_loads_handoff_saved_under_resolve_key_end_to_end() {
let agent_party = ConversationParty::agent(aid(1)); // l'agent du harnais.
// (1) Clé de SAUVEGARDE = resolve_conversation(None, agent) avec registre câblé
// == for_pair(User, agent) (égalité scellée Bloc 1, côté infrastructure).
let save_key = ConversationId::for_pair(ConversationParty::User, agent_party);
// (2) Clé que P8a persiste sur la cellule neuve, donc portée à la réouverture.
let persisted_on_leaf = ConversationId::for_pair(ConversationParty::User, agent_party);
assert_eq!(
save_key, persisted_on_leaf,
"préalable end-to-end : clé sauvegarde (resolve) == clé persistée (P8a)"
);
let store = FakeHandoffStore::with(
save_key,
handoff_for("État au dernier tour : lot P8a câblé.", Some("Sceller §19")),
);
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
// (3) Réouverture : la cellule porte la clé que P8a avait persistée.
let mut input = launch_input(agent.id);
input.conversation_id = Some(persisted_on_leaf.to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
doc.contains("# Reprise de la conversation"),
"clé de chargement (P7, clé persistée par P8a) == clé de sauvegarde (resolve) : \
le handoff doit être retrouvé. doc: {doc}"
);
assert!(
doc.contains("**Objectif :** Sceller §19"),
"objectif du handoff sauvé sous la clé de résolution injecté: {doc}"
);
assert!(
doc.contains("État au dernier tour : lot P8a câblé."),
"résumé du handoff sauvé sous la clé de résolution injecté: {doc}"
);
}
/// Contre-épreuve : un handoff rangé sous une **autre** clé (un agent différent) ne
/// doit PAS être chargé — garantit que la réussite du test ci-dessus tient à
/// l'**égalité** des clés, pas à un chargement inconditionnel.
#[tokio::test]
async fn reopened_cell_does_not_load_handoff_saved_under_a_different_pair_key() {
let agent_party = ConversationParty::agent(aid(1)); // agent du harnais.
// La cellule porte SA clé de paire (celle que P8a aurait persistée)…
let leaf_key = ConversationId::for_pair(ConversationParty::User, agent_party);
// …mais le handoff est rangé sous la clé d'une AUTRE paire (autre agent).
let other_key =
ConversationId::for_pair(ConversationParty::User, ConversationParty::agent(aid(2)));
assert_ne!(
leaf_key, other_key,
"préalable : deux clés de paire distinctes"
);
let store = FakeHandoffStore::with(other_key, handoff_for("ne doit pas fuiter", Some("X")));
let provider = Arc::new(FakeHandoffProvider(Arc::new(store))) as Arc<dyn HandoffProvider>;
let (launch, agent, fs) = launch_with_handoff(Some(provider));
let mut input = launch_input(agent.id);
input.conversation_id = Some(leaf_key.to_string());
launch.execute(input).await.expect("launch succeeds");
let doc = convention_doc(&fs);
assert!(
!doc.contains("# Reprise de la conversation"),
"handoff d'une autre paire ⇒ aucune reprise (pas de fuite de clé): {doc}"
);
}
// ===========================================================================
// LP3-3 — permission projection wiring (apply_permission_projection + registry
// + MCP decoupling). FS-mocked, projectors are faithful test doubles (the real
// translation is covered by the infra LP3-2 tests; application must stay
// dependency-free of `infrastructure`).
// ===========================================================================
const CLAUDE_SEED_REL: &str = "/.claude/settings.local.json";
const CODEX_CONFIG_REL: &str = "/.codex/config.toml";
/// In-memory [`PermissionStore`] returning a fixed document (LP3-3 wiring tests).
struct FakePermissionStore(ProjectPermissions);
#[async_trait]
impl PermissionStore for FakePermissionStore {
async fn load_permissions(&self, _project: &Project) -> Result<ProjectPermissions, StoreError> {
Ok(self.0.clone())
}
async fn save_permissions(
&self,
_project: &Project,
_permissions: &ProjectPermissions,
) -> Result<(), StoreError> {
Ok(())
}
}
/// Faithful Claude projector double: emits a single owned `Replace` settings file
/// whose `defaultMode` mirrors the real posture→mode mapping (Allow→bypass,
/// Ask→acceptEdits, Deny→plan), and embeds the project root verbatim. `eff == None`
/// ⇒ empty projection.
struct FakeClaudeProjector;
impl PermissionProjector for FakeClaudeProjector {
fn key(&self) -> ProjectorKey {
ProjectorKey::Claude
}
fn project(
&self,
eff: Option<&EffectivePermissions>,
ctx: &ProjectionContext,
) -> PermissionProjection {
let Some(eff) = eff else {
return PermissionProjection::empty();
};
let mode = match eff.fallback() {
Posture::Deny => "plan",
Posture::Ask => "acceptEdits",
Posture::Allow => "bypassPermissions",
};
let contents = format!(
"{{\"permissions\":{{\"defaultMode\":\"{mode}\",\"additionalDirectories\":[\"{}\"]}}}}\n",
ctx.project_root
);
PermissionProjection {
files: vec![ProjectedFile::Replace {
rel_path: ".claude/settings.local.json".to_owned(),
contents,
}],
args: Vec::new(),
env: Vec::new(),
}
}
fn owned_replace_paths(&self) -> Vec<String> {
vec![".claude/settings.local.json".to_owned()]
}
}
/// Faithful Codex projector double: emits a co-owned `MergeToml` over the two
/// managed keys + the matching `--sandbox`/`--ask-for-approval` args, both derived
/// from the posture exactly like the real projector. Workspace-write postures also
/// add the project root as a writable directory (`--add-dir`). `eff == None` ⇒
/// empty.
struct FakeCodexProjector;
impl FakeCodexProjector {
fn modes(fallback: Posture) -> (&'static str, &'static str) {
match fallback {
Posture::Deny => ("read-only", "on-request"),
Posture::Ask => ("workspace-write", "on-request"),
Posture::Allow => ("workspace-write", "never"),
}
}
}
impl PermissionProjector for FakeCodexProjector {
fn key(&self) -> ProjectorKey {
ProjectorKey::Codex
}
fn project(
&self,
eff: Option<&EffectivePermissions>,
ctx: &ProjectionContext,
) -> PermissionProjection {
let Some(eff) = eff else {
return PermissionProjection::empty();
};
let (sandbox, approval) = Self::modes(eff.fallback());
let contents = format!("sandbox_mode = \"{sandbox}\"\napproval_policy = \"{approval}\"\n");
let mut args = vec![
"--sandbox".to_owned(),
sandbox.to_owned(),
"--ask-for-approval".to_owned(),
approval.to_owned(),
];
if sandbox == "workspace-write" {
args.push("--add-dir".to_owned());
args.push(ctx.project_root.to_owned());
}
PermissionProjection {
files: vec![ProjectedFile::MergeToml {
rel_path: ".codex/config.toml".to_owned(),
managed_tables: Vec::new(),
managed_keys: vec!["sandbox_mode".to_owned(), "approval_policy".to_owned()],
contents,
}],
args,
env: Vec::new(),
}
}
fn owned_replace_paths(&self) -> Vec<String> {
Vec::new()
}
}
/// A registry carrying both faithful projector doubles.
fn full_registry() -> Arc<PermissionProjectorRegistry> {
Arc::new(
PermissionProjectorRegistry::new()
.with(Arc::new(FakeClaudeProjector))
.with(Arc::new(FakeCodexProjector)),
)
}
/// A project document whose project-level fallback is `posture` (no agent
/// override) ⇒ `resolve_for` yields `Some(eff)` with that fallback.
fn perm_doc(posture: Posture) -> ProjectPermissions {
ProjectPermissions::new(Some(PermissionSet::new(vec![], posture)), Vec::new())
}
/// Builds a `codex` profile (convention `AGENTS.md`) with the given customiser, so
/// the structured-adapter / projector / mcp variants can be exercised.
fn codex_profile() -> AgentProfile {
AgentProfile::new(
pid(9),
"OpenAI Codex CLI",
"codex",
Vec::new(),
ContextInjection::convention_file("AGENTS.md").unwrap(),
Some("codex --version".to_owned()),
"{agentRunDir}",
None,
)
.unwrap()
}
/// Wires a `LaunchAgent` over the fakes with an optional projector registry and an
/// optional permission document. Returns the use case + the seeded agent + the
/// recording fs/pty so the projection writes and folded args can be asserted.
fn launch_with_projection(
profile: AgentProfile,
plan: Option<ContextInjectionPlan>,
registry: Option<Arc<PermissionProjectorRegistry>>,
perm_doc: Option<ProjectPermissions>,
) -> (LaunchAgent, Agent, FakeFs, FakePty, Arc<TerminalSessions>) {
let agent = scratch_agent(aid(1), "Backend", "agents/backend.md", profile.id);
let contexts = FakeContexts::with_agent(&agent, "# ctx body");
let profiles = FakeProfiles::new(vec![profile]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let sessions = Arc::new(TerminalSessions::new());
let mut launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(Arc::clone(&tr), plan)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::clone(&sessions),
Arc::new(SpyBus::default()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
);
if let Some(doc) = perm_doc {
launch = launch.with_permission_store(Arc::new(FakePermissionStore(doc)));
}
if let Some(reg) = registry {
launch = launch.with_permission_projectors(reg);
}
(launch, agent, fs, pty, sessions)
}
fn convention_file_plan() -> Option<ContextInjectionPlan> {
Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
})
}
// ---- (1) projector key selection -------------------------------------------
/// (1a) An explicit `projector = Some(Claude)` is honoured even when the heuristic
/// would not fire (here the convention file is GEMINI.md): the explicit field wins.
#[tokio::test]
async fn projection_selects_claude_from_explicit_projector_field() {
let profile = profile(
pid(9),
ContextInjection::convention_file("GEMINI.md").unwrap(),
)
.with_projector(ProjectorKey::Claude);
let (launch, agent, fs, _pty, _s) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "GEMINI.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
let seeds = fs.writes_ending_with(CLAUDE_SEED_REL);
assert_eq!(seeds.len(), 1, "the Claude projector ran (explicit key)");
assert!(
fs.writes_ending_with(CODEX_CONFIG_REL).is_empty(),
"the Codex projector must NOT run"
);
}
/// (1b) Legacy fallback: no `projector` field, but a `CLAUDE.md` convention file ⇒
/// Claude projector is selected.
#[tokio::test]
async fn projection_falls_back_to_claude_from_convention_file() {
let profile = profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
);
assert!(
profile.projector.is_none(),
"no explicit projector (legacy)"
);
let (launch, agent, fs, _pty, _s) = launch_with_projection(
profile,
convention_file_plan(),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert_eq!(
fs.writes_ending_with(CLAUDE_SEED_REL).len(),
1,
"CLAUDE.md heuristic selects the Claude projector"
);
}
/// (1c) Legacy fallback: no `projector` field, but `StructuredAdapter::Codex` ⇒
/// Codex projector is selected.
#[tokio::test]
async fn projection_falls_back_to_codex_from_structured_adapter() {
let profile = codex_profile().with_structured_adapter(StructuredAdapter::Codex);
assert!(
profile.projector.is_none(),
"no explicit projector (legacy)"
);
let (launch, agent, fs, pty, _s) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert_eq!(
fs.writes_ending_with(CODEX_CONFIG_REL).len(),
1,
"Codex structured adapter selects the Codex projector"
);
assert!(
fs.writes_ending_with(CLAUDE_SEED_REL).is_empty(),
"the Claude projector must NOT run"
);
// Args were folded into the spawned spec.
assert!(
pty.spawns()[0].args.contains(&"--sandbox".to_owned()),
"sandbox args folded into spec"
);
}
/// (1d) A non-projectable profile (no projector, no CLAUDE.md, no Codex signal) ⇒
/// no projection at all, even with a full registry and a posed policy.
#[tokio::test]
async fn projection_noop_for_unprojectable_profile() {
let profile = profile(
pid(9),
ContextInjection::convention_file("GEMINI.md").unwrap(),
);
let (launch, agent, fs, pty, _s) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "GEMINI.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert!(fs.writes_ending_with(CLAUDE_SEED_REL).is_empty());
assert!(fs.writes_ending_with(CODEX_CONFIG_REL).is_empty());
assert!(
!pty.spawns()[0].args.contains(&"--sandbox".to_owned()),
"no projected args either"
);
}
// ---- (2) Replace clobber ---------------------------------------------------
/// (2) A `Replace` file is **clobbered** (rewritten) on every (re)launch: launching
/// the same Claude agent twice (with the session removed in between to clear the
/// singleton guard) writes the owned seed twice to the SAME path — proving the
/// inversion vs. the MCP non-clobbering regime (which skips when the file exists).
#[tokio::test]
async fn claude_replace_seed_is_clobbered_on_relaunch() {
let profile = profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)
.with_projector(ProjectorKey::Claude);
let (launch, agent, fs, _pty, sessions) = launch_with_projection(
profile,
convention_file_plan(),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let seed_path = format!("{run_dir}{CLAUDE_SEED_REL}");
// Pre-mark the seed as already existing: a Replace must write anyway (clobber).
fs.mark_existing(&seed_path);
// First launch, then simulate the agent exiting so a fresh relaunch is allowed.
launch
.execute(launch_input(agent.id))
.await
.expect("launch 1");
sessions.remove(&sid(777));
launch
.execute(launch_input(agent.id))
.await
.expect("launch 2");
let seeds = fs.writes_ending_with(CLAUDE_SEED_REL);
assert_eq!(
seeds.len(),
2,
"the owned Replace seed is rewritten on each launch (clobber), got {seeds:?}"
);
assert!(
seeds.iter().all(|(p, _)| p == &seed_path),
"both writes target the same seed path"
);
}
// ---- (3) MergeToml: upsert managed keys, preserve unmanaged, idempotent -----
/// (3) Projecting onto a pre-existing `.codex/config.toml` upserts the two managed
/// keys while preserving an unmanaged user key; a second projection does not
/// duplicate the managed keys (idempotence).
#[tokio::test]
async fn codex_mergetoml_upserts_managed_keys_and_preserves_unmanaged() {
let profile = codex_profile().with_projector(ProjectorKey::Codex);
let (launch, agent, fs, _pty, sessions) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Allow)),
);
let run_dir = format!("/home/me/proj/.ideai/run/{}", agent.id);
let cfg_path = format!("{run_dir}{CODEX_CONFIG_REL}");
// Pre-existing config with an unmanaged top-level key + an unmanaged table.
fs.seed_read(
&cfg_path,
"user_key = \"keep-me\"\n[mcp_servers.idea]\ncommand = \"idea\"\n",
);
// First projection.
launch
.execute(launch_input(agent.id))
.await
.expect("launch 1");
let first = String::from_utf8(
fs.writes_ending_with(CODEX_CONFIG_REL)
.last()
.expect("a codex config write")
.1
.clone(),
)
.unwrap();
assert!(
first.contains("user_key = \"keep-me\""),
"unmanaged key preserved: {first}"
);
assert!(
first.contains("[mcp_servers.idea]"),
"unmanaged table preserved: {first}"
);
assert!(
first.contains("sandbox_mode = \"workspace-write\""),
"managed sandbox_mode upserted: {first}"
);
assert!(
first.contains("approval_policy = \"never\""),
"managed approval_policy upserted: {first}"
);
// Second projection (relaunch): managed keys are replaced in place, not dup'd.
sessions.remove(&sid(777));
launch
.execute(launch_input(agent.id))
.await
.expect("launch 2");
let second = String::from_utf8(
fs.writes_ending_with(CODEX_CONFIG_REL)
.last()
.unwrap()
.1
.clone(),
)
.unwrap();
assert_eq!(
second.matches("sandbox_mode =").count(),
1,
"idempotent: no duplicate sandbox_mode after a second projection: {second}"
);
assert_eq!(
second.matches("approval_policy =").count(),
1,
"idempotent: no duplicate approval_policy: {second}"
);
assert!(
second.contains("user_key = \"keep-me\""),
"unmanaged key still preserved"
);
}
// ---- (4) args/env fold into the spawned spec --------------------------------
/// (4) The projection's launch args are folded into the spec inherited by the
/// (PTY) spawn, in order, alongside the projected config file.
#[tokio::test]
async fn codex_projection_folds_args_into_spawn_spec() {
let profile = codex_profile().with_projector(ProjectorKey::Codex);
let (launch, agent, _fs, pty, _s) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Ask)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
let args = &pty.spawns()[0].args;
// Ask ⇒ workspace-write / on-request, in CLI order.
let pos = args
.windows(2)
.position(|w| w == ["--sandbox".to_owned(), "workspace-write".to_owned()]);
assert!(
pos.is_some(),
"expected --sandbox workspace-write in {args:?}"
);
let pos2 = args
.windows(2)
.position(|w| w == ["--ask-for-approval".to_owned(), "on-request".to_owned()]);
assert!(
pos2.is_some(),
"expected --ask-for-approval on-request in {args:?}"
);
let add_dir = args
.windows(2)
.position(|w| w == ["--add-dir".to_owned(), "/home/me/proj".to_owned()]);
assert!(
add_dir.is_some(),
"expected --add-dir project root in {args:?}"
);
}
// ---- (5) MCP decoupling — THE key case of the lot ---------------------------
/// (5) A Codex profile with **no MCP capability** still gets its sandbox projected
/// (config file + args). This proves the projection no longer depends on
/// `apply_mcp_config`: the MCP table is absent, yet the permission plan is applied.
#[tokio::test]
async fn codex_sandbox_projected_without_any_mcp_capability() {
let profile = codex_profile().with_projector(ProjectorKey::Codex);
assert!(profile.mcp.is_none(), "precondition: no MCP capability");
let (launch, agent, fs, pty, _s) = launch_with_projection(
profile,
Some(ContextInjectionPlan::File {
target: "AGENTS.md".to_owned(),
}),
Some(full_registry()),
Some(perm_doc(Posture::Deny)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
// The sandbox config WAS written despite the absent MCP capability.
let cfg = fs.writes_ending_with(CODEX_CONFIG_REL);
assert_eq!(cfg.len(), 1, "sandbox config projected without MCP");
let toml = String::from_utf8(cfg[0].1.clone()).unwrap();
assert!(
toml.contains("sandbox_mode = \"read-only\""),
"Deny ⇒ read-only: {toml}"
);
// And the args were folded too.
assert!(
pty.spawns()[0]
.args
.windows(2)
.any(|w| w == ["--sandbox".to_owned(), "read-only".to_owned()]),
"sandbox args projected without MCP: {:?}",
pty.spawns()[0].args
);
}
// ---- (6) no-op regimes ------------------------------------------------------
/// (6a) Registry absent (builder never called) ⇒ no permission file is written,
/// even with a posed policy.
#[tokio::test]
async fn no_registry_means_no_projection() {
let profile = profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)
.with_projector(ProjectorKey::Claude);
let (launch, agent, fs, _pty, _s) = launch_with_projection(
profile,
convention_file_plan(),
None, // no registry wired
Some(perm_doc(Posture::Deny)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert!(
fs.writes_ending_with(CLAUDE_SEED_REL).is_empty(),
"no registry ⇒ no permission seed written (legacy behaviour)"
);
}
/// (6b) `eff == None` (no project/agent policy posed) ⇒ empty projection: nothing
/// written, even though the registry IS wired.
#[tokio::test]
async fn no_policy_posed_means_empty_projection() {
let profile = profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)
.with_projector(ProjectorKey::Claude);
let (launch, agent, fs, _pty, _s) = launch_with_projection(
profile,
convention_file_plan(),
Some(full_registry()),
Some(ProjectPermissions::default()), // project_defaults = None ⇒ resolve_for == None
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
assert!(
fs.writes_ending_with(CLAUDE_SEED_REL).is_empty(),
"eff == None ⇒ empty projection ⇒ no seed written"
);
}
// ---- (7) resolved eff reflected in the projected file -----------------------
/// (7) Smoke: a posed `Deny` project posture flows through `resolve_for` into the
/// projector and is reflected in the produced Claude settings (`defaultMode=plan`).
#[tokio::test]
async fn resolved_deny_posture_reflected_as_plan_mode() {
let profile = profile(
pid(9),
ContextInjection::convention_file("CLAUDE.md").unwrap(),
)
.with_projector(ProjectorKey::Claude);
let (launch, agent, fs, _pty, _s) = launch_with_projection(
profile,
convention_file_plan(),
Some(full_registry()),
Some(perm_doc(Posture::Deny)),
);
launch
.execute(launch_input(agent.id))
.await
.expect("launch");
let seed = String::from_utf8(fs.writes_ending_with(CLAUDE_SEED_REL)[0].1.clone()).unwrap();
let json: serde_json::Value = serde_json::from_str(&seed).expect("valid settings JSON");
assert_eq!(
json["permissions"]["defaultMode"], "plan",
"Deny posture ⇒ plan mode: {seed}"
);
assert_eq!(
json["permissions"]["additionalDirectories"][0], "/home/me/proj",
"project root flowed into the projection ctx"
);
}
// ---------------------------------------------------------------------------
// État du projet injection at launch (lot LS4) — `resolve_live_state` owns the
// manifest join + self-exclusion + ordering + cap; the composer renders it.
// ---------------------------------------------------------------------------
/// In-memory [`LiveStateStore`] seeded with fixed rows (no I/O), to drive the
/// live-state preview injected into the convention file at launch.
struct SeededLiveStore {
state: Mutex<domain::live_state::LiveState>,
}
#[async_trait]
impl domain::ports::LiveStateStore for SeededLiveStore {
async fn load(&self) -> Result<domain::live_state::LiveState, domain::ports::StoreError> {
Ok(self.state.lock().unwrap().clone())
}
async fn upsert(
&self,
entry: domain::live_state::LiveEntry,
) -> Result<(), domain::ports::StoreError> {
self.state.lock().unwrap().upsert(entry);
Ok(())
}
async fn prune(
&self,
now_ms: u64,
ttl_ms: u64,
max_n: usize,
) -> Result<(), domain::ports::StoreError> {
self.state.lock().unwrap().prune(now_ms, ttl_ms, max_n);
Ok(())
}
}
/// Fixed clock so the seeded rows are never pruned for age at read time.
struct InjectClock(i64);
impl domain::ports::Clock for InjectClock {
fn now_millis(&self) -> i64 {
self.0
}
}
/// A [`LiveStateLeanProvider`] yielding the same [`GetLiveStateLean`] over a shared
/// seeded store (root-agnostic for the test).
struct SeededLeanProvider {
getter: Arc<application::GetLiveStateLean>,
}
impl application::LiveStateLeanProvider for SeededLeanProvider {
fn live_state_lean_for(
&self,
_root: &ProjectPath,
) -> Option<Arc<application::GetLiveStateLean>> {
Some(Arc::clone(&self.getter))
}
}
#[tokio::test]
async fn launch_injects_live_state_excluding_self_capped_in_manifest_order() {
use domain::live_state::{LiveEntry, LiveState, WorkStatus};
let injection = ContextInjection::convention_file("CLAUDE.md").unwrap();
let plan = Some(ContextInjectionPlan::File {
target: "CLAUDE.md".to_owned(),
});
// The launched agent (self) — must be EXCLUDED from its own preview.
let me = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
let contexts = FakeContexts::with_agent(&me, "# ctx body");
// 18 OTHER agents in the manifest, in a deterministic order (aid 2..=19).
{
let mut inner = contexts.0.lock().unwrap();
for n in 2..=19u128 {
let other = scratch_agent(
aid(n),
&format!("A{n:02}"),
&format!("agents/a{n}.md"),
pid(9),
);
inner
.manifest
.entries
.push(ManifestEntry::from_agent(&other));
}
}
// Seed the live-state store: a row for self (must not surface), a row for each
// of the 18 manifest peers, plus one OFF-manifest row (aid 99) that must drop.
let now = 1_000_000_i64;
let mut state = LiveState::default();
state.upsert(
LiveEntry::new(
aid(1),
None,
"my own work",
WorkStatus::Working,
None,
None,
now as u64,
)
.unwrap(),
);
for n in 2..=19u128 {
state.upsert(
LiveEntry::new(
aid(n),
None,
format!("intent {n}"),
WorkStatus::Working,
None,
None,
now as u64,
)
.unwrap(),
);
}
state.upsert(
LiveEntry::new(
aid(99),
None,
"ghost",
WorkStatus::Idle,
None,
None,
now as u64,
)
.unwrap(),
);
let store = Arc::new(SeededLiveStore {
state: Mutex::new(state),
});
let getter = Arc::new(application::GetLiveStateLean::new(
store as Arc<dyn domain::ports::LiveStateStore>,
Arc::new(InjectClock(now)),
));
let provider = Arc::new(SeededLeanProvider { getter });
let profiles = FakeProfiles::new(vec![profile(pid(9), injection)]);
let tr = trace();
let fs = FakeFs::new(Arc::clone(&tr));
let pty = FakePty::new(Arc::clone(&tr), sid(777));
let sessions = Arc::new(TerminalSessions::new());
let bus = SpyBus::default();
let launch = LaunchAgent::new(
Arc::new(contexts),
Arc::new(profiles),
Arc::new(FakeRuntime::new(Arc::clone(&tr), plan)),
Arc::new(fs.clone()),
Arc::new(pty.clone()),
Arc::new(FakeSkills::default()),
Arc::clone(&sessions),
Arc::new(bus.clone()),
Arc::new(SeqIds::new()),
Arc::new(FakeRecall::default()),
None,
)
.with_live_state_lean(provider as Arc<dyn application::LiveStateLeanProvider>);
launch.execute(launch_input(me.id)).await.expect("launch");
let writes = fs.context_writes();
assert_eq!(writes.len(), 1, "exactly one convention file written");
let doc = String::from_utf8(writes[0].1.clone()).unwrap();
// The section is present.
assert!(
doc.contains("# État du projet"),
"live-state section present: {doc}"
);
// Self is EXCLUDED: the launched agent never sees its own row.
assert!(
!doc.contains("- **Backend**"),
"the launched agent must not see its own live row: {doc}"
);
// The off-manifest row never surfaces (its name is unknown to the manifest).
assert!(
!doc.contains("ghost"),
"off-manifest rows are dropped: {doc}"
);
// Cap: exactly LIVE_STATE_INJECT_MAX (16) peer rows are injected, in manifest
// order ⇒ A02..=A17 present, A18/A19 dropped by the cap. The only `- **` bullets
// in this composition are the live rows (no skills/memory bullets here).
assert_eq!(
doc.matches("- **").count(),
16,
"capped to LIVE_STATE_INJECT_MAX peer rows: {doc}"
);
assert!(
doc.contains("- **A02** — working · intent 2"),
"first peer row: {doc}"
);
assert!(
doc.contains("- **A17** — working · intent 17"),
"16th peer row: {doc}"
);
assert!(
!doc.contains("- **A18**"),
"18th agent dropped by the cap: {doc}"
);
assert!(
!doc.contains("- **A19**"),
"19th agent dropped by the cap: {doc}"
);
// Manifest order preserved across the kept rows.
let a02 = doc.find("**A02**").unwrap();
let a17 = doc.find("**A17**").unwrap();
assert!(a02 < a17, "rows follow manifest order: {doc}");
}
Reference in New Issue View Git Blame Copy Permalink