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)