@@ -378,6 +378,34 @@ describe("buildCorePosixToolPlugins", () => {
     }
   });
 
+  test("evidence archive search sits after shell-guard so grep/search inherit the 10s budget", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "ic-posix-plugins-"));
+    try {
+      const gate = createPermissionGate({
+        approvals: [],
+        interactive: false,
+        skipPermissions: true,
+        reactorGated: false,
+        cwd,
+      });
+      const plugins = buildCorePosixToolPlugins({
+        cwd,
+        permissionGate: gate,
+        getEvidenceArchive: () => undefined,
+      });
+      const shellGuardIndex = findMiddlewareIndex(plugins, "[command timed out after");
+      const archiveIndex = findMiddlewareIndex(
+        plugins,
+        "evidence archive is not available in this session",
+      );
+      expect(shellGuardIndex).toBeGreaterThanOrEqual(0);
+      expect(archiveIndex).toBeGreaterThanOrEqual(0);
+      expect(archiveIndex).toBeGreaterThan(shellGuardIndex);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
   test("a real line-range edit_file call verifies as success through the wired plugin chain", async () => {
     const cwd = await mkdtemp(join(tmpdir(), "ic-posix-plugins-"));
     try {
 
@@ -106,7 +106,6 @@ export function buildCorePosixToolPlugins(
     resultTruncationPlugin(truncationOptions),
     toolResultSecretScrubPlugin(),
     pathEscapePlugin(cwd, createWorktreeRootsProvider(cwd), { allowOutside }),
-    ...(getEvidenceArchive !== undefined ? [evidenceArchiveSearchPlugin(getEvidenceArchive)] : []),
     evidenceArchivePathGuardPlugin(),
     deleteFilePlugin(cwd, { allowOutside }),
     toolOutputUriPlugin(),
@@ -119,6 +118,9 @@ export function buildCorePosixToolPlugins(
         ? { getBackgroundShellRegistry }
         : {}),
     }),
+    ...(getEvidenceArchive !== undefined
+      ? [evidenceArchiveSearchPlugin(getEvidenceArchive)]
+      : []),
     readFileGuardPlugin(cwd, readFileGuard),
     ripgrepPlugin(cwd),
     // Verify wraps the line-range short-circuit (composeMiddleware runs plugins
 
@@ -226,16 +226,16 @@ export function buildPromptDisciplineBlock(
 
 const TOOL_SUMMARIES: Record<string, string> = {
   read_file:
-    "read a file, tool-output:///{callId} from a prior tool result, or archive:///{occurrenceId} (prefer over cat/head/tail in the shell). Only read_file a tool-output:// URI if the truncation notice named one",
+    "read a file or tool-output:///{callId} from a prior tool result (prefer over cat/head/tail in the shell). Only read_file a tool-output:// URI if the truncation notice named one",
   write_file: "create or overwrite a file (never shell redirects or heredocs)",
   edit_file:
     "make a surgical edit (exact old_string match, or start_line/end_line line-range mode; never include read_file's NNNNNN\\t line prefix; substring failures include nearby file text; prefer over sed/awk in the shell)",
   delete_file: "delete one file with an explicit outcome (never shell rm)",
   run_shell:
     "run a shell command (builds, tests, git; pass timeout ms to bound long commands; never to read/write/delete files, search trees, or talk to the user)",
   search_files:
-    "find files by name or pattern (bounded; timeout + output caps — safer than open-ended shell find); path archive:/// lists evidence-archive refs",
-  grep: "search file contents (bounded; timeout + output caps — safer than open-ended shell grep -r/rg); path archive:/// searches this session's evidence archive",
+    "find files by name or pattern (bounded; timeout + output caps — safer than open-ended shell find)",
+  grep: "search file contents (bounded; timeout + output caps — safer than open-ended shell grep -r/rg)",
   list_dir: "list a directory's entries (bounded listing)",
   lsp: "resolve symbols — goToDefinition, findReferences, hover (prefer before reading huge files)",
   web_search: "search the web (use instead of curl or wget)",
@@ -263,11 +263,24 @@ const TOOL_SUMMARIES: Record<string, string> = {
     "look up skill descriptions by capability (catalog — call directly, do not tool_search for this)",
 };
 
+const ARCHIVE_TOOL_SUMMARIES: Partial<Record<string, string>> = {
+  read_file:
+    "read a file, tool-output:///{callId} from a prior tool result, or archive:///{occurrenceId} (prefer over cat/head/tail in the shell). Only read_file a tool-output:// URI if the truncation notice named one",
+  search_files:
+    "find files by name or pattern (bounded; timeout + output caps — safer than open-ended shell find); path archive:/// lists evidence-archive refs",
+  grep: "search file contents (bounded; timeout + output caps — safer than open-ended shell grep -r/rg); path archive:/// searches this session's evidence archive",
+};
+
 export function buildAvailableTools(
   tools: readonly string[] = CORE_TOOL_NAMES,
+  opts: { advertiseArchive?: boolean } = {},
 ): string {
+  const summaries =
+    opts.advertiseArchive === true
+      ? { ...TOOL_SUMMARIES, ...ARCHIVE_TOOL_SUMMARIES }
+      : TOOL_SUMMARIES;
   const lines = tools.map(
-    (tool) => `- ${tool}: ${TOOL_SUMMARIES[tool] ?? "available"}`,
+    (tool) => `- ${tool}: ${summaries[tool] ?? "available"}`,
   );
   return ["Tools:", ...lines].join("\n");
 }
@@ -365,6 +378,7 @@ export function buildChatSystemPrompt(
     baseSection(baseOverride, sessionMode),
     buildAvailableTools(
       coreToolNamesForSessionMode(sessionMode, toolAvailability),
+      { advertiseArchive: true },
     ),
   ];
   if (skills.length > 0) sections.push(buildSkillsSection(skills));
 
@@ -210,6 +210,87 @@ describe("evidenceArchiveSearchPlugin", () => {
     );
     expect(result.content).toBe("passthrough:grep");
   });
+
+  test("grep pattern archive searches payloads and metadata, not the URI line", async () => {
+    const archive = memoryArchive("sess-uri");
+    const occ = await archive.recordAuthorizedPayload({
+      kind: "user_message",
+      payload: "plain-payload-without-scheme",
+    });
+    const plugin = evidenceArchiveSearchPlugin(() => archive);
+    const handler = plugin.middleware ? plugin.middleware(nextHandler) : nextHandler;
+
+    const uriHits = await handler(
+      makeCall("grep", { pattern: "archive", path: "archive:///" }),
+      new AbortController().signal,
+    );
+    expect(String(uriHits.content)).toContain("no matches");
+    expect(String(uriHits.content)).not.toContain(formatArchiveRef(occ.occurrenceId));
+
+    const payloadHits = await handler(
+      makeCall("grep", { pattern: "plain-payload-without-scheme", path: "archive:///" }),
+      new AbortController().signal,
+    );
+    expect(String(payloadHits.content)).toContain(formatArchiveRef(occ.occurrenceId));
+    expect(String(payloadHits.content)).toContain("plain-payload-without-scheme");
+  });
+
+  test("archive grep and search_files honor abort before loading remaining payloads", async () => {
+    const archive = memoryArchive("sess-abort");
+    const first = await archive.recordAuthorizedPayload({
+      kind: "user_message",
+      payload: "abort-first",
+    });
+    await archive.recordAuthorizedPayload({
+      kind: "assistant_text",
+      payload: "abort-second",
+    });
+    const plugin = evidenceArchiveSearchPlugin(() => archive);
+    const handler = plugin.middleware ? plugin.middleware(nextHandler) : nextHandler;
+    const controller = new AbortController();
+    const reads: string[] = [];
+    const orig = archive.readAuthorizedPayload.bind(archive);
+    archive.readAuthorizedPayload = async (occurrenceId) => {
+      reads.push(occurrenceId);
+      if (reads.length === 1) controller.abort();
+      return orig(occurrenceId);
+    };
+
+    const grepResult = await handler(
+      makeCall("grep", { pattern: "abort-second", path: "archive:///" }),
+      controller.signal,
+    );
+    expect(grepResult.isError).toBe(true);
+    expect(String(grepResult.content).toLowerCase()).toMatch(/abort/);
+    expect(reads).toEqual([first.occurrenceId]);
+
+    const searchController = new AbortController();
+    searchController.abort();
+    const searchResult = await handler(
+      makeCall("search_files", { pattern: "*", path: "archive:///" }),
+      searchController.signal,
+    );
+    expect(searchResult.isError).toBe(true);
+    expect(String(searchResult.content).toLowerCase()).toMatch(/abort/);
+  });
+
+  test("archive grep includes posix-style context around payload matches", async () => {
+    const archive = memoryArchive("sess-context");
+    const occ = await archive.recordAuthorizedPayload({
+      kind: "tool_result",
+      payload: "alpha\nbeta-hit\ngamma",
+    });
+    const plugin = evidenceArchiveSearchPlugin(() => archive);
+    const handler = plugin.middleware ? plugin.middleware(nextHandler) : nextHandler;
+    const hits = await handler(
+      makeCall("grep", { pattern: "beta-hit", path: "archive:///", context: 1 }),
+      new AbortController().signal,
+    );
+    const ref = formatArchiveRef(occ.occurrenceId);
+    expect(String(hits.content)).toContain(`${ref}-1-alpha`);
+    expect(String(hits.content)).toContain(`${ref}:2:beta-hit`);
+    expect(String(hits.content)).toContain(`${ref}-3-gamma`);
+  });
 });
 
 describe("createAgentToolset archive mount", () => {
@@ -233,6 +314,14 @@ describe("createAgentToolset archive mount", () => {
       .currentDefinitions()
       .find((d) => d.name === "read_file");
     expect(workerRead?.description ?? "").not.toContain("archive:///");
+    const workerGrep = worker.dynamicRunner.currentDefinitions().find((d) => d.name === "grep");
+    expect(workerGrep?.description ?? "").not.toContain("archive:///");
+    expect(JSON.stringify(workerGrep?.inputSchema ?? {})).not.toContain("archive:///");
+    const workerSearch = worker.dynamicRunner
+      .currentDefinitions()
+      .find((d) => d.name === "search_files");
+    expect(workerSearch?.description ?? "").not.toContain("archive:///");
+    expect(JSON.stringify(workerSearch?.inputSchema ?? {})).not.toContain("archive:///");
     await worker.dispose();
 
     const primary = await createAgentToolset({
 
@@ -174,7 +174,13 @@ export function evidenceArchiveSearchPlugin(
           const maxResults = num(call.arguments.max_results) ?? SEARCH_DEFAULT_MAX;
           return {
             callId: call.id,
-            content: await searchArchiveFiles(archive, pattern, target.occurrenceId, maxResults),
+            content: await searchArchiveFiles(
+              archive,
+              pattern,
+              target.occurrenceId,
+              maxResults,
+              signal,
+            ),
           };
         }
         const pattern = str(call.arguments.pattern);
@@ -187,9 +193,19 @@ export function evidenceArchiveSearchPlugin(
         }
         const maxResults = num(call.arguments.max_results) ?? GREP_DEFAULT_MAX;
         const glob = str(call.arguments.glob);
+        const contextArg = num(call.arguments.context);
+        const context = contextArg !== undefined && contextArg > 0 ? Math.floor(contextArg) : 0;
         return {
           callId: call.id,
-          content: await grepArchive(archive, pattern, target.occurrenceId, maxResults, glob),
+          content: await grepArchive(
+            archive,
+            pattern,
+            target.occurrenceId,
+            maxResults,
+            glob,
+            context,
+            signal,
+          ),
         };
       } catch (err) {
         return {
@@ -232,10 +248,13 @@ async function searchArchiveFiles(
   pattern: string,
   occurrenceId: string | undefined,
   maxResults: number,
+  signal: AbortSignal,
 ): Promise<string> {
+  signal.throwIfAborted();
   const occurrences = await selectOccurrences(archive, occurrenceId);
   const hits: string[] = [];
   for (const occ of occurrences) {
+    signal.throwIfAborted();
     if (hits.length >= maxResults) break;
     if (!matchesArchiveName(pattern, occ)) continue;
     hits.push(formatArchiveRef(occ.occurrenceId));
@@ -246,13 +265,58 @@ async function searchArchiveFiles(
   return hits.join("\n");
 }
 
+function grepPayloadHits(
+  ref: string,
+  lines: string[],
+  regex: RegExp,
+  context: number,
+  remaining: number,
+): string[] {
+  if (remaining <= 0) return [];
+  const matchLines: number[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (regex.test(lines[i] ?? "")) matchLines.push(i);
+    if (matchLines.length >= remaining) break;
+  }
+  if (matchLines.length === 0) return [];
+  if (context <= 0) {
+    return matchLines.map((i) => `${ref}:${i + 1}:${lines[i] ?? ""}`);
+  }
+  const matchSet = new Set(matchLines);
+  const ranges: { start: number; end: number }[] = [];
+  for (const i of matchLines) {
+    const start = Math.max(0, i - context);
+    const end = Math.min(lines.length - 1, i + context);
+    const prev = ranges[ranges.length - 1];
+    if (prev !== undefined && start <= prev.end + 1) {
+      prev.end = end;
+    } else {
+      ranges.push({ start, end });
+    }
+  }
+  const out: string[] = [];
+  let first = true;
+  for (const range of ranges) {
+    if (!first) out.push("--");
+    first = false;
+    for (let i = range.start; i <= range.end; i++) {
+      const sep = matchSet.has(i) ? ":" : "-";
+      out.push(`${ref}${sep}${i + 1}${sep}${lines[i] ?? ""}`);
+    }
+  }
+  return out;
+}
+
 async function grepArchive(
   archive: CompactionArchive,
   pattern: string,
   occurrenceId: string | undefined,
   maxResults: number,
   glob: string | undefined,
+  context: number,
+  signal: AbortSignal,
 ): Promise<string> {
+  signal.throwIfAborted();
   let regex: RegExp;
   try {
     regex = new RegExp(pattern);
@@ -262,26 +326,26 @@ async function grepArchive(
   const occurrences = await selectOccurrences(archive, occurrenceId);
   const hits: string[] = [];
   for (const occ of occurrences) {
+    signal.throwIfAborted();
     if (hits.length >= maxResults) break;
     if (glob !== undefined && !matchesArchiveName(glob, occ)) continue;
     const ref = formatArchiveRef(occ.occurrenceId);
-    if (regex.test(metadataBlob(occ)) || regex.test(formatHit(occ))) {
+    if (regex.test(metadataBlob(occ))) {
       hits.push(`${ref}:1:${formatHit(occ)}`);
       continue;
     }
     if (occ.gap === true) continue;
     let payload: string;
     try {
       payload = await archive.readAuthorizedPayload(occ.occurrenceId);
-    } catch {
+    } catch (err) {
+      if (signal.aborted) throw err;
       continue;
     }
-    const lines = payload.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      if (hits.length >= maxResults) break;
-      const line = lines[i] ?? "";
-      if (regex.test(line)) hits.push(`${ref}:${i + 1}:${line}`);
-    }
+    signal.throwIfAborted();
+    hits.push(
+      ...grepPayloadHits(ref, payload.split("\n"), regex, context, maxResults - hits.length),
+    );
   }
   if (hits.length === 0) return `no matches for /${pattern}/`;
   return hits.join("\n");
 
@@ -432,6 +432,17 @@ test("sub-agent prompt does not advertise tool_search (it gets the full toolset)
   expect(prompt).toContain("your full toolset");
 });
 
+test("worker prompt does not advertise archive:///; primary chat prompt does", () => {
+  const worker = buildSubAgentSystemPrompt();
+  expect(worker).not.toContain("archive:///");
+  const primary = buildChatSystemPrompt();
+  expect(primary).toContain("archive:///");
+  expect(buildAvailableTools(["read_file", "grep", "search_files"])).not.toContain("archive:///");
+  expect(
+    buildAvailableTools(["read_file", "grep", "search_files"], { advertiseArchive: true }),
+  ).toContain("archive:///");
+});
+
 // Pins the appendix-last invariant for JS-plugin agents: regardless of how the
 // systemPromptRole is sourced (data-only markdown vs. a JS plugin's
 // `agentPlugin.agents[i].systemPromptRole`), `buildSubAgentSystemPrompt` is