From f7ca6b7ced3407c2f8a65d3fc97b7101b385665e Mon Sep 17 00:00:00 2001
From: Phelipe Lorran <112786693+httpsphl@users.noreply.github.com>
Date: Mon, 5 Oct 2026 13:07:05 -0300
Subject: [PATCH] feat(tools): read and edit another crew's files with the
 owner's OK

ask_crew_access now takes read and edit besides talk. With access, a bot
lists, reads and writes the other crew's files through crew_files,
read_crew_file and write_crew_file, never its own file tools, which the
fences still keep out. One bot reaches that bot's folder and its crew's
work folder; the whole crew reaches every bot's folder. The bots'
memory, rules and the owner's attachments stay out of reach, so no crew
can give another crew's bots instructions. The details list says what
each access allows. Spec 10, 10.4.
---
 app/src/features/bots/CrewAccessList.tsx      |  12 +-
 app/src/features/chat/CrewAccessCard.tsx      |   8 +-
 app/src/features/chat/crewAccess.test.tsx     |   7 +-
 app/src/i18n/en/bots.ts                       |   1 +
 app/src/i18n/en/chat.ts                       |   2 +
 app/src/i18n/es/bots.ts                       |   1 +
 app/src/i18n/es/chat.ts                       |   2 +
 app/src/i18n/pt-BR/bots.ts                    |   1 +
 app/src/i18n/pt-BR/chat.ts                    |   2 +
 app/src/lib/fakeCrewAccess.ts                 |  10 +-
 app/src/lib/protocol.gen.ts                   |  12 +
 .../botloft-core/src/protocol/crew_access.rs  |   6 +
 .../migrations/0022_crew_access_files.sql     |   3 +
 crates/botloft-store/src/crew_access.rs       |  71 ++++-
 crates/botloft-store/src/lib.rs               |   2 +-
 crates/botloft-store/src/migrate.rs           |   1 +
 crates/botloftd/src/service/crew_access.rs    | 128 ++++++---
 crates/botloftd/src/service/files/foreign.rs  | 118 ++++++++
 crates/botloftd/src/service/files/mod.rs      |   4 +
 crates/botloftd/src/tools/calls.rs            |  37 ++-
 crates/botloftd/src/tools/catalog.rs          |   1 +
 crates/botloftd/src/tools/crew_access.rs      | 151 +++++-----
 crates/botloftd/src/tools/crew_reach.rs       | 258 ++++++++++++++++++
 crates/botloftd/src/tools/mod.rs              |   1 +
 crates/botloftd/src/workspace/files.rs        |   8 +-
 crates/botloftd/tests/crew_files.rs           | 195 +++++++++++++
 crates/botloftd/tests/mcp.rs                  |   5 +-
 docs/spec.md                                  |  10 +-
 28 files changed, 904 insertions(+), 153 deletions(-)
 create mode 100644 crates/botloft-store/migrations/0022_crew_access_files.sql
 create mode 100644 crates/botloftd/src/service/files/foreign.rs
 create mode 100644 crates/botloftd/src/tools/crew_reach.rs
 create mode 100644 crates/botloftd/tests/crew_files.rs

diff --git a/app/src/features/bots/CrewAccessList.tsx b/app/src/features/bots/CrewAccessList.tsx
index e0bb7dc9..3a0fc4a2 100644
--- a/app/src/features/bots/CrewAccessList.tsx
+++ b/app/src/features/bots/CrewAccessList.tsx
@@ -64,7 +64,17 @@ export function CrewAccessList({ bot }: { bot: Bot }) {
                   className="flex items-center gap-2 rounded-lg border border-line bg-sunken py-1.5 pr-1 pl-2.5"
                 >
                   <Network aria-hidden size={14} className="shrink-0 text-muted" />
-                  <span className="min-w-0 flex-1 text-xs">{what}</span>
+                  <span className="min-w-0 flex-1 text-xs">
+                    <span className="block">{what}</span>
+                    <span className="block text-ink-soft">
+                      {[
+                        access.talk && words.crewsKinds.talk,
+                        access.edit ? words.crewsKinds.edit : access.read && words.crewsKinds.read,
+                      ]
+                        .filter(Boolean)
+                        .join(" · ")}
+                    </span>
+                  </span>
                   <Button
                     variant="ghost"
                     size="sm"
diff --git a/app/src/features/chat/CrewAccessCard.tsx b/app/src/features/chat/CrewAccessCard.tsx
index c41a6e41..1ecc078d 100644
--- a/app/src/features/chat/CrewAccessCard.tsx
+++ b/app/src/features/chat/CrewAccessCard.tsx
@@ -129,7 +129,13 @@ export function CrewAccessCard({ approval, bot }: { approval: ApprovalItem; bot:
         <ul className="flex flex-col gap-1">
           {(asked.access ?? []).map((kind) => (
             <li key={kind} className="text-ink-soft">
-              {kind === "talk" ? w.talk(target ? target : crew) : kind}
+              {kind === "talk"
+                ? w.talk(target ?? crew)
+                : kind === "read"
+                  ? w.read(target ?? crew)
+                  : kind === "edit"
+                    ? w.edit(target ?? crew)
+                    : kind}
             </li>
           ))}
         </ul>
diff --git a/app/src/features/chat/crewAccess.test.tsx b/app/src/features/chat/crewAccess.test.tsx
index 10e00476..0d528daf 100644
--- a/app/src/features/chat/crewAccess.test.tsx
+++ b/app/src/features/chat/crewAccess.test.tsx
@@ -28,7 +28,7 @@ const request = (bot: string | null) =>
     crew: "Blog",
     bot,
     handle: bot?.toLowerCase() ?? null,
-    access: ["talk"],
+    access: ["talk", "read"],
     why: "To get this week's post.",
   });
 
@@ -42,6 +42,7 @@ describe("a bot asking to reach another crew", () => {
       name: "Scout wants to reach Writer, of the crew Blog",
     });
     expect(within(card).getByText(/^Talk with Writer/)).toBeDefined();
+    expect(within(card).getByText("Read the files of Writer and of its work folder")).toBeDefined();
     expect(within(card).getByText("To get this week's post.")).toBeDefined();
     expect(within(card).getByRole("button", { name: "Only now" })).toBeDefined();
     expect(within(card).getByRole("button", { name: "Always the crew Blog" })).toBeDefined();
@@ -67,11 +68,13 @@ describe("a bot asking to reach another crew", () => {
   test("lasting access shows in the bot's details and can be taken back", async () => {
     const { fake, scout } = await openScout();
     fake.crewAccess.add(scout.id, "Blog");
-    fake.crewAccess.add(scout.id, "Shop", { id: "bot_clerk", name: "Clerk" });
+    fake.crewAccess.add(scout.id, "Shop", { id: "bot_clerk", name: "Clerk" }, { edit: true });
     fireEvent.click(screen.getByRole("button", { name: /^Show details/ }));
     const details = screen.getByRole("complementary", { name: "About Scout" });
     expect(await within(details).findByText("The whole crew Blog")).toBeDefined();
     expect(within(details).getByText("Clerk, of the crew Shop")).toBeDefined();
+    expect(within(details).getByText("talk")).toBeDefined();
+    expect(within(details).getByText("edit files")).toBeDefined();
     fireEvent.click(
       within(details).getByRole("button", { name: "Take back: The whole crew Blog" }),
     );
diff --git a/app/src/i18n/en/bots.ts b/app/src/i18n/en/bots.ts
index d1d499ee..4a838e89 100644
--- a/app/src/i18n/en/bots.ts
+++ b/app/src/i18n/en/bots.ts
@@ -137,5 +137,6 @@ export const bots = {
     crewsBot: (bot: string, crew: string) => `${bot}, of the crew ${crew}`,
     crewsRemove: (what: string) => `Take back: ${what}`,
     crewsRemoveFailed: "Could not take it back",
+    crewsKinds: { talk: "talk", read: "read files", edit: "edit files" },
   },
 };
diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts
index a6bd0bbd..72ded18d 100644
--- a/app/src/i18n/en/chat.ts
+++ b/app/src/i18n/en/chat.ts
@@ -325,6 +325,8 @@ export const chat = {
     titleBot: (bot: string, other: string, crew: string) =>
       `${bot} wants to reach ${other}, of the crew ${crew}`,
     talk: (whom: string) => `Talk with ${whom}: see who is there and send messages and tasks`,
+    read: (whom: string) => `Read the files of ${whom} and of its work folder`,
+    edit: (whom: string) => `Change and add files of ${whom} and of its work folder`,
     why: (bot: string) => `Why, says ${bot}:`,
     explain: "Crews do not see each other. Only now lasts until the bot ends this turn.",
     once: "Only now",
diff --git a/app/src/i18n/es/bots.ts b/app/src/i18n/es/bots.ts
index 4b9b3ce3..39c757d9 100644
--- a/app/src/i18n/es/bots.ts
+++ b/app/src/i18n/es/bots.ts
@@ -135,5 +135,6 @@ export const bots: Messages["bots"] = {
     crewsBot: (bot, crew) => `${bot}, del equipo ${crew}`,
     crewsRemove: (what) => `Quitar el acceso: ${what}`,
     crewsRemoveFailed: "No se pudo quitar el acceso",
+    crewsKinds: { talk: "hablar", read: "leer archivos", edit: "editar archivos" },
   },
 };
diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts
index a65733ec..1565c5a9 100644
--- a/app/src/i18n/es/chat.ts
+++ b/app/src/i18n/es/chat.ts
@@ -313,6 +313,8 @@ export const chat: Messages["chat"] = {
     titleCrew: (bot, crew) => `${bot} quiere acceder al equipo ${crew}`,
     titleBot: (bot, other, crew) => `${bot} quiere acceder a ${other}, del equipo ${crew}`,
     talk: (whom) => `Hablar con ${whom}: ver quién está y enviar mensajes y tareas`,
+    read: (whom) => `Leer los archivos de ${whom} y de su carpeta de trabajo`,
+    edit: (whom) => `Cambiar y crear archivos de ${whom} y de su carpeta de trabajo`,
     why: (bot) => `Por qué, según ${bot}:`,
     explain: "Los equipos no se ven entre sí. Solo ahora vale hasta que el bot termine este turno.",
     once: "Solo ahora",
diff --git a/app/src/i18n/pt-BR/bots.ts b/app/src/i18n/pt-BR/bots.ts
index f220d30c..6e8c10e5 100644
--- a/app/src/i18n/pt-BR/bots.ts
+++ b/app/src/i18n/pt-BR/bots.ts
@@ -134,5 +134,6 @@ export const bots: Messages["bots"] = {
     crewsBot: (bot, crew) => `${bot}, da equipe ${crew}`,
     crewsRemove: (what) => `Tirar o acesso: ${what}`,
     crewsRemoveFailed: "Não foi possível tirar o acesso",
+    crewsKinds: { talk: "conversar", read: "ler arquivos", edit: "editar arquivos" },
   },
 };
diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts
index e6454399..e3d947ef 100644
--- a/app/src/i18n/pt-BR/chat.ts
+++ b/app/src/i18n/pt-BR/chat.ts
@@ -310,6 +310,8 @@ export const chat: Messages["chat"] = {
     titleCrew: (bot, crew) => `${bot} quer acessar a equipe ${crew}`,
     titleBot: (bot, other, crew) => `${bot} quer acessar ${other}, da equipe ${crew}`,
     talk: (whom) => `Conversar com ${whom}: ver quem está lá e mandar mensagens e tarefas`,
+    read: (whom) => `Ler os arquivos de ${whom} e da pasta de trabalho`,
+    edit: (whom) => `Mudar e criar arquivos de ${whom} e da pasta de trabalho`,
     why: (bot) => `Por quê, segundo ${bot}:`,
     explain: "As equipes não se enxergam. Só agora vale até o bot terminar esta vez.",
     once: "Só agora",
diff --git a/app/src/lib/fakeCrewAccess.ts b/app/src/lib/fakeCrewAccess.ts
index fd0bc55a..cdbbc4e1 100644
--- a/app/src/lib/fakeCrewAccess.ts
+++ b/app/src/lib/fakeCrewAccess.ts
@@ -15,7 +15,12 @@ export class FakeCrewAccess {
   constructor(private readonly fake: FakeBotloft) {}
 
   /** `bot` may reach `crewName` for good, or only `target` in it. */
-  add(bot: BotId, crewName: string, target?: { id: BotId; name: string }): CrewAccess {
+  add(
+    bot: BotId,
+    crewName: string,
+    target?: { id: BotId; name: string },
+    kinds: { talk?: boolean; read?: boolean; edit?: boolean } = { talk: true },
+  ): CrewAccess {
     const access: CrewAccess = {
       id: `cxa_${this.next++}`,
       botId: bot,
@@ -23,6 +28,9 @@ export class FakeCrewAccess {
       crewName,
       targetBotId: target?.id ?? null,
       targetName: target?.name ?? null,
+      talk: kinds.talk ?? false,
+      read: (kinds.read ?? false) || (kinds.edit ?? false),
+      edit: kinds.edit ?? false,
       createdAt: this.fake.now,
     };
     this.list.push(access);
diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts
index c3203298..353dc505 100644
--- a/app/src/lib/protocol.gen.ts
+++ b/app/src/lib/protocol.gen.ts
@@ -1019,6 +1019,18 @@ botId: BotId, crewId: CrewId, crewName: string,
  * One bot of the crew; `null` for the whole crew.
  */
 targetBotId: BotId | null, targetName: string | null, 
+/**
+ * Talking with its bots: roster, messages and tasks.
+ */
+talk: boolean, 
+/**
+ * Reading their files; true whenever `edit` is.
+ */
+read: boolean, 
+/**
+ * Changing and adding files.
+ */
+edit: boolean, 
 /**
  * Unix time in milliseconds.
  */
diff --git a/crates/botloft-core/src/protocol/crew_access.rs b/crates/botloft-core/src/protocol/crew_access.rs
index bf370c82..c2604a9a 100644
--- a/crates/botloft-core/src/protocol/crew_access.rs
+++ b/crates/botloft-core/src/protocol/crew_access.rs
@@ -18,6 +18,12 @@ pub struct CrewAccess {
     /// One bot of the crew; `null` for the whole crew.
     pub target_bot_id: Option<BotId>,
     pub target_name: Option<String>,
+    /// Talking with its bots: roster, messages and tasks.
+    pub talk: bool,
+    /// Reading their files; true whenever `edit` is.
+    pub read: bool,
+    /// Changing and adding files.
+    pub edit: bool,
     /// Unix time in milliseconds.
     pub created_at: i64,
 }
diff --git a/crates/botloft-store/migrations/0022_crew_access_files.sql b/crates/botloft-store/migrations/0022_crew_access_files.sql
new file mode 100644
index 00000000..879101e1
--- /dev/null
+++ b/crates/botloft-store/migrations/0022_crew_access_files.sql
@@ -0,0 +1,3 @@
+-- Reading and editing another crew's files, besides talking (spec 10.4).
+ALTER TABLE crew_access ADD COLUMN read INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE crew_access ADD COLUMN edit INTEGER NOT NULL DEFAULT 0;
diff --git a/crates/botloft-store/src/crew_access.rs b/crates/botloft-store/src/crew_access.rs
index 25e835fe..f7d00b73 100644
--- a/crates/botloft-store/src/crew_access.rs
+++ b/crates/botloft-store/src/crew_access.rs
@@ -6,6 +6,28 @@ use rusqlite::{OptionalExtension, Row, params};
 
 use crate::{Result, Store, parse_column};
 
+/// What a bot may do in another crew. Editing files includes reading them.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct AccessKinds {
+    /// Talking with its bots: roster, messages and tasks.
+    pub talk: bool,
+    /// Listing and reading their files.
+    pub read: bool,
+    /// Changing and adding files.
+    pub edit: bool,
+}
+
+impl AccessKinds {
+    /// Everything either one allows.
+    pub fn with(self, other: Self) -> Self {
+        Self {
+            talk: self.talk || other.talk,
+            read: self.read || other.read,
+            edit: self.edit || other.edit,
+        }
+    }
+}
+
 /// A bot's lasting access to another crew, or to one bot of it.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CrewAccessRecord {
@@ -15,12 +37,11 @@ pub struct CrewAccessRecord {
     pub crew_id: CrewId,
     /// One bot of the crew; `None` for the whole crew.
     pub target_bot_id: Option<BotId>,
-    /// Talking with its bots: roster, messages and tasks.
-    pub talk: bool,
+    pub kinds: AccessKinds,
     pub created_at: i64,
 }
 
-const COLUMNS: &str = "id, bot_id, crew_id, target_bot_id, talk, created_at";
+const COLUMNS: &str = "id, bot_id, crew_id, target_bot_id, talk, read, edit, created_at";
 
 fn from_row(row: &Row<'_>) -> rusqlite::Result<CrewAccessRecord> {
     let target: Option<String> = row.get(3)?;
@@ -32,8 +53,12 @@ fn from_row(row: &Row<'_>) -> rusqlite::Result<CrewAccessRecord> {
             Some(_) => Some(parse_column(row, 3)?),
             None => None,
         },
-        talk: row.get(4)?,
-        created_at: row.get(5)?,
+        kinds: AccessKinds {
+            talk: row.get(4)?,
+            read: row.get(5)?,
+            edit: row.get(6)?,
+        },
+        created_at: row.get(7)?,
     })
 }
 
@@ -45,20 +70,24 @@ impl Store {
         bot: &BotId,
         crew: &CrewId,
         target: Option<&BotId>,
-        talk: bool,
+        kinds: AccessKinds,
         now: i64,
     ) -> Result<()> {
         self.conn.execute(
-            "INSERT INTO crew_access (id, bot_id, crew_id, target_bot_id, talk, created_at) \
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6) \
+            "INSERT INTO crew_access \
+             (id, bot_id, crew_id, target_bot_id, talk, read, edit, created_at) \
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8) \
              ON CONFLICT (bot_id, crew_id, coalesce(target_bot_id, '')) DO UPDATE SET \
-             talk = talk OR excluded.talk",
+             talk = talk OR excluded.talk, read = read OR excluded.read, \
+             edit = edit OR excluded.edit",
             params![
                 CrewAccessId::generate().as_str(),
                 bot.as_str(),
                 crew.as_str(),
                 target.map(BotId::as_str),
-                talk,
+                kinds.talk,
+                kinds.read,
+                kinds.edit,
                 now,
             ],
         )?;
@@ -95,8 +124,15 @@ impl Store {
 mod tests {
     use botloft_core::ids::CrewId;
 
+    use super::AccessKinds;
     use crate::tests::Fixture;
 
+    const TALK: AccessKinds = AccessKinds {
+        talk: true,
+        read: false,
+        edit: false,
+    };
+
     #[test]
     fn access_is_kept_per_bot_and_reach_and_only_grows() {
         let fx = Fixture::new();
@@ -110,19 +146,26 @@ mod tests {
             })
             .expect("blog");
         fx.store
-            .grant_crew_access(scout, &blog, Some(writer), true, 10)
+            .grant_crew_access(scout, &blog, Some(writer), TALK, 10)
             .expect("bot");
         fx.store
-            .grant_crew_access(scout, &blog, None, false, 20)
+            .grant_crew_access(scout, &blog, None, AccessKinds::default(), 20)
             .expect("crew");
         fx.store
-            .grant_crew_access(scout, &blog, None, true, 30)
+            .grant_crew_access(scout, &blog, None, TALK, 30)
             .expect("crew again");
+        let edit = AccessKinds {
+            edit: true,
+            ..AccessKinds::default()
+        };
+        fx.store
+            .grant_crew_access(scout, &blog, None, edit, 40)
+            .expect("and files");
         let access = fx.store.crew_access(scout).expect("list");
         assert_eq!(access.len(), 2);
         assert_eq!(access[0].target_bot_id.as_ref(), Some(writer));
         assert!(access[1].target_bot_id.is_none());
-        assert!(access[1].talk);
+        assert!(access[1].kinds.talk && access[1].kinds.edit && !access[1].kinds.read);
         assert_eq!(access[1].created_at, 20);
         assert!(fx.store.crew_access(writer).expect("none").is_empty());
 
diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs
index a9dc26de..b70bbae3 100644
--- a/crates/botloft-store/src/lib.rs
+++ b/crates/botloft-store/src/lib.rs
@@ -36,7 +36,7 @@ use rusqlite::{Connection, Row, ffi};
 
 pub use approvals::ApprovalRecord;
 pub use bots::BotRecord;
-pub use crew_access::CrewAccessRecord;
+pub use crew_access::{AccessKinds, CrewAccessRecord};
 pub use deliveries::DeliveryOutcome;
 pub use messages::MessageFilter;
 pub use migrate::LATEST_VERSION;
diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs
index 2ea0366d..5211684c 100644
--- a/crates/botloft-store/src/migrate.rs
+++ b/crates/botloft-store/src/migrate.rs
@@ -28,6 +28,7 @@ const MIGRATIONS: &[(u32, &str)] = &[
     (19, include_str!("../migrations/0019_reactions.sql")),
     (20, include_str!("../migrations/0020_desktop_grants.sql")),
     (21, include_str!("../migrations/0021_crew_access.sql")),
+    (22, include_str!("../migrations/0022_crew_access_files.sql")),
 ];
 
 /// Schema version after every migration has run.
diff --git a/crates/botloftd/src/service/crew_access.rs b/crates/botloftd/src/service/crew_access.rs
index 381309c7..037c26c0 100644
--- a/crates/botloftd/src/service/crew_access.rs
+++ b/crates/botloftd/src/service/crew_access.rs
@@ -8,21 +8,43 @@ use std::sync::{Mutex, PoisonError};
 
 use botloft_core::ids::{BotId, CrewId};
 use botloft_core::protocol::{Crew, CrewAccess, CrewAccessIdParams, CrewAccessListParams};
-use botloft_store::{BotRecord, Store};
+use botloft_store::{AccessKinds, BotRecord, Store};
 
 use super::{ApiError, ApiResult};
 use crate::state::Daemon;
 
-/// What a bot may reach in another crew: the whole crew, or one bot of it.
+/// What a bot needs to do in another crew.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Need {
+    Talk,
+    Read,
+    Edit,
+}
+
+impl Need {
+    /// Whether `kinds` allows it. Editing files includes reading them.
+    fn met_by(self, kinds: AccessKinds) -> bool {
+        match self {
+            Self::Talk => kinds.talk,
+            Self::Read => kinds.read || kinds.edit,
+            Self::Edit => kinds.edit,
+        }
+    }
+}
+
+/// What a bot may reach in another crew: the whole crew, or one bot of it,
+/// and what it may do there.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Reach {
     pub crew: CrewId,
     pub target: Option<BotId>,
+    pub kinds: AccessKinds,
 }
 
 impl Reach {
-    fn covers(&self, crew: &CrewId, bot: Option<&BotId>) -> bool {
+    fn covers(&self, crew: &CrewId, bot: Option<&BotId>, need: Need) -> bool {
         self.crew == *crew
+            && need.met_by(self.kinds)
             && match (&self.target, bot) {
                 (None, _) => true,
                 (Some(target), Some(bot)) => target == bot,
@@ -41,8 +63,12 @@ impl TurnAccess {
     pub fn allow(&self, bot: &BotId, reach: Reach) {
         let mut turns = self.turns.lock().unwrap_or_else(PoisonError::into_inner);
         let list = turns.entry(bot.clone()).or_default();
-        if !list.contains(&reach) {
-            list.push(reach);
+        match list
+            .iter_mut()
+            .find(|had| had.crew == reach.crew && had.target == reach.target)
+        {
+            Some(had) => had.kinds = had.kinds.with(reach.kinds),
+            None => list.push(reach),
         }
     }
 
@@ -55,12 +81,12 @@ impl TurnAccess {
             .remove(bot);
     }
 
-    fn covers(&self, bot: &BotId, crew: &CrewId, target: Option<&BotId>) -> bool {
+    fn covers(&self, bot: &BotId, crew: &CrewId, target: Option<&BotId>, need: Need) -> bool {
         self.turns
             .lock()
             .unwrap_or_else(PoisonError::into_inner)
             .get(bot)
-            .is_some_and(|list| list.iter().any(|reach| reach.covers(crew, target)))
+            .is_some_and(|list| list.iter().any(|reach| reach.covers(crew, target, need)))
     }
 }
 
@@ -99,31 +125,35 @@ fn described(store: &Store, bot: &BotId) -> ApiResult<Vec<CrewAccess>> {
                 crew_name: crew_name.unwrap_or_default(),
                 target_bot_id: access.target_bot_id,
                 target_name,
+                talk: access.kinds.talk,
+                read: access.kinds.read || access.kinds.edit,
+                edit: access.kinds.edit,
                 created_at: access.created_at,
             })
         })
         .collect()
 }
 
-/// Whether `bot` may talk with `target` of `crew` (or, with `None`, see
-/// the crew's roster), for good or for this turn.
+/// Whether `bot` may do `need` with `target` of `crew` (with `None`, with
+/// the whole crew), for good or for this turn.
 pub(crate) fn reaches(
     daemon: &Daemon,
     store: &Store,
     bot: &BotId,
     crew: &CrewId,
     target: Option<&BotId>,
+    need: Need,
 ) -> ApiResult<bool> {
-    if daemon.crew_access.covers(bot, crew, target) {
+    if daemon.crew_access.covers(bot, crew, target, need) {
         return Ok(true);
     }
     Ok(store.crew_access(bot)?.iter().any(|access| {
-        access.talk
-            && Reach {
-                crew: access.crew_id.clone(),
-                target: access.target_bot_id.clone(),
-            }
-            .covers(crew, target)
+        Reach {
+            crew: access.crew_id.clone(),
+            target: access.target_bot_id.clone(),
+            kinds: access.kinds,
+        }
+        .covers(crew, target, need)
     }))
 }
 
@@ -141,9 +171,21 @@ pub(crate) fn may_talk(
     to: &BotRecord,
 ) -> ApiResult<bool> {
     let since = daemon.clock.now_ms() - ANSWER_WINDOW_MS;
-    Ok(reaches(daemon, store, &from.id, &to.crew_id, Some(&to.id))?
-        || reaches(daemon, store, &to.id, &from.crew_id, Some(&from.id))?
-        || store.wrote_to_since(&to.id, &from.id, since)?)
+    Ok(reaches(
+        daemon,
+        store,
+        &from.id,
+        &to.crew_id,
+        Some(&to.id),
+        Need::Talk,
+    )? || reaches(
+        daemon,
+        store,
+        &to.id,
+        &from.crew_id,
+        Some(&from.id),
+        Need::Talk,
+    )? || store.wrote_to_since(&to.id, &from.id, since)?)
 }
 
 /// Another active crew, by its name or folder name, case aside. The
@@ -174,36 +216,54 @@ mod tests {
     fn a_crew_reach_covers_its_bots_and_a_bot_reach_only_that_bot() {
         let (crew, other) = (CrewId::generate(), CrewId::generate());
         let (writer, editor) = (BotId::generate(), BotId::generate());
+        let talk = AccessKinds {
+            talk: true,
+            ..AccessKinds::default()
+        };
         let whole = Reach {
             crew: crew.clone(),
             target: None,
+            kinds: talk,
         };
-        assert!(whole.covers(&crew, Some(&writer)));
-        assert!(whole.covers(&crew, None));
-        assert!(!whole.covers(&other, Some(&writer)));
+        assert!(whole.covers(&crew, Some(&writer), Need::Talk));
+        assert!(whole.covers(&crew, None, Need::Talk));
+        assert!(!whole.covers(&other, Some(&writer), Need::Talk));
+        assert!(!whole.covers(&crew, Some(&writer), Need::Read));
         let one = Reach {
             crew: crew.clone(),
             target: Some(writer.clone()),
+            kinds: AccessKinds {
+                edit: true,
+                ..AccessKinds::default()
+            },
         };
-        assert!(one.covers(&crew, Some(&writer)));
-        assert!(!one.covers(&crew, Some(&editor)));
-        assert!(!one.covers(&crew, None));
+        assert!(one.covers(&crew, Some(&writer), Need::Read));
+        assert!(one.covers(&crew, Some(&writer), Need::Edit));
+        assert!(!one.covers(&crew, Some(&writer), Need::Talk));
+        assert!(!one.covers(&crew, Some(&editor), Need::Read));
+        assert!(!one.covers(&crew, None, Need::Read));
     }
 
     #[test]
     fn access_for_the_turn_goes_when_it_ends() {
         let access = TurnAccess::default();
         let (bot, crew) = (BotId::generate(), CrewId::generate());
-        access.allow(
-            &bot,
-            Reach {
-                crew: crew.clone(),
-                target: None,
+        let reach = |talk, read| Reach {
+            crew: crew.clone(),
+            target: None,
+            kinds: AccessKinds {
+                talk,
+                read,
+                edit: false,
             },
-        );
-        assert!(access.covers(&bot, &crew, None));
-        assert!(!access.covers(&BotId::generate(), &crew, None));
+        };
+        access.allow(&bot, reach(true, false));
+        access.allow(&bot, reach(false, true));
+        assert!(access.covers(&bot, &crew, None, Need::Talk));
+        assert!(access.covers(&bot, &crew, None, Need::Read));
+        assert!(!access.covers(&bot, &crew, None, Need::Edit));
+        assert!(!access.covers(&BotId::generate(), &crew, None, Need::Talk));
         access.end_turn(&bot);
-        assert!(!access.covers(&bot, &crew, None));
+        assert!(!access.covers(&bot, &crew, None, Need::Talk));
     }
 }
diff --git a/crates/botloftd/src/service/files/foreign.rs b/crates/botloftd/src/service/files/foreign.rs
new file mode 100644
index 00000000..2a888b9a
--- /dev/null
+++ b/crates/botloftd/src/service/files/foreign.rs
@@ -0,0 +1,118 @@
+//! A bot's files as a bot of another crew reaches them (spec 10.4): only in
+//! its own folder and its crew's work folder, never a file it wrote
+//! elsewhere, and never what Botloft keeps for it there (its memory, its
+//! rules and settings, the owner's attachments).
+
+use std::path::{Path, PathBuf};
+
+use botloft_core::ids::BotId;
+use botloft_core::protocol::{BotFile, FilesListParams};
+
+use super::{Places, list, places};
+use crate::service::{ApiError, ApiResult};
+use crate::state::Daemon;
+
+/// At the top of either folder, what bots load as memory and rules, and
+/// what Botloft and the owner keep there: never another crew's to touch,
+/// or it could give that crew's bots instructions.
+const KEPT: [&str; 5] = [
+    "CLAUDE.md",
+    "CLAUDE.local.md",
+    ".claude",
+    ".botloft",
+    "attachments",
+];
+
+/// The two folders, as they are on disk.
+fn folders(places: &Places) -> Vec<PathBuf> {
+    [&places.work, &places.workspace]
+        .into_iter()
+        .filter_map(|root| root.canonicalize().ok())
+        .collect()
+}
+
+/// Whether `path` (real, absolute) is in one of the folders and not kept.
+fn open_to_others(places: &Places, path: &Path) -> bool {
+    folders(places).iter().any(|root| {
+        path.strip_prefix(root).is_ok_and(|rest| {
+            rest.components().next().is_some_and(|first| {
+                let first = first.as_os_str();
+                !KEPT.iter().any(|kept| first.eq_ignore_ascii_case(kept))
+            })
+        })
+    })
+}
+
+/// The bot's files another crew may see: those of `files.list` in its
+/// folders, kept ones aside.
+pub(crate) fn listed(daemon: &Daemon, owner: &BotId) -> ApiResult<Vec<BotFile>> {
+    let (_, places) = places(daemon, owner)?;
+    Ok(list(
+        daemon,
+        FilesListParams {
+            bot_id: owner.clone(),
+        },
+    )?
+    .into_iter()
+    .filter(|file| {
+        Path::new(&file.path)
+            .canonicalize()
+            .is_ok_and(|real| open_to_others(&places, &real))
+    })
+    .collect())
+}
+
+/// An existing file of the bot's another crew may read, and its size.
+pub(crate) fn readable(daemon: &Daemon, owner: &BotId, path: &str) -> ApiResult<(PathBuf, u64)> {
+    let (_, places) = places(daemon, owner)?;
+    let asked = absolute(path)?;
+    let real = asked
+        .canonicalize()
+        .ok()
+        .filter(|real| open_to_others(&places, real))
+        .ok_or_else(|| out_of_reach(path))?;
+    let meta = std::fs::metadata(&real).map_err(|_| out_of_reach(path))?;
+    if !meta.is_file() {
+        return Err(out_of_reach(path));
+    }
+    Ok((real, meta.len()))
+}
+
+/// Where another crew's bot may write: an existing file of the bot's, or a
+/// new one in a folder that already exists in its folders.
+pub(crate) fn writable(daemon: &Daemon, owner: &BotId, path: &str) -> ApiResult<PathBuf> {
+    let (_, places) = places(daemon, owner)?;
+    let asked = absolute(path)?;
+    if let Ok(real) = asked.canonicalize() {
+        return (real.is_file() && open_to_others(&places, &real))
+            .then_some(real)
+            .ok_or_else(|| out_of_reach(path));
+    }
+    let name = asked.file_name().ok_or_else(|| out_of_reach(path))?;
+    let parent = asked
+        .parent()
+        .and_then(|parent| parent.canonicalize().ok())
+        .filter(|parent| parent.is_dir())
+        .ok_or_else(|| out_of_reach(path))?;
+    let new = parent.join(name);
+    open_to_others(&places, &new)
+        .then_some(new)
+        .ok_or_else(|| out_of_reach(path))
+}
+
+fn absolute(path: &str) -> ApiResult<PathBuf> {
+    let path = Path::new(path.trim());
+    if !path.is_absolute() {
+        return Err(ApiError::validation(
+            "give the file's full path, as crew_files lists it",
+        ));
+    }
+    Ok(path.to_path_buf())
+}
+
+fn out_of_reach(path: &str) -> ApiError {
+    ApiError::NotFound(format!(
+        "{} is not a file you can reach in that crew; call crew_files to see which",
+        path.trim()
+    ))
+}
diff --git a/crates/botloftd/src/service/files/mod.rs b/crates/botloftd/src/service/files/mod.rs
index 6aa85140..2a10b132 100644
--- a/crates/botloftd/src/service/files/mod.rs
+++ b/crates/botloftd/src/service/files/mod.rs
@@ -2,6 +2,7 @@
 //! previews. They are in the crew's work folder or the bot's own folder, or
 //! wherever the bot's `Write`/`Edit` calls put them.
 
+mod foreign;
 mod scan;
 
 use std::collections::HashMap;
@@ -13,6 +14,9 @@ use botloft_core::ids::BotId;
 use botloft_core::protocol::{BotFile, FileData, FilesListParams, FilesReadParams};
 use botloft_store::BotRecord;
 
+pub(crate) use self::foreign::{
+    listed as foreign_files, readable as foreign_readable, writable as foreign_writable,
+};
 pub(crate) use self::scan::media_type;
 use self::scan::{Found, Root, key, keys, millis, walk};
 use super::{ApiError, ApiResult, bots, crews};
diff --git a/crates/botloftd/src/tools/calls.rs b/crates/botloftd/src/tools/calls.rs
index afb89fd3..0799ec9e 100644
--- a/crates/botloftd/src/tools/calls.rs
+++ b/crates/botloftd/src/tools/calls.rs
@@ -17,9 +17,9 @@ use tracing::warn;
 use super::Failure;
 use super::catalog::{COMPLETE_TASK, CREW_ROSTER, MY_TASKS, SEND_MESSAGE};
 use super::question::{self, ASK_OWNER};
-use super::routine_change;
 use super::share::{self, SHARE_FILE};
 use super::signal::{self, SEND_SIGNAL};
+use super::{crew_reach, routine_change};
 use crate::service::tasks::{self, BotMessage};
 use crate::service::{ApiError, bots, lead};
 use crate::state::Daemon;
@@ -35,20 +35,27 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value
         .get("arguments")
         .cloned()
         .unwrap_or_else(|| json!({}));
-    let outcome = match name {
-        CREW_ROSTER => parse(arguments).and_then(|args: RosterArgs| match args.crew {
-            Some(crew) => super::crew_access::roster(daemon, bot, &crew).map_err(explain),
-            None => roster(daemon, bot),
-        }),
-        SEND_MESSAGE => parse(arguments).and_then(|args| send(daemon, bot, args)),
-        COMPLETE_TASK => parse(arguments).and_then(|args| complete(daemon, bot, args)),
-        MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)),
-        SHARE_FILE => parse(arguments).and_then(|args| share::share(daemon, bot, args)),
-        ASK_OWNER => parse(arguments).and_then(|args| question::ask(daemon, bot, args)),
-        SEND_SIGNAL => parse(arguments).and_then(|args| signal::send(daemon, bot, args)),
-        routine_change::MY_ROUTINES => routine_change::mine(daemon, bot),
-        other => return Err(invalid(&format!("Unknown tool: {other}"))),
-    };
+    let outcome =
+        match name {
+            CREW_ROSTER => parse(arguments).and_then(|args: RosterArgs| match args.crew {
+                Some(crew) => super::crew_reach::roster(daemon, bot, &crew).map_err(explain),
+                None => roster(daemon, bot),
+            }),
+            SEND_MESSAGE => parse(arguments).and_then(|args| send(daemon, bot, args)),
+            COMPLETE_TASK => parse(arguments).and_then(|args| complete(daemon, bot, args)),
+            MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)),
+            SHARE_FILE => parse(arguments).and_then(|args| share::share(daemon, bot, args)),
+            ASK_OWNER => parse(arguments).and_then(|args| question::ask(daemon, bot, args)),
+            SEND_SIGNAL => parse(arguments).and_then(|args| signal::send(daemon, bot, args)),
+            routine_change::MY_ROUTINES => routine_change::mine(daemon, bot),
+            crew_reach::CREW_FILES => parse(arguments)
+                .and_then(|args| crew_reach::files(daemon, bot, args).map_err(explain)),
+            crew_reach::READ_CREW_FILE => parse(arguments)
+                .and_then(|args| crew_reach::read(daemon, bot, args).map_err(explain)),
+            crew_reach::WRITE_CREW_FILE => parse(arguments)
+                .and_then(|args| crew_reach::write(daemon, bot, args).map_err(explain)),
+            other => return Err(invalid(&format!("Unknown tool: {other}"))),
+        };
     Ok(tool_result(outcome))
 }
 
diff --git a/crates/botloftd/src/tools/catalog.rs b/crates/botloftd/src/tools/catalog.rs
index 3f35dbce..923b353e 100644
--- a/crates/botloftd/src/tools/catalog.rs
+++ b/crates/botloftd/src/tools/catalog.rs
@@ -32,6 +32,7 @@ pub fn tools() -> Value {
         .into_iter()
         .chain(super::routine_catalog::tools())
         .chain([super::bot_change::tool(), super::crew_access::tool()])
+        .chain(super::crew_reach::tools())
         .chain(super::browser_catalog::tools())
         .chain(super::desktop_catalog::tools());
         list.splice(at..at, more);
diff --git a/crates/botloftd/src/tools/crew_access.rs b/crates/botloftd/src/tools/crew_access.rs
index 04bb4071..e437fed2 100644
--- a/crates/botloftd/src/tools/crew_access.rs
+++ b/crates/botloftd/src/tools/crew_access.rs
@@ -7,22 +7,37 @@
 
 use botloft_core::chat::CREW_ACCESS_TOOL;
 use botloft_core::ids::BotId;
-use botloft_core::protocol::{BotsListParams, PermissionMode};
+use botloft_core::protocol::PermissionMode;
 use botloft_core::slug;
+use botloft_store::AccessKinds;
 use serde::Deserialize;
 use serde_json::{Value, json};
 
 use super::calls::{explain, parse, tool_result};
 use super::suggest::REASON_MAX;
 use crate::approvals::{self, Answer};
-use crate::service::crew_access::{self, Reach};
-use crate::service::{ApiError, ApiResult, bots, lead};
+use crate::service::crew_access::{self, Need, Reach};
+use crate::service::{ApiError, ApiResult, bots};
 use crate::state::Daemon;
 
 pub const ASK_CREW_ACCESS: &str = "ask_crew_access";
 
-/// What a bot may ask for in another crew. Only talking, for now.
-const KINDS: [&str; 1] = ["talk"];
+/// What a bot may ask for in another crew.
+const KINDS: [&str; 3] = ["talk", "read", "edit"];
+
+/// The kinds asked for; `None` for an unknown one.
+fn kinds_of(access: &[String]) -> Option<AccessKinds> {
+    let mut kinds = AccessKinds::default();
+    for kind in access {
+        match kind.as_str() {
+            "talk" => kinds.talk = true,
+            "read" => kinds.read = true,
+            "edit" => kinds.edit = true,
+            _ => return None,
+        }
+    }
+    (kinds != AccessKinds::default()).then_some(kinds)
+}
 
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -56,10 +71,13 @@ pub(super) fn tool() -> Value {
         "title": "Ask to reach another crew",
         "description": "Your crew cannot see or reach other crews. When the owner wants you to \
             work with another crew, or one of its bots, call this with the crew's name as the \
-            owner gave it, the bot's handle if it is one bot, what you need (`talk`: see its \
-            bots and send them messages and tasks) and why. The owner allows it only for now, \
-            always for that bot, or always for the whole crew, or declines; the call waits for \
-            that. Then use crew_roster and send_message with `crew`.",
+            owner gave it, the bot's handle if it is one bot, what you need and why: `talk` to \
+            see its bots and send them messages and tasks, `read` to list and read the files of \
+            that bot (or of the whole crew) and its crew's work folder, `edit` to also change \
+            and add files there. The owner allows it only for now, always for that bot, or \
+            always for the whole crew, or declines; the call waits for that. Then use \
+            crew_roster and send_message with `crew`, and crew_files, read_crew_file and \
+            write_crew_file.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -72,7 +90,7 @@ pub(super) fn tool() -> Value {
                     "type": "array",
                     "items": { "type": "string", "enum": KINDS },
                     "minItems": 1,
-                    "description": "What you need: `talk`.",
+                    "description": "What you need: `talk`, `read`, `edit` (edit includes read).",
                 },
                 "why": {
                     "type": "string",
@@ -93,14 +111,9 @@ pub(super) async fn ask(daemon: &Daemon, bot: &BotId, generation: u64, args: Val
 
 async fn run(daemon: &Daemon, me: &BotId, generation: u64, args: Value) -> Result<Value, String> {
     let args: Args = parse(args)?;
-    if args.access.is_empty()
-        || args
-            .access
-            .iter()
-            .any(|kind| !KINDS.contains(&kind.as_str()))
-    {
-        return Err("access must list what you need: \"talk\"".to_owned());
-    }
+    let Some(kinds) = kinds_of(&args.access) else {
+        return Err("access must list what you need: \"talk\", \"read\" or \"edit\"".to_owned());
+    };
     let why = args.why.trim();
     if why.is_empty() || why.chars().count() > REASON_MAX {
         return Err(format!(
@@ -115,13 +128,25 @@ async fn run(daemon: &Daemon, me: &BotId, generation: u64, args: Value) -> Resul
             None => None,
             Some(handle) => Some(find(&store, &crew, handle).map_err(explain)?),
         };
-        let already =
-            crew_access::reaches(daemon, &store, me, &crew.id, target.as_ref().map(|t| &t.id))
-                .map_err(explain)?;
+        let target_id = target.as_ref().map(|t| &t.id);
+        let mut already = true;
+        for (asked, need) in [
+            (kinds.talk, Need::Talk),
+            (kinds.read, Need::Read),
+            (kinds.edit, Need::Edit),
+        ] {
+            if asked
+                && !crew_access::reaches(daemon, &store, me, &crew.id, target_id, need)
+                    .map_err(explain)?
+            {
+                already = false;
+            }
+        }
         if already {
             return Ok(granted(
                 &crew.name,
                 target.as_ref().map(|t| t.handle.as_str()),
+                kinds,
                 "You can already reach it.",
             ));
         }
@@ -130,6 +155,7 @@ async fn run(daemon: &Daemon, me: &BotId, generation: u64, args: Value) -> Resul
     let reach = Reach {
         crew: crew.id.clone(),
         target: target.as_ref().map(|t| t.id.clone()),
+        kinds,
     };
     let handle = target.as_ref().map(|t| t.handle.as_str());
     if mode == PermissionMode::BypassPermissions {
@@ -137,6 +163,7 @@ async fn run(daemon: &Daemon, me: &BotId, generation: u64, args: Value) -> Resul
         return Ok(granted(
             &crew.name,
             handle,
+            kinds,
             "You bypass permissions, so you have it for this turn without asking.",
         ));
     }
@@ -173,13 +200,18 @@ async fn run(daemon: &Daemon, me: &BotId, generation: u64, args: Value) -> Resul
                     };
                     daemon
                         .store()
-                        .grant_crew_access(me, &crew.id, target, true, now)
+                        .grant_crew_access(me, &crew.id, target, kinds, now)
                         .map_err(|err| explain(err.into()))?;
                     "The owner allowed it for good."
                 }
             };
             let whole = scope == Scope::Crew;
-            Ok(granted(&crew.name, if whole { None } else { handle }, how))
+            Ok(granted(
+                &crew.name,
+                if whole { None } else { handle },
+                kinds,
+                how,
+            ))
         }
         Some(Answer::Denied { note }) => {
             let why = note.map_or_else(String::new, |note| format!(" They said: {note}"));
@@ -219,61 +251,28 @@ fn find(
     bots::find(store, &id)
 }
 
-fn granted(crew: &str, handle: Option<&str>, how: &str) -> Value {
-    let whom = handle.map_or_else(
-        || format!("send_message(to: <handle>, crew: \"{crew}\")"),
-        |handle| format!("send_message(to: \"{handle}\", crew: \"{crew}\")"),
-    );
-    json!({
-        "allowed": true,
-        "crew": crew,
-        "bot": handle,
-        "note": format!(
-            "{how} See who you can reach with crew_roster(crew: \"{crew}\") and write with \
-             {whom}. Tell them who you are and what you need: they do not know you."
-        ),
-    })
-}
-
-/// `crew_roster` with `crew`: the bots of another crew the caller may reach.
-pub(super) fn roster(daemon: &Daemon, me: &BotId, name: &str) -> ApiResult<Value> {
-    let (crew, mine) = {
-        let store = daemon.store();
-        let (own, mine) = bots::active(&store, me)?;
-        (crew_access::other_crew(&store, &own.id, name)?, mine)
-    };
-    let list = bots::list(
-        daemon,
-        BotsListParams {
-            crew_id: Some(crew.id.clone()),
-        },
-    )?;
-    let store = daemon.store();
-    let mut reachable = Vec::new();
-    for bot in list {
-        let record = bots::find(&store, &bot.id)?;
-        if crew_access::may_talk(daemon, &store, &mine, &record)? {
-            reachable.push(json!({
-                "handle": bot.handle,
-                "name": bot.name,
-                "role": bot.role,
-                "state": bot.state,
-                "chief": lead::is_lead(&crew, &bot.id),
-            }));
-        }
+fn granted(crew: &str, handle: Option<&str>, kinds: AccessKinds, how: &str) -> Value {
+    let mut note = how.to_owned();
+    if kinds.talk {
+        let whom = handle.map_or_else(
+            || format!("send_message(to: <handle>, crew: \"{crew}\")"),
+            |handle| format!("send_message(to: \"{handle}\", crew: \"{crew}\")"),
+        );
+        note.push_str(&format!(
+            " See who you can reach with crew_roster(crew: \"{crew}\") and write with {whom}. \
+             Tell them who you are and what you need: they do not know you."
+        ));
     }
-    if reachable.is_empty() {
-        return Err(ApiError::Conflict(format!(
-            "you cannot reach the crew {}; if the owner wants you to, call ask_crew_access with \
-             what you need and why",
-            crew.name
-        )));
+    if kinds.read || kinds.edit {
+        note.push_str(&format!(
+            " List the files with crew_files(crew: \"{crew}\") and read one with \
+             read_crew_file. Your own file tools cannot open them."
+        ));
     }
-    Ok(json!({
-        "crew": crew.name,
-        "bots": reachable,
-        "note": format!("Write with send_message(to, crew: \"{}\").", crew.name),
-    }))
+    if kinds.edit {
+        note.push_str(" Change or add one with write_crew_file.");
+    }
+    json!({ "allowed": true, "crew": crew, "bot": handle, "note": note })
 }
 
 /// The owner's answer to a request (`approvals.answer` with `input`): how
diff --git a/crates/botloftd/src/tools/crew_reach.rs b/crates/botloftd/src/tools/crew_reach.rs
new file mode 100644
index 00000000..b3c87fd9
--- /dev/null
+++ b/crates/botloftd/src/tools/crew_reach.rs
@@ -0,0 +1,258 @@
+//! What a bot does in another crew once the owner let it in (spec 10.4):
+//! `crew_roster` with `crew`, and `crew_files`, `read_crew_file` and
+//! `write_crew_file`. A crew or a file out of reach reads like a missing
+//! one.
+
+use botloft_core::ids::BotId;
+use botloft_core::protocol::{BotsListParams, Crew};
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use crate::service::crew_access::{self, Need};
+use crate::service::files::{foreign_files, foreign_readable, foreign_writable};
+use crate::service::{ApiError, ApiResult, bots, lead};
+use crate::state::Daemon;
+
+pub const CREW_FILES: &str = "crew_files";
+pub const READ_CREW_FILE: &str = "read_crew_file";
+pub const WRITE_CREW_FILE: &str = "write_crew_file";
+
+/// Most files `crew_files` lists, newest first.
+const LIST_MAX: usize = 200;
+/// Largest file read or written as text, in bytes.
+const TEXT_MAX: u64 = 1024 * 1024;
+
+pub(super) fn tools() -> [Value; 3] {
+    let crew = json!({ "type": "string", "description": "The other crew's name." });
+    let path = json!({
+        "type": "string",
+        "description": "The file's full path, as crew_files lists it.",
+    });
+    [
+        json!({
+            "name": CREW_FILES,
+            "title": "Another crew's files",
+            "description": "Lists the files of another crew you were let in to read \
+                (ask_crew_access with `read`): of one bot, or of every bot you reach there, \
+                with its crew's work folder. Newest first: full path, name, size, when it changed.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "crew": crew,
+                    "bot": { "type": "string", "description": "Only this bot's files (its handle)." },
+                },
+                "required": ["crew"],
+                "additionalProperties": false,
+            },
+            "annotations": { "readOnlyHint": true },
+        }),
+        json!({
+            "name": READ_CREW_FILE,
+            "title": "Read another crew's file",
+            "description": "Reads, as text, a file crew_files listed, in a crew you were let in to \
+                read. Up to 1 MB.",
+            "inputSchema": {
+                "type": "object",
+                "properties": { "crew": crew, "path": path },
+                "required": ["crew", "path"],
+                "additionalProperties": false,
+            },
+            "annotations": { "readOnlyHint": true },
+        }),
+        json!({
+            "name": WRITE_CREW_FILE,
+            "title": "Write another crew's file",
+            "description": "Replaces a file of another crew you were let in to edit \
+                (ask_crew_access with `edit`), or adds one in a folder that already exists there. \
+                The whole new text, up to 1 MB. Tell the bots of that crew what you changed.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "crew": crew,
+                    "path": path,
+                    "content": { "type": "string", "description": "The file's whole new text." },
+                },
+                "required": ["crew", "path", "content"],
+                "additionalProperties": false,
+            },
+        }),
+    ]
+}
+
+/// The crew by name and the bots of it whose files the caller may `need`.
+fn owners(daemon: &Daemon, me: &BotId, name: &str, need: Need) -> ApiResult<(Crew, Vec<BotId>)> {
+    let store = daemon.store();
+    let (own, _) = bots::active(&store, me)?;
+    let crew = crew_access::other_crew(&store, &own.id, name)?;
+    let mut owners = Vec::new();
+    for bot in store.bots(Some(&crew.id), false)? {
+        if crew_access::reaches(daemon, &store, me, &crew.id, Some(&bot.id), need)? {
+            owners.push(bot.id);
+        }
+    }
+    if owners.is_empty() {
+        let what = if need == Need::Edit { "edit" } else { "read" };
+        return Err(ApiError::Conflict(format!(
+            "you cannot {what} the files of the crew {}; if the owner wants you to, call \
+             ask_crew_access with `{what}` and why",
+            crew.name
+        )));
+    }
+    Ok((crew, owners))
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct FilesArgs {
+    crew: String,
+    #[serde(default)]
+    bot: Option<String>,
+}
+
+pub(super) fn files(daemon: &Daemon, me: &BotId, args: FilesArgs) -> ApiResult<Value> {
+    let (crew, mut owners) = owners(daemon, me, &args.crew, Need::Read)?;
+    if let Some(handle) = &args.bot {
+        let handle = botloft_core::slug::slugify(handle.trim().trim_start_matches('@'), "");
+        let id = daemon.store().active_bot_by_handle(&crew.id, &handle)?;
+        owners.retain(|owner| Some(owner) == id.as_ref());
+        if owners.is_empty() {
+            return Err(ApiError::NotFound(format!(
+                "you cannot read the files of @{handle} in the crew {}",
+                crew.name
+            )));
+        }
+    }
+    let mut found = Vec::new();
+    for owner in &owners {
+        for file in foreign_files(daemon, owner)? {
+            if !found
+                .iter()
+                .any(|seen: &botloft_core::protocol::BotFile| seen.path == file.path)
+            {
+                found.push(file);
+            }
+        }
+    }
+    found.sort_by_key(|file| std::cmp::Reverse(file.modified_at));
+    found.truncate(LIST_MAX);
+    let now = daemon.clock.now_ms();
+    let files: Vec<Value> = found
+        .iter()
+        .map(|file| {
+            json!({
+                "path": file.path,
+                "name": file.name,
+                "size": file.size,
+                "changed": ago(file.modified_at, now),
+            })
+        })
+        .collect();
+    Ok(json!({ "crew": crew.name, "files": files }))
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct ReadArgs {
+    crew: String,
+    path: String,
+}
+
+pub(super) fn read(daemon: &Daemon, me: &BotId, args: ReadArgs) -> ApiResult<Value> {
+    let (crew, owners) = owners(daemon, me, &args.crew, Need::Read)?;
+    let (path, size) = first(&owners, |owner| foreign_readable(daemon, owner, &args.path))?;
+    if size > TEXT_MAX {
+        return Err(ApiError::validation("the file is larger than 1 MB"));
+    }
+    let bytes = std::fs::read(&path).map_err(|_| ApiError::NotFound(args.path.clone()))?;
+    let text = String::from_utf8(bytes).map_err(|_| {
+        ApiError::validation("the file is not text; only text files can be read this way")
+    })?;
+    Ok(json!({ "crew": crew.name, "path": path.display().to_string(), "text": text }))
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct WriteArgs {
+    crew: String,
+    path: String,
+    content: String,
+}
+
+pub(super) fn write(daemon: &Daemon, me: &BotId, args: WriteArgs) -> ApiResult<Value> {
+    if args.content.len() as u64 > TEXT_MAX {
+        return Err(ApiError::validation("content must be at most 1 MB"));
+    }
+    let (crew, owners) = owners(daemon, me, &args.crew, Need::Edit)?;
+    let path = first(&owners, |owner| foreign_writable(daemon, owner, &args.path))?;
+    std::fs::write(&path, args.content.as_bytes())
+        .map_err(|err| ApiError::validation(format!("could not write the file: {err}")))?;
+    Ok(json!({
+        "crew": crew.name,
+        "path": path.display().to_string(),
+        "note": "Written. Tell the bots of that crew what you changed.",
+    }))
+}
+
+/// How long ago, for a reader who does not know the current time.
+fn ago(at_ms: i64, now_ms: i64) -> String {
+    let minutes = now_ms.saturating_sub(at_ms).max(0) / 60_000;
+    match minutes {
+        0 => "just now".to_owned(),
+        1..=89 => format!("{minutes} min ago"),
+        90..=2879 => format!("{} h ago", (minutes + 30) / 60),
+        _ => format!("{} days ago", minutes / 1440),
+    }
+}
+
+/// The first owner for whom `try_one` works, or the last error.
+fn first<T>(owners: &[BotId], try_one: impl Fn(&BotId) -> ApiResult<T>) -> ApiResult<T> {
+    let mut last = None;
+    for owner in owners {
+        match try_one(owner) {
+            Ok(found) => return Ok(found),
+            Err(err) => last = Some(err),
+        }
+    }
+    Err(last.unwrap_or_else(|| ApiError::NotFound("no file".into())))
+}
+
+/// `crew_roster` with `crew`: the bots of another crew the caller may reach.
+pub(super) fn roster(daemon: &Daemon, me: &BotId, name: &str) -> ApiResult<Value> {
+    let (crew, mine) = {
+        let store = daemon.store();
+        let (own, mine) = bots::active(&store, me)?;
+        (crew_access::other_crew(&store, &own.id, name)?, mine)
+    };
+    let list = bots::list(
+        daemon,
+        BotsListParams {
+            crew_id: Some(crew.id.clone()),
+        },
+    )?;
+    let store = daemon.store();
+    let mut reachable = Vec::new();
+    for bot in list {
+        let record = bots::find(&store, &bot.id)?;
+        if crew_access::may_talk(daemon, &store, &mine, &record)? {
+            reachable.push(json!({
+                "handle": bot.handle,
+                "name": bot.name,
+                "role": bot.role,
+                "state": bot.state,
+                "chief": lead::is_lead(&crew, &bot.id),
+            }));
+        }
+    }
+    if reachable.is_empty() {
+        return Err(ApiError::Conflict(format!(
+            "you cannot reach the crew {}; if the owner wants you to, call ask_crew_access with \
+             what you need and why",
+            crew.name
+        )));
+    }
+    Ok(json!({
+        "crew": crew.name,
+        "bots": reachable,
+        "note": format!("Write with send_message(to, crew: \"{}\").", crew.name),
+    }))
+}
diff --git a/crates/botloftd/src/tools/mod.rs b/crates/botloftd/src/tools/mod.rs
index 3d841650..666704a1 100644
--- a/crates/botloftd/src/tools/mod.rs
+++ b/crates/botloftd/src/tools/mod.rs
@@ -16,6 +16,7 @@ mod browser_sites;
 mod calls;
 mod catalog;
 mod crew_access;
+mod crew_reach;
 mod desktop;
 mod desktop_act;
 mod desktop_catalog;
diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs
index c0216516..07ac8a36 100644
--- a/crates/botloftd/src/workspace/files.rs
+++ b/crates/botloftd/src/workspace/files.rs
@@ -172,9 +172,11 @@ app; the other bots of your crew send you messages too.
 - Never call `permission_prompt` yourself; Claude Code uses it for approvals.
 - You can only reach bots of your own crew. Other crews are closed to you:
   only when the owner asks you to work with one of them, or with one of its
-  bots, call `ask_crew_access` with its name, what you need and why. Once
-  the owner allows it, `crew_roster` and `send_message` take `crew`. A bot
-  of another crew that writes to you can be answered the same way.
+  bots, call `ask_crew_access` with its name, what you need (`talk`, `read`
+  or `edit` its files) and why. Once the owner allows it, `crew_roster` and
+  `send_message` take `crew`, and `crew_files`, `read_crew_file` and
+  `write_crew_file` reach its files; your own file tools cannot. A bot of
+  another crew that writes to you can be answered the same way.
 - A task you receive ends with `complete_task`, also when you could not do it
   (`status: \"failed\"` and why): the bot that asked is waiting for it.
 - Do not wait in a loop for a reply. Finish your turn; the reply arrives as a
diff --git a/crates/botloftd/tests/crew_files.rs b/crates/botloftd/tests/crew_files.rs
new file mode 100644
index 00000000..d2aa1644
--- /dev/null
+++ b/crates/botloftd/tests/crew_files.rs
@@ -0,0 +1,195 @@
+//! Another crew's files (spec 10.4): closed until the owner lets a bot read
+//! or edit them, then reached only through `crew_files`, `read_crew_file`
+//! and `write_crew_file`, never the bots' memory and rules.
+
+mod common;
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use common::bots::ready_bot;
+use common::mcp::Mcp;
+use common::{Client, TestDaemon};
+use serde_json::{Value, json};
+use tokio::task::JoinHandle;
+
+struct Crews {
+    _t: TestDaemon,
+    app: Client,
+    scout_mcp: Mcp,
+    /// Blog's work folder and the writer's own folder.
+    work: PathBuf,
+    writer_folder: PathBuf,
+}
+
+fn put(path: &Path, text: &str) {
+    fs::create_dir_all(path.parent().expect("parent")).expect("dirs");
+    fs::write(path, text).expect("write");
+}
+
+async fn crews() -> Crews {
+    let t = TestDaemon::start_supervised().await;
+    let mut app = t.session().await;
+    let ops = app
+        .call("crews.create", json!({ "name": "Ops" }))
+        .await
+        .expect("ops");
+    let blog = app
+        .call("crews.create", json!({ "name": "Blog" }))
+        .await
+        .expect("blog");
+    let (_, _, scout_mcp) = ready_bot(&t, &mut app, &ops, "Scout").await;
+    let (writer, _, _) = ready_bot(&t, &mut app, &blog, "Writer").await;
+    let writer_folder = PathBuf::from(writer["workspace"].as_str().expect("workspace"));
+    let work = t.paths.shared_dir("blog");
+    put(&work.join("post.md"), "# The post");
+    put(&work.join("CLAUDE.md"), "Blog's rules");
+    put(&writer_folder.join("draft.md"), "draft");
+    Crews {
+        _t: t,
+        app,
+        scout_mcp,
+        work,
+        writer_folder,
+    }
+}
+
+fn ask(mcp: &Mcp, access: &[&str]) -> JoinHandle<Result<Value, String>> {
+    let mut mcp = Mcp::new(mcp.addr, mcp.token.clone());
+    let arguments =
+        json!({ "crew": "Blog", "bot": "writer", "access": access, "why": "The post." });
+    tokio::spawn(async move { mcp.tool("ask_crew_access", arguments).await })
+}
+
+async fn allow(app: &mut Client, scope: &str) {
+    loop {
+        let changed = app.notification("chat.item").await;
+        let body = &changed["item"]["body"];
+        if body["kind"] == "approval" && body["status"] == "pending" {
+            let input = json!({ "scope": scope }).to_string();
+            app.call(
+                "approvals.answer",
+                json!({ "approvalId": body["approvalId"], "allow": true, "input": input }),
+            )
+            .await
+            .expect("answer");
+            return;
+        }
+    }
+}
+
+fn path(of: &Path) -> String {
+    of.display().to_string()
+}
+
+#[tokio::test]
+async fn files_are_read_once_allowed_and_rules_stay_out_of_reach() {
+    let mut c = crews().await;
+    let closed = c
+        .scout_mcp
+        .tool("crew_files", json!({ "crew": "Blog" }))
+        .await
+        .expect_err("closed");
+    assert!(closed.contains("ask_crew_access"), "{closed}");
+
+    let waiting = ask(&c.scout_mcp, &["read"]);
+    allow(&mut c.app, "bot").await;
+    waiting.await.expect("task").expect("allowed");
+
+    let listed = c
+        .scout_mcp
+        .tool("crew_files", json!({ "crew": "Blog" }))
+        .await
+        .expect("files");
+    let mut names: Vec<&str> = listed["files"]
+        .as_array()
+        .expect("files")
+        .iter()
+        .filter_map(|file| file["name"].as_str())
+        .collect();
+    names.sort_unstable();
+    assert_eq!(names, ["draft.md", "post.md"]);
+
+    let read = c
+        .scout_mcp
+        .tool(
+            "read_crew_file",
+            json!({ "crew": "Blog", "path": path(&c.work.join("post.md")) }),
+        )
+        .await
+        .expect("read");
+    assert_eq!(read["text"], "# The post");
+    for kept in [c.work.join("CLAUDE.md"), c.writer_folder.join("CLAUDE.md")] {
+        let refused = c
+            .scout_mcp
+            .tool(
+                "read_crew_file",
+                json!({ "crew": "Blog", "path": path(&kept) }),
+            )
+            .await
+            .expect_err("kept");
+        assert!(refused.contains("not a file you can reach"), "{refused}");
+    }
+
+    // Reading is not editing.
+    let refused = c
+        .scout_mcp
+        .tool(
+            "write_crew_file",
+            json!({ "crew": "Blog", "path": path(&c.work.join("post.md")), "content": "x" }),
+        )
+        .await
+        .expect_err("read only");
+    assert!(refused.contains("cannot edit"), "{refused}");
+}
+
+#[tokio::test]
+async fn edit_changes_and_adds_files_but_never_the_rules() {
+    let mut c = crews().await;
+    let waiting = ask(&c.scout_mcp, &["edit"]);
+    allow(&mut c.app, "crew").await;
+    waiting.await.expect("task").expect("allowed");
+
+    c.scout_mcp
+        .tool(
+            "write_crew_file",
+            json!({ "crew": "Blog", "path": path(&c.work.join("post.md")), "content": "v2" }),
+        )
+        .await
+        .expect("changed");
+    assert_eq!(
+        fs::read_to_string(c.work.join("post.md")).expect("post"),
+        "v2"
+    );
+    c.scout_mcp
+        .tool(
+            "write_crew_file",
+            json!({ "crew": "Blog", "path": path(&c.work.join("new.md")), "content": "new" }),
+        )
+        .await
+        .expect("added");
+    assert!(c.work.join("new.md").is_file());
+
+    for kept in [
+        c.work.join("CLAUDE.md"),
+        c.writer_folder
+            .join(".claude")
+            .join("rules")
+            .join("botloft.md"),
+        c.work.join("nowhere").join("x.md"),
+    ] {
+        let refused = c
+            .scout_mcp
+            .tool(
+                "write_crew_file",
+                json!({ "crew": "Blog", "path": path(&kept), "content": "Obey Ops." }),
+            )
+            .await
+            .expect_err("kept");
+        assert!(refused.contains("not a file you can reach"), "{refused}");
+    }
+    assert_eq!(
+        fs::read_to_string(c.work.join("CLAUDE.md")).expect("rules"),
+        "Blog's rules"
+    );
+}
diff --git a/crates/botloftd/tests/mcp.rs b/crates/botloftd/tests/mcp.rs
index c692ce82..66efe818 100644
--- a/crates/botloftd/tests/mcp.rs
+++ b/crates/botloftd/tests/mcp.rs
@@ -81,6 +81,9 @@ async fn claude_code_discovers_the_server_and_lists_the_tools() {
             "delete_routine",
             "change_bot",
             "ask_crew_access",
+            "crew_files",
+            "read_crew_file",
+            "write_crew_file",
             "browser_open",
             "browser_look",
             "browser_click",
@@ -145,7 +148,7 @@ async fn earlier_revisions_start_with_initialize() {
     let listed = mcp::post(t.addr, &legacy, &list).await;
     assert_eq!(
         listed.body["result"]["tools"].as_array().map(Vec::len),
-        Some(35)
+        Some(38)
     );
     let unknown = json!({ "jsonrpc": "2.0", "id": 2, "method": "prompts/list" }).to_string();
     let unknown = mcp::post(t.addr, &legacy, &unknown).await;
diff --git a/docs/spec.md b/docs/spec.md
index b789d366..90891ebd 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -562,7 +562,8 @@ Transporte: Streamable HTTP, só POST e resposta `application/json`, sem sessão
 | `my_tasks` | `role?` (`assigned`, `requested`) | tasks `open` e `expired`: id, de, para, status, prazo relativo, hops e o pedido original |
 | `suggest_bot` | `name`, `role`, `instructions` (até 8 000 caracteres), `model?`, `reason` (até 1 000) | `created` e, criado, `handle`, `name`, `role`, `model` e um lembrete para mandar a primeira task; recusado ou sem resposta, o porquê (10.2). Só o chefe |
 | `schedule_routine` | `name`, `prompt` (até 8 000 caracteres), `schedule` (como em 20.2), `bot?` (handle de outro bot da crew) | `created` e, criada, `routine_id`, nome, pedido, horário, fuso e a próxima vez; recusada ou sem resposta, o aviso de que nada foi agendado (20.12) |
-| `ask_crew_access` | `crew` (nome da outra crew), `bot?` (handle de um bot dela), `access` (`["talk"]`), `why` (até 1 000) | `allowed` e, permitido, como usar; recusado ou sem resposta, o porquê (10.4) |
+| `ask_crew_access` | `crew` (nome da outra crew), `bot?` (handle de um bot dela), `access` (`talk`, `read`, `edit`), `why` (até 1 000) | `allowed` e, permitido, como usar; recusado ou sem resposta, o porquê (10.4) |
+| `crew_files`, `read_crew_file`, `write_crew_file` | `crew`, e `bot?`, `path` ou `path` e `content` | os arquivos de outra crew que o bot alcança, o texto de um, ou o aviso de que gravou (10.4) |
 | `change_bot` | `bot?` (handle de outro bot da crew, só o chefe), `name?`, `role?`, `instructions?` (até 8 000 caracteres), `reason?` (até 1 000) | `done` e, mudado, `handle`, `name`, `role` e quando vale; recusado ou sem resposta, o aviso de que nada mudou (10.3) |
 | `share_file` | `files` (1 a 10 caminhos, absolutos ou relativos à pasta do bot) | `shown` (um `BotFile` por arquivo, 8.4) e um lembrete de que o dono vê cada um como cartão no chat; um arquivo fora das pastas do bot e não escrito por ele, ou que não existe, recusa a chamada inteira e diz qual e por quê |
 | `send_signal` | `name`, `note?` (até 2 000 caracteres) | o aviso normalizado e, para cada rotina da crew que o espera, se rodou e por que não (20.13) |
@@ -633,13 +634,14 @@ Quando o dono pede, um bot pode mudar o próprio nome, papel ou instruções, e
 
 ### 10.4 Bots que alcançam outra crew
 
-Crews não se enxergam (7.5, 10). Quando o dono pede, um bot pode pedir para alcançar outra crew, ou um bot dela, com `ask_crew_access`: o nome da crew como o dono deu (nome ou pasta, sem diferença de maiúsculas; a própria crew dá erro), o handle do bot se for um só, o que quer (`talk`: ver os bots de lá e mandar mensagens e tasks) e por quê. Ler e editar arquivos de outra crew ficam para depois.
+Crews não se enxergam (7.5, 10). Quando o dono pede, um bot pode pedir para alcançar outra crew, ou um bot dela, com `ask_crew_access`: o nome da crew como o dono deu (nome ou pasta, sem diferença de maiúsculas; a própria crew dá erro), o handle do bot se for um só, o que quer (`talk`: ver os bots de lá e mandar mensagens e tasks; `read`: listar e ler os arquivos; `edit`: também mudar e criar arquivos, o que inclui ler) e por quê.
 
 - **Pedido:** um pedido no chat de quem pede, `toolName: "mcp__botloft__ask_crew_access"`, com entrada `crew_id`, `crew`, `bot_id`, `bot`, `handle`, `access` e `why`; o resumo é o nome da crew. A chamada espera a resposta. Um pedido do que o bot já alcança volta na hora, sem pedido. Quem está em `bypass_permissions` recebe o acesso só para a vez, sem perguntar.
-- **Resposta:** Negar, ou permitir com `approvals.answer` e `input` `{"scope": ...}`: `once` (só agora, o padrão sem `input`), `bot` (sempre, só o bot pedido; recusado se o pedido era a crew) ou `crew` (sempre, a crew inteira). "Só agora" fica em memória e vale até o fim da vez do bot (o `result` do turno ou o fim do processo). "Sempre" vai para a tabela `crew_access` (bot, crew, bot alvo ou nenhum, `talk`), que guarda o que já tinha e soma o novo; apagar o bot, o alvo ou a crew apaga a linha.
+- **Resposta:** Negar, ou permitir com `approvals.answer` e `input` `{"scope": ...}`: `once` (só agora, o padrão sem `input`), `bot` (sempre, só o bot pedido; recusado se o pedido era a crew) ou `crew` (sempre, a crew inteira). "Só agora" fica em memória e vale até o fim da vez do bot (o `result` do turno ou o fim do processo). "Sempre" vai para a tabela `crew_access` (bot, crew, bot alvo ou nenhum, `talk`, `read`, `edit`), que guarda o que já tinha e soma o novo; apagar o bot, o alvo ou a crew apaga a linha.
 - **Com acesso:** `crew_roster` com `crew` lista só os bots de lá que o bot alcança; `send_message` com `crew` manda nota ou task a um deles. Um bot fora de alcance e um que não existe dão o mesmo erro, que manda pedir com `ask_crew_access`.
+- **Arquivos:** só pelas tools do Botloft (`crew_files {crew, bot?}`, `read_crew_file {crew, path}`, `write_crew_file {crew, path, content}`, texto até 1 MB): as cercas de 7.5 continuam tirando as pastas de outras crews das ferramentas de arquivo do próprio Claude Code. Um bot alcança a pasta dele e a pasta de trabalho da crew dele; a crew inteira, a pasta de trabalho e as pastas de todos os bots. Nunca um arquivo que o bot escreveu fora dessas pastas, nem, no topo de qualquer uma delas, `CLAUDE.md`, `CLAUDE.local.md`, `.claude`, `.botloft` e `attachments`: memória, regras e anexos do dono. Assim um bot de fora não dá instruções aos bots da outra crew. `crew_files` lista como o painel de arquivos (8.4), até 200, do mais novo, com há quanto tempo mudou; `write_crew_file` troca um arquivo que existe ou cria um numa pasta que já existe. Fora de alcance e inexistente dão o mesmo erro.
 - **Resposta do outro lado:** o bot que recebe pode responder a quem escreveu sem pedir: a quem tem acesso a ele, ou a um bot de outra crew que lhe escreveu nas últimas 24 horas (bots conversam em vezes; a resposta costuma chegar depois que a vez com acesso acabou). `complete_task` não depende de acesso: só o designado completa a task.
-- **No app:** o cartão diz "<bot> quer acessar a equipe <crew>" ou "<bot> quer acessar <bot>, da equipe <crew>", o que o bot quer lá ("Conversar com ...: ver quem está lá e mandar mensagens e tarefas") e o porquê, com Só agora, Sempre <bot> (só num pedido de um bot), Sempre a equipe <crew> e Negar, e o campo para dizer por que não. A resposta guarda, no lugar da entrada, o pedido com `scope`, e o cartão respondido diz por quanto tempo. Nos detalhes do bot, "Outras equipes" lista o que ele alcança sempre (`crewAccess.list`), com um botão para tirar cada um (`crewAccess.revoke`); a lista é lida de novo quando um pedido desses é respondido. IDs com o prefixo `cxa_`.
+- **No app:** o cartão diz "<bot> quer acessar a equipe <crew>" ou "<bot> quer acessar <bot>, da equipe <crew>", o que o bot quer lá ("Conversar com ...: ver quem está lá e mandar mensagens e tarefas", "Ler os arquivos de ... e da pasta de trabalho", "Mudar e criar arquivos de ...") e o porquê, com Só agora, Sempre <bot> (só num pedido de um bot), Sempre a equipe <crew> e Negar, e o campo para dizer por que não. A resposta guarda, no lugar da entrada, o pedido com `scope`, e o cartão respondido diz por quanto tempo. Nos detalhes do bot, "Outras equipes" lista o que ele alcança sempre (`crewAccess.list`, com `talk`, `read` e `edit`) e o que pode fazer lá, com um botão para tirar cada um (`crewAccess.revoke`); a lista é lida de novo quando um pedido desses é respondido. IDs com o prefixo `cxa_`.
 - **Onde fica:** a mensagem e a task entre crews são da crew de quem recebe, e o resultado e o aviso de prazo, da crew de quem pediu. Assim cada crew só guarda o que é para os bots dela, e apagar uma crew não deixa nada pendurado. `my_tasks` mostra um bot de outra crew como "writer of crew Blog".
 
 ## 11. Protocolo do app (JSON-RPC 2.0 sobre WebSocket)