@allansantos-dev/smart-tool 0.9.41 → 0.9.43

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.9.43 - beta
+
+- The session-start audit report (Claude Code and Codex) is also given after a compaction and after a fork, the two
+  starts that drop the earlier context; an installed hook shows as outdated until "Update hook" on the setup page, and
+  Codex asks for approval again in `/hooks`. The index scope prompt names PPTX, XLSX and PDF next to DOCX.
+
+## 0.9.42 - beta
+
+- Presentations and workbooks of the project are searchable. `.pptx` text comes out per slide under `[slide N]`, with the
+  speaker notes under `[notes N]`; `.xlsx` per sheet under `[sheet NAME]`, one tab-separated line per row, cached formula
+  values (nothing is calculated), shared and inline strings resolved. They go through the same zip and XML guards as
+  `.docx` and `.pdf` (10 MiB, 2000 entries, no encryption, no DOCTYPE or ENTITY, 8 MiB of XML, 1 MiB of text), plus 100,000
+  rows and 16,384 columns for a workbook; a corrupt, hostile or oversized file is skipped with the reason and the rest of the
+  project is indexed. `document_text.VERSION` is 3: `.docx` and `.pdf` already indexed are read once more. Measurement
+  before and after in `docs/research/data/office-probe-*.json`; tests in `tests/test_office_index.py`. A CSV of 1 MiB is
+  indexed and searched in 4 ms; one of 20 MiB is refused as `over size limit` in the index stats, without stalling.
+- The session-start audit report works in Codex. The Setup audit page turns on the SessionStart hook for Claude Code or
+  Codex (preview, confirm, backup, remove only ours); Codex runs a new hook only after you approve it in `/hooks`, so the page
+  shows "installed, waiting for your approval in /hooks" until the approval is found in `config.toml`, and the first-search
+  audit line keeps showing until then. Research with the primary sources in
+  `docs/research/2026-10-27-codex-sessionstart-hook.md`; tests in `tests/test_codex_audit_hook.py`.
+- Review fixes: a workbook cell reference past column XFD, a negative shared-string index, a corrupt deflate stream and
+  a newline in a sheet name no longer escape as `MemoryError`, `zlib.error`, a wrong text or a forged `[sheet ...]` line;
+  the tests of the Codex hook ignore `CODEX_HOME` and `CLAUDE_CONFIG_DIR` so they never write outside their temporary home.
+
 ## 0.9.41 - beta
 
 - Far fewer calls to the embedding and rerank models. Measured on a real machine (24 h): 8303 embedding and 1473 rerank

package/README.md

@@ -16,7 +16,7 @@ registered as the `playwright` server where this machine lets a browser be drive
 An optional hook routes the agent's native Grep/Glob/Read/Bash/WebSearch/WebFetch calls to these tools when they
 are cheaper, or just tells the agent what Smart Tool would do.
 
-**Status:** 0.9.41 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.43 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 
@@ -191,7 +191,10 @@ Redirects) and Maintenance (Setup audit, Startup).
 
    **Dependency check on edit**: an edit of `package.json`, `requirements*.txt` or `go.mod` that adds or changes a dependency lists the OSV advisory IDs of up to 5 of them (exact version, or the lower bound of `^`, `~`, `~=` and `>=`), answered from a 6 h disk cache or one 2.5 s batch call that sends only package names and versions; when OSV cannot answer, the reminder says the check was skipped and the edit goes on. `dependency_mode` in `config.json`: `warn` (default) or `off`.
 
-   **PDFs** inside a project are indexed as text with `[page N]` markers (20 MiB, 300 pages and 20 s per file; a scanned, password-protected or corrupt PDF is skipped with the reason), so `smart_search` returns the page that holds a passage.
+   **PDFs** inside a project are indexed as text with `[page N]` markers (20 MiB, 300 pages and 20 s per file; a scanned, password-protected or corrupt PDF is skipped with the reason), so `smart_search` returns the page that holds a passage. **Presentations and workbooks** (`.pptx`, `.xlsx`) are indexed the
+   same way: text of each slide under `[slide N]` with the speaker notes under `[notes N]`, each sheet under `[sheet NAME]` with one
+   tab-separated line per row (cached formula values; 100,000 rows or 1 MiB of text at most). Older formats (`.ppt`, `.xls`,
+   `.xlsm`) are not read.
 
    **Block patterns waiting for you** are shown in one approval panel: 8 per page, the ones that would have blocked
    the most logged calls first, a filter over pattern, reason and example, and bulk accept or reject of the selected
@@ -232,9 +235,10 @@ Redirects) and Maintenance (Setup audit, Startup).
    folder (or the nearest audited parent) without auditing again, and fails with what to do when none is stored. On
    its first `smart_search` of a session, and once per folder, the agent also gets one short line (under 100 tokens)
    when the stored report holds errors or warnings; a clean report adds nothing. Optionally, **Report at session
-   start (Claude Code)** on the Setup audit page moves that line to the start of every new session: it previews the
-   exact SessionStart entry, adds it to `~/.claude/settings.json` only after you confirm (backup first), and **Turn
-   off** removes only that entry. It is off by default; while it is on, the search no longer repeats the line. The
+   start** on the Setup audit page (Claude Code or Codex) moves that line to the start of every new session: it
+   previews the exact SessionStart entry, adds it to `~/.claude/settings.json` or `~/.codex/hooks.json` only after you
+   confirm (backup first), and **Turn off** removes only that entry. Codex runs a new hook only after you approve it in
+   `/hooks`; until then the page shows "waiting for your approval" and the search keeps repeating the line. It is off by default; while it is on, the search no longer repeats the line. The
    hook script (`hooks/session_audit.py`) only reads the stored report from the running service and prints nothing
    when the service is down.
 4. **Local models** (optional): if the mcp-memory embedding sidecar is installed on the machine, its local embedder

package/client_hooks.py

@@ -1,9 +1,11 @@
+import hashlib
 import json
 import os
 import secrets
 import shutil
 import sys
 import time
+import tomllib
 
 import daemon_launcher
 import endpoint_sync
@@ -12,8 +14,11 @@ HOOK_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hooks",
 MARKER = "pretool_router.py"
 AUDIT_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hooks", "session_audit.py")
 AUDIT_MARKER = "session_audit.py"
-AUDIT_MATCHER = "startup|resume|clear"
+AUDIT_MATCHER = "startup|resume|clear|compact|fork"
 AUDIT_TIMEOUT_S = 10
+AUDIT_CLIENTS = ("claude", "codex")
+AUDIT_ON = "current"
+AUDIT_WAITING = "waiting_approval"
 HTTP_PATH = "/hooks/pretool"
 POST_PATH = "/hooks/posttool"
 # A redirected shell search waits for its answer in the PreToolUse (smart_tool_daemon.HOOK_SHELL_BUDGET_S).
@@ -282,9 +287,16 @@ def _audit_entry():
                        "timeout": AUDIT_TIMEOUT_S}]}
 
 
-def _audit_plan():
-    """(path, data, groups) of Claude Code's settings with our SessionStart entry already removed from groups."""
-    path = os.path.realpath(CLIENTS["claude"]["files"][0])
+def _audit_client(client):
+    """The client's config spec; only Claude Code and Codex fire a SessionStart hook whose output the model reads."""
+    if client not in AUDIT_CLIENTS:
+        raise ValueError(f"The session-start audit report is only available for Claude Code or Codex, not {client!r}.")
+    return CLIENTS[client]
+
+
+def _audit_plan(client="claude"):
+    """(path, data, groups) of the client's hooks file with our SessionStart entry already removed from groups."""
+    path = os.path.realpath(_audit_client(client)["files"][0])
     try:
         with open(path, encoding="utf-8") as stream:
             data = json.load(stream)
@@ -299,10 +311,52 @@ def _audit_plan():
     return path, data, groups
 
 
-def audit_state():
-    """The SessionStart audit hook in Claude Code's settings: `current` (our entry equals this version's), `outdated`
-    (an entry of ours that differs) or `missing`."""
-    path = CLIENTS["claude"]["files"][0]
+def _codex_hash(event, group, index=0):
+    """Codex's approval hash (`sha256:` of the key-sorted compact JSON of the normalized hook identity, as in
+    openai/codex hooks/src/engine/discovery.rs `hook_hash`) of the handler at `index` in a hooks.json group."""
+    handler = group["hooks"][index]
+    normalized = {"type": handler["type"], "command": handler["command"], "timeout": handler.get("timeout", 600),
+                  "async": bool(handler.get("async", False))}
+    if handler.get("statusMessage") is not None:
+        normalized["statusMessage"] = handler["statusMessage"]
+    identity = {"event_name": event, "hooks": [normalized]}
+    if group.get("matcher") is not None:
+        identity["matcher"] = group["matcher"]
+    text = json.dumps(identity, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return "sha256:" + hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _codex_approved(groups):
+    """Our SessionStart handler is trusted in Codex's config.toml: the entry keyed by hooks.json path, event, group
+    and handler index holds the hash of the definition as it is now (a missing or different hash means /hooks has not
+    approved it, so Codex does not run it). An unreadable config.toml raises ValueError."""
+    spec = CLIENTS["codex"]
+    try:
+        with open(spec["files"][1], encoding="utf-8") as stream:
+            hooks = tomllib.loads(stream.read()).get("hooks")
+            states = hooks.get("state") if isinstance(hooks, dict) else None
+            states = states if isinstance(states, dict) else {}
+    except FileNotFoundError:
+        return False
+    except tomllib.TOMLDecodeError as exc:
+        raise ValueError(f"{spec['files'][1]} is not valid TOML: {exc}")
+    paths = {spec["files"][0], os.path.realpath(spec["files"][0])}
+    for group_index, group in enumerate(groups):
+        if not _ours(group, _audit_hook):
+            continue
+        handler_index = next(i for i, hook in enumerate(group["hooks"]) if _audit_hook(hook))
+        for path in paths:
+            trusted = (states.get(f"{path}:session_start:{group_index}:{handler_index}") or {}).get("trusted_hash")
+            if trusted == _codex_hash("session_start", group, handler_index):
+                return True
+    return False
+
+
+def audit_state(client="claude"):
+    """The SessionStart audit hook in the client's hooks file: `current` (our entry equals this version's and, in
+    Codex, was approved in /hooks), `waiting_approval` (Codex only: written but not approved, so it does not run yet),
+    `outdated` (an entry of ours that differs) or `missing`."""
+    path = _audit_client(client)["files"][0]
     try:
         with open(path, encoding="utf-8") as stream:
             data = json.load(stream)
@@ -312,52 +366,61 @@ def audit_state():
     found = [group for group in groups if _ours(group, _audit_hook)] if isinstance(groups, list) else []
     if not found:
         return "missing"
-    return "current" if _audit_entry() in found else "outdated"
+    if _audit_entry() not in found:
+        return "outdated"
+    return "current" if client != "codex" or _codex_approved(groups) else AUDIT_WAITING
 
 
 def audit_hook_installed(client):
-    """The Claude Code session-start audit report is on, so a search need not repeat it. An unreadable settings file
-    counts as off here; `audit_state` raises for it on the setup screen."""
-    if client != "claude":
+    """The session-start audit report is on and running (Codex: approved in /hooks), so a search need not repeat it.
+    An unreadable config file counts as off here; `audit_state` raises for it on the setup screen."""
+    if client not in AUDIT_CLIENTS:
         return False
     try:
-        return audit_state() == "current"
+        return audit_state(client) == "current"
     except (OSError, ValueError):
         return False
 
 
-def audit_preview():
-    """The change that turns the SessionStart audit report on in Claude Code, with a token for `audit_install`."""
-    path, _data, _groups = _audit_plan()
+def _audit_after(client):
+    """{after_install: ...} for a client whose new hooks need the user's approval, else nothing."""
+    note = CLIENTS[client].get("after_install")
+    return {"after_install": note} if note else {}
+
+
+def audit_preview(client="claude"):
+    """The change that turns the SessionStart audit report on in the client, with a token for `audit_install`."""
+    path, _data, _groups = _audit_plan(client)
     entry = _audit_entry()
-    if audit_state() == "current":
+    if audit_state(client) in (AUDIT_ON, AUDIT_WAITING):
         return {"installed": True, "file": path, "change": None}
     token = secrets.token_urlsafe(12)
-    _PREVIEWS[token] = {"client": "audit", "at": time.time()}
+    _PREVIEWS[token] = {"client": f"audit:{client}", "at": time.time()}
     return {"installed": False, "file": path, "event": "SessionStart", "change": entry, "token": token,
-            "expires_s": PREVIEW_TTL_S}
+            "expires_s": PREVIEW_TTL_S, **_audit_after(client)}
 
 
-def audit_install(token, confirm):
-    """Writes the SessionStart audit entry into Claude Code's settings with a backup; needs the `audit_preview` token
-    (10 min) and confirm=True. Returns {installed, changed, file, backup}."""
+def audit_install(token, confirm, client="claude"):
+    """Writes the SessionStart audit entry into the client's hooks file with a backup; needs the `audit_preview` token
+    (10 min) and confirm=True. Returns {installed, changed, file, backup}, plus `after_install` in Codex: the hook
+    runs only after the user approves it in /hooks."""
     planned = _PREVIEWS.pop(token or "", None)
-    if confirm is not True or not planned or planned["client"] != "audit" or time.time() - planned["at"] > PREVIEW_TTL_S:
+    if confirm is not True or not planned or planned["client"] != f"audit:{client}" or time.time() - planned["at"] > PREVIEW_TTL_S:
         raise ValueError("Turning the audit report on requires the preview token (valid for 10 min) and confirm=true.")
-    path, data, groups = _audit_plan()
-    if audit_state() == "current":
+    path, data, groups = _audit_plan(client)
+    if audit_state(client) in (AUDIT_ON, AUDIT_WAITING):
         return {"installed": True, "changed": False, "file": path}
     groups.append(_audit_entry())
-    backup = _write_checked(path, data, lambda: audit_state() == "current", "The audit hook")
-    return {"installed": True, "changed": True, "file": path, "backup": backup}
+    backup = _write_checked(path, data, lambda: audit_state(client) in (AUDIT_ON, AUDIT_WAITING), "The audit hook")
+    return {"installed": True, "changed": True, "file": path, "backup": backup, **_audit_after(client)}
 
 
-def audit_remove():
-    """Takes only our SessionStart entry out of Claude Code's settings (after a backup); nothing else is touched."""
-    path, data, groups = _audit_plan()
-    if audit_state() == "missing":
+def audit_remove(client="claude"):
+    """Takes only our SessionStart entry out of the client's hooks file (after a backup); nothing else is touched."""
+    path, data, groups = _audit_plan(client)
+    if audit_state(client) == "missing":
         return {"installed": False, "changed": False, "file": path}
     if not groups:
         del data["hooks"]["SessionStart"]
-    backup = _write_checked(path, data, lambda: audit_state() == "missing", "The removal")
+    backup = _write_checked(path, data, lambda: audit_state(client) == "missing", "The removal")
     return {"installed": False, "changed": True, "file": path, "backup": backup}

package/document_text.py

@@ -1,13 +1,16 @@
-"""Extração local de texto DOCX e PDF, sem Office, execução de macros ou acesso externo."""
+"""Extração local de texto DOCX, PPTX, XLSX e PDF, sem Office, execução de macros ou acesso externo."""
+import contextlib
 import io
 import json
+import posixpath
 import re
 import subprocess
 import sys
 import zipfile
 import xml.etree.ElementTree as ET
+import zlib
 
-VERSION = 2
+VERSION = 3
 PDF_MAX_BYTES = 20 * 1024 * 1024
 PDF_TIMEOUT_S = 20
 PDF_MAX_PAGES = 300
@@ -15,6 +18,8 @@ PDF_MAX_CHARS = 1_000_000
 MAX_ARCHIVE_BYTES = 10 * 1024 * 1024
 MAX_XML_BYTES = 8 * 1024 * 1024
 MAX_TEXT_BYTES = 1024 * 1024
+XLSX_MAX_ROWS = 100_000
+XLSX_MAX_COLUMNS = 16_384
 W = '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}'
 
 
@@ -37,53 +42,264 @@ class PdfUnreadable(DocumentError):
 
 
 class _DocumentTreeBuilder(ET.TreeBuilder):
+    label = 'DOCX'
+
     def doctype(self, name, pubid, system):
         # O callback também recusa DTD em XML UTF-16, antes de expandir entidades.
-        raise DocumentError('DOCX contains disallowed entities.')
+        raise DocumentError(f'{self.label} contains disallowed entities.')
+
+
+class _Package:
+    """An open OOXML zip: the parts it holds and a guarded parser that charges every part to one XML budget."""
+
+    def __init__(self, archive, entries, label):
+        self.archive = archive
+        self.entries = entries
+        self.label = label
+        self.xml_bytes = 0
+
+    def parse(self, name):
+        info = self.entries[name]
+        if info.flag_bits & 1 or info.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED):
+            raise DocumentError(f'Encrypted {self.label} or unsupported compression.')
+        if info.file_size > MAX_XML_BYTES - self.xml_bytes:
+            raise DocumentError(f'{self.label} XML content over the limit.')
+        with self.archive.open(info) as stream:
+            raw = stream.read(MAX_XML_BYTES - self.xml_bytes + 1)
+        self.xml_bytes += len(raw)
+        if self.xml_bytes > MAX_XML_BYTES or b'<!DOCTYPE' in raw.upper() or b'<!ENTITY' in raw.upper():
+            raise DocumentError(f'{self.label} contains excessive XML or disallowed entities.')
+        builder = _DocumentTreeBuilder()
+        builder.label = self.label
+        return ET.fromstring(raw, parser=ET.XMLParser(target=builder))
+
+
+@contextlib.contextmanager
+def _open_package(data, label, required):
+    """The one place that opens an OOXML zip (docx, pptx, xlsx) with the guards: archive size, entry count, a required
+    part, no encryption, one XML budget, no DOCTYPE or ENTITY, and every low-level failure turned into a DocumentError.
+
+    Parameters: data (zip bytes), label (`DOCX`, `PPTX` or `XLSX`, used in the reasons), required (a part name, or a
+    predicate over the part names, that must exist). Yields: a _Package. Raises: DocumentError with a readable reason."""
+    if len(data) > MAX_ARCHIVE_BYTES:
+        raise DocumentError(f'{label} over the 10 MiB limit.')
+    try:
+        with zipfile.ZipFile(io.BytesIO(data)) as archive:
+            listing = archive.infolist()
+            entries = {info.filename: info for info in listing}
+            present = required(entries) if callable(required) else required in entries
+            if len(listing) > 2000 or not present:
+                raise DocumentError(f'Invalid {label} or excessive structure.')
+            yield _Package(archive, entries, label)
+    except (zipfile.BadZipFile, ET.ParseError, RuntimeError, NotImplementedError, OSError, zlib.error, EOFError) as exc:
+        raise DocumentError(f'Could not extract text from this {label}.') from exc
+
+
+class _Lines(list):
+    """Output lines of an extractor; `add` refuses to grow past MAX_TEXT_BYTES of UTF-8 text."""
+
+    def __init__(self, label):
+        super().__init__()
+        self.label = label
+        self.size = 0
+
+    def add(self, *lines):
+        for line in lines:
+            self.size += len(line.encode('utf-8')) + 1
+            if self.size > MAX_TEXT_BYTES:
+                raise DocumentError(f'Text extracted from {self.label} exceeds 1 MiB.')
+            self.append(line)
+
+
+def _local(tag):
+    return tag.rsplit('}', 1)[-1]
 
 
 def extract_docx(data):
-    if len(data)>MAX_ARCHIVE_BYTES:
-        raise DocumentError('DOCX over the 10 MiB limit.')
-    try:
-        with zipfile.ZipFile(io.BytesIO(data)) as archive:
-            listing=archive.infolist()
-            entries={info.filename:info for info in listing}
-            if len(listing)>2000 or 'word/document.xml' not in entries:
-                raise DocumentError('Invalid DOCX or excessive structure.')
-            names=['word/document.xml']+sorted(name for name in entries if re.fullmatch(r'word/(?:header\d+|footer\d+|footnotes|endnotes)\.xml',name))
-            paragraphs=[];xml_bytes=0;text_bytes=0
-            for name in names:
-                info=entries[name]
-                if info.flag_bits&1 or info.compress_type not in (zipfile.ZIP_STORED,zipfile.ZIP_DEFLATED):
-                    raise DocumentError('Encrypted DOCX or unsupported compression.')
-                if info.file_size>MAX_XML_BYTES-xml_bytes:
-                    raise DocumentError('DOCX XML content over the limit.')
-                with archive.open(info) as stream:
-                    raw=stream.read(MAX_XML_BYTES-xml_bytes+1)
-                xml_bytes+=len(raw)
-                if xml_bytes>MAX_XML_BYTES or b'<!DOCTYPE' in raw.upper() or b'<!ENTITY' in raw.upper():
-                    raise DocumentError('DOCX contains excessive XML or disallowed entities.')
-                root=ET.fromstring(raw,parser=ET.XMLParser(target=_DocumentTreeBuilder()))
-                namespace=W if root.tag.startswith(W) else '{http://purl.oclc.org/ooxml/wordprocessingml/main}'
-                for paragraph in root.iter(namespace+'p'):
-                    def parts(node):
-                        pending=list(reversed(node))
-                        while pending:
-                            child=pending.pop()
-                            if child.tag==namespace+'p':continue
-                            if child.tag==namespace+'t':yield child.text or ''
-                            elif child.tag==namespace+'tab':yield '\t'
-                            elif child.tag in (namespace+'br',namespace+'cr'):yield '\n'
-                            else:pending.extend(reversed(child))
-                    text=''.join(parts(paragraph))
-                    if text.strip():
-                        text_bytes+=len(text.encode('utf-8'))+1
-                        if text_bytes>MAX_TEXT_BYTES:raise DocumentError('Text extracted from DOCX exceeds 1 MiB.')
-                        paragraphs.append(text)
-            return ('\n'.join(paragraphs)+'\n' if paragraphs else '').encode('utf-8')
-    except (zipfile.BadZipFile,ET.ParseError,RuntimeError,NotImplementedError,OSError) as exc:
-        raise DocumentError('Could not extract text from this DOCX.') from exc
+    """Text of a .docx: body, headers, footers, footnotes and endnotes, one line per non-empty paragraph.
+
+    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
+    corrupt, encrypted or oversized package, or one with a DOCTYPE or entity."""
+    with _open_package(data, 'DOCX', 'word/document.xml') as package:
+        names = ['word/document.xml'] + sorted(name for name in package.entries if re.fullmatch(
+            r'word/(?:header\d+|footer\d+|footnotes|endnotes)\.xml', name))
+        paragraphs = _Lines('DOCX')
+        for name in names:
+            root = package.parse(name)
+            namespace = W if root.tag.startswith(W) else '{http://purl.oclc.org/ooxml/wordprocessingml/main}'
+            for paragraph in root.iter(namespace + 'p'):
+                def parts(node):
+                    pending = list(reversed(node))
+                    while pending:
+                        child = pending.pop()
+                        if child.tag == namespace + 'p':
+                            continue
+                        if child.tag == namespace + 't':
+                            yield child.text or ''
+                        elif child.tag == namespace + 'tab':
+                            yield '\t'
+                        elif child.tag in (namespace + 'br', namespace + 'cr'):
+                            yield '\n'
+                        else:
+                            pending.extend(reversed(child))
+                text = ''.join(parts(paragraph))
+                if text.strip():
+                    paragraphs.add(text)
+        return ('\n'.join(paragraphs) + '\n' if paragraphs else '').encode('utf-8')
+
+
+def _drawing_paragraphs(root):
+    """Non-empty paragraphs (`a:p`) of a slide or notes part, from the `a:t` runs; the slide-number field is not text."""
+    lines = []
+    for paragraph in root.iter():
+        if _local(paragraph.tag) != 'p':
+            continue
+        pending = list(reversed(paragraph))
+        pieces = []
+        while pending:
+            child = pending.pop()
+            kind = _local(child.tag)
+            if kind == 'fld' and child.get('type', '').startswith('slidenum'):
+                continue
+            if kind == 't':
+                pieces.append(child.text or '')
+            elif kind == 'br':
+                pieces.append('\n')
+            elif kind != 'p':
+                pending.extend(reversed(child))
+        text = ''.join(pieces)
+        if text.strip():
+            lines.append(text)
+    return lines
+
+
+def extract_pptx(data):
+    """Text of a .pptx: each slide under `[slide N]`, then its speaker notes under `[notes N]`, in slide order.
+
+    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
+    corrupt, encrypted, oversized or hostile package, or a deck without any text."""
+    def has_slides(names):
+        return any(re.fullmatch(r'ppt/slides/slide\d+\.xml', name) for name in names)
+
+    with _open_package(data, 'PPTX', has_slides) as package:
+        slides = sorted((int(m.group(1)), name) for name in package.entries
+                        if (m := re.fullmatch(r'ppt/slides/slide(\d+)\.xml', name)))
+        lines = _Lines('PPTX')
+        for number, name in slides:
+            body = _drawing_paragraphs(package.parse(name))
+            if body:
+                lines.add(f'[slide {number}]', *body)
+            notes_name = f'ppt/notesSlides/notesSlide{number}.xml'
+            notes = _drawing_paragraphs(package.parse(notes_name)) if notes_name in package.entries else []
+            if notes:
+                lines.add(f'[notes {number}]', *notes)
+    if not lines:
+        raise DocumentError('PPTX has no text.')
+    return ('\n'.join(lines) + '\n').encode('utf-8')
+
+
+def _shared_strings(package):
+    if 'xl/sharedStrings.xml' not in package.entries:
+        return []
+    strings = []
+    for item in package.parse('xl/sharedStrings.xml'):
+        if _local(item.tag) != 'si':
+            continue
+        pending = list(reversed(item))
+        pieces = []
+        while pending:
+            child = pending.pop()
+            kind = _local(child.tag)
+            if kind == 't':
+                pieces.append(child.text or '')
+            elif kind != 'rPh':
+                pending.extend(reversed(child))
+        strings.append(''.join(pieces))
+    return strings
+
+
+def _column_index(ref):
+    letters = re.match(r'[A-Za-z]+', ref or '')
+    if not letters:
+        return None
+    index = 0
+    for char in letters.group().upper():
+        index = index * 26 + ord(char) - 64
+    return index - 1
+
+
+def _sheet_rows(root, strings):
+    """Tab-joined text of each non-empty row of a worksheet; an empty cell keeps the columns after it aligned."""
+    for row in root.iter():
+        if _local(row.tag) != 'row':
+            continue
+        values = []
+        for cell in row:
+            if _local(cell.tag) != 'c':
+                continue
+            kind = cell.get('t')
+            value = ''
+            if kind == 'inlineStr':
+                value = ''.join(node.text or '' for node in cell.iter() if _local(node.tag) == 't')
+            else:
+                raw = next((node.text or '' for node in cell if _local(node.tag) == 'v'), '')
+                if kind == 's':
+                    position = int(raw) if raw.strip().isdigit() else -1
+                    if not 0 <= position < len(strings):
+                        raise DocumentError('Could not extract text from this XLSX.')
+                    value = strings[position]
+                else:
+                    value = raw
+            column = _column_index(cell.get('r'))
+            if column is None:
+                column = len(values)
+            if column >= XLSX_MAX_COLUMNS:
+                raise DocumentError(f'XLSX over {XLSX_MAX_COLUMNS} columns.')
+            values += [''] * (column - len(values))
+            if column == len(values):
+                values.append(value)
+            else:
+                values[column] = value
+        if any(value.strip() for value in values):
+            yield '\t'.join(values)
+
+
+def extract_xlsx(data):
+    """Text of an .xlsx: each sheet, in workbook order, under `[sheet NAME]`, then one line per row with the cells
+    separated by tabs. Shared strings are resolved; numbers and inline strings are kept; a formula contributes its cached
+    value, nothing is calculated.
+
+    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
+    corrupt, encrypted, oversized or hostile package, a workbook over XLSX_MAX_ROWS rows or MAX_TEXT_BYTES of text, or
+    one without any text."""
+    with _open_package(data, 'XLSX', 'xl/workbook.xml') as package:
+        workbook = package.parse('xl/workbook.xml')
+        targets = {}
+        if 'xl/_rels/workbook.xml.rels' in package.entries:
+            for rel in package.parse('xl/_rels/workbook.xml.rels'):
+                target = rel.get('Target', '')
+                targets[rel.get('Id')] = posixpath.normpath(target.lstrip('/') if target.startswith('/')
+                                                            else posixpath.join('xl', target))
+        strings = _shared_strings(package)
+        lines = _Lines('XLSX')
+        rows = 0
+        for sheet in (node for node in workbook.iter() if _local(node.tag) == 'sheet'):
+            rid = next((value for key, value in sheet.attrib.items() if _local(key) == 'id'), None)
+            part = targets.get(rid)
+            if part not in package.entries:
+                raise DocumentError('Invalid XLSX or excessive structure.')
+            header = f"[sheet {' '.join(sheet.get('name', '').split())}]"
+            for line in _sheet_rows(package.parse(part), strings):
+                rows += 1
+                if rows > XLSX_MAX_ROWS:
+                    raise DocumentError(f'XLSX over {XLSX_MAX_ROWS} rows.')
+                if header:
+                    lines.add(header)
+                    header = ''
+                lines.add(line)
+    if not lines:
+        raise DocumentError('XLSX has no text.')
+    return ('\n'.join(lines) + '\n').encode('utf-8')
 
 
 PDF_SCRIPT = """
@@ -150,11 +366,15 @@ def extract_pdf(data):
     return (text + "\n").encode("utf-8", "replace")
 
 
+_EXTENSIONS = ('.docx', '.pptx', '.xlsx', '.pdf')
+
+
 def is_extracted(path):
     """Whether the file type goes through a text extractor before indexing.
 
-    Parameters: path (any file name or path). Returns: True for `.docx` and `.pdf`, case-insensitive."""
-    return str(path).lower().endswith(('.docx', '.pdf'))
+    Parameters: path (any file name or path). Returns: True for `.docx`, `.pptx`, `.xlsx` and `.pdf`, case-insensitive;
+    macro and binary formats (`.xlsm`, `.xlsb`, `.xls`, `.ppt`, `.pptm`) are not extracted."""
+    return str(path).lower().endswith(_EXTENSIONS)
 
 
 def size_limit(path):
@@ -169,7 +389,14 @@ def extract(path, data):
 
     Parameters: path (decides the type, see is_extracted), data (file bytes). Returns: UTF-8 text bytes. Raises:
     DocumentError with a readable reason."""
-    return extract_pdf(data) if str(path).lower().endswith('.pdf') else extract_docx(data)
+    name = str(path).lower()
+    if name.endswith('.pdf'):
+        return extract_pdf(data)
+    if name.endswith('.pptx'):
+        return extract_pptx(data)
+    if name.endswith('.xlsx'):
+        return extract_xlsx(data)
+    return extract_docx(data)
 
 
 def location_kind(path):

package/hooks/session_audit.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""SessionStart hook of Claude Code (opt-in, from the setup screen): forwards the payload to the Smart Tool daemon
+"""SessionStart hook of Claude Code and Codex (opt-in, from the setup screen): forwards the payload to the Smart Tool daemon
 (POST /hooks/session-audit) and prints its answer, the stored setup audit notice of the session folder as additional
 context. Never starts the daemon or an audit: daemon down or any error means empty output, so a session start is
 never delayed or blocked.

package/index_profile.py

@@ -11,7 +11,7 @@ PROFILE_VERSION = 2
 KINDS = ("code", "test", "doc")
 RETRY_AFTER_S = 3600
 MAX_DIRS = 90
-PROSE = {"md", "txt", "docx", "pdf", "rst", "adoc"}
+PROSE = {"md", "txt", "docx", "pptx", "xlsx", "pdf", "rst", "adoc"}
 # Data and markup inside a documentation, design or data-dump folder are reports and mockups, not code (GitHub Linguist
 # treats docs/ as documentation; a design/ HTML or a probe's JSON result pushed hook_decision.py out of the code block).
 DOC_DATA = {"html", "htm", "json", "csv", "xml", "yaml", "yml", "svg"}

package/index_scope.py

@@ -387,8 +387,8 @@ def _build_scope_prompt(root, ambiguous_dirs, root_files, doc_context):
         "not indexed, and an empty `include` indexes only the loose root files. "
         "Include sources useful for search even if they are gitignored (e.g. docs/, README, "
         "ADRs). Java, Angular, HTML/CSS, plain text and Markdown are supported sources. "
-        "DOCX documents are supported through bounded local text extraction; do not exclude "
-        "useful Word documentation merely because its container is binary. "
+        "DOCX, PPTX, XLSX and PDF documents are supported through bounded local text extraction; do not exclude "
+        "useful Office or PDF documentation merely because its container is binary. "
         "Exclude directories that inspection shows are generated artifacts or "
         "dependencies (compiled binaries, minified bundles, hashed build chunks, vendored "
         "packages)."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.41",
+  "version": "0.9.43",
   "description": "Local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharper tools than their built-in search. Windows.",
   "license": "Apache-2.0",
   "author": "Allan Santos",

package/requirements.txt

@@ -6,4 +6,4 @@ trafilatura==2.3.0
 pypdf==6.20.0
 # Mapas JS/TS: TypeScript 5.9.3 no runtime Node (web_adapters/node/package-lock.json).
 # Mapas Java/Angular: java-parser 3.0.1 e @angular/compiler 20.3.0 no mesmo runtime Node.
-# DOCX: extração com zipfile + ElementTree (stdlib; sem Office/macros/rede).
+# DOCX, PPTX e XLSX: extração com zipfile + ElementTree (stdlib; sem Office/macros/rede). PDF: pypdf, em subprocesso.

package/scout.py

@@ -102,7 +102,7 @@ def is_intent_question(question):
 
 def disk_lines(root, path, start, end):
     """`[(line_number, text)]` of lines `start..end` of the file as it is on disk now, or None when the file cannot be
-    read by the index rules (secret, dotfile, too large, binary, gone) or holds no line text (docx, pdf)."""
+    read by the index rules (secret, dotfile, too large, binary, gone) or holds no line text (docx, pdf, pptx, xlsx)."""
     if document_text.location_kind(path) != "source_line":
         return None
     data, encoding = indexer.read_indexable(root, path)

package/setup_ui.py

@@ -325,21 +325,25 @@ def handle_integration_save(body):
 def handle_audit(body):
     """Setup audit panel: `index` lists the registered projects with their last audit summary; `report` returns the
     last stored report of one of them; `run` audits it now (MCP servers contacted unless probe is false). Only
-    registered project folders are accepted. The opt-in session-start report in Claude Code: `hook_state`,
+    registered project folders are accepted. The opt-in session-start report in Claude Code or Codex (`client`, default
+    claude; Codex runs it only after /hooks approval, state `waiting_approval`): `hook_state`,
     `hook_preview` (the exact entry and a token), `hook_install` (with that token, after a backup) and `hook_remove`
     (only Smart Tool's entry, after a backup)."""
     if not isinstance(body, dict):
         raise SetupError("Invalid request.")
     roots = sorted({p["root"] for p in project_store.all_projects() if p.get("root")}, key=str.casefold)
     try:
+        client = body.get("client", "claude")
         if body.get("action") == "hook_state":
-            return {"state": client_hooks.audit_state(), "file": client_hooks.CLIENTS["claude"]["files"][0]}
+            state = client_hooks.audit_state(client)
+            detail = {"detail": "installed, waiting for your approval in /hooks"} if state == client_hooks.AUDIT_WAITING else {}
+            return {"state": state, "file": client_hooks.CLIENTS[client]["files"][0], **detail}
         if body.get("action") == "hook_preview":
-            return client_hooks.audit_preview()
+            return client_hooks.audit_preview(client)
         if body.get("action") == "hook_install":
-            return client_hooks.audit_install(body.get("token"), True)
+            return client_hooks.audit_install(body.get("token"), True, client)
         if body.get("action") == "hook_remove":
-            return client_hooks.audit_remove()
+            return client_hooks.audit_remove(client)
         if body.get("action") == "index":
             stored = setup_audit.index()
             found = {root: stored[setup_audit.index_key(root)] for root in roots if setup_audit.index_key(root) in stored}
@@ -809,8 +813,9 @@ _PAGE_TEMPLATE = """<!doctype html>
       <header class="page-head"><h2 id="h-audit" tabindex="-1">Setup audit</h2>
         <p>What Claude Code and Codex load for a project, and where they collide: hooks deciding on the same tool at once, hooks or MCP servers that do not work, tools offered twice, skills and instructions one agent never sees. It runs on its own for the registered projects and never changes anything.</p></header>
       <div class="card">
-        <div class="card-head"><h3>Report at session start (Claude Code)</h3><span class="pill" id="audit-hook-pill" data-tone="busy">Checking</span></div>
-        <p class="lede">Off by default. When on, every new Claude Code session starts with one short line about the stored audit of its folder (errors and warnings only, nothing runs). It adds a SessionStart entry to <span class="mono" id="audit-hook-file"></span>, written after a backup, and turning it off removes only that entry. Without it, the agent gets the same line once, on its first search.</p>
+        <div class="card-head"><h3>Report at session start</h3><span class="pill" id="audit-hook-pill" data-tone="busy">Checking</span></div>
+        <div class="field"><label for="sel-audit-hook-client">Client</label><select id="sel-audit-hook-client"><option value="claude">Claude Code</option><option value="codex">Codex</option></select></div>
+        <p class="lede">Off by default. When on, every new session starts with one short line about the stored audit of its folder (errors and warnings only, nothing runs). It adds a SessionStart entry to <span class="mono" id="audit-hook-file"></span>, written after a backup, and turning it off removes only that entry. Codex runs a new hook only after you approve it in /hooks. Without it, the agent gets the same line once, on its first search.</p>
         <div class="actions"><button type="button" class="primary" id="btn-audit-hook-on" hidden>Turn on</button><button type="button" id="btn-audit-hook-off" hidden>Turn off</button></div>
         <div id="audit-hook-confirm" hidden>
           <p class="hint" id="audit-hook-where"></p>
@@ -1886,14 +1891,17 @@ async function loadAudit() {
   }
   renderOverview();
 }
+function auditHookClient() { return $("sel-audit-hook-client").value; }
+$("sel-audit-hook-client").addEventListener("change", () => { setMsg("audit-hook-msg", "", ""); loadAuditHook(); });
 async function loadAuditHook() {
   try {
-    const hook = await post("/setup/audit", { action: "hook_state" });
+    const hook = await post("/setup/audit", { action: "hook_state", client: auditHookClient() });
     $("audit-hook-file").textContent = hook.file;
-    const on = hook.state === "current";
+    const on = hook.state === "current" || hook.state === "waiting_approval";
     const pillEl = $("audit-hook-pill");
-    pillEl.textContent = on ? "On" : hook.state === "outdated" ? "Outdated" : "Off";
-    pillEl.dataset.tone = on ? "ok" : hook.state === "outdated" ? "warn" : "idle";
+    pillEl.textContent = hook.state === "waiting_approval" ? "Waiting for approval in /hooks" : on ? "On" : hook.state === "outdated" ? "Outdated" : "Off";
+    pillEl.dataset.tone = hook.state === "waiting_approval" || hook.state === "outdated" ? "warn" : on ? "ok" : "idle";
+    if (hook.detail) setMsg("audit-hook-msg", "", hook.detail + ".");
     $("btn-audit-hook-on").hidden = on;
     $("btn-audit-hook-on").textContent = hook.state === "outdated" ? "Update" : "Turn on";
     $("btn-audit-hook-off").hidden = hook.state === "missing";
@@ -1904,7 +1912,7 @@ async function loadAuditHook() {
 $("btn-audit-hook-on").addEventListener("click", async () => {
   setMsg("audit-hook-msg", "", "Preparing the change…");
   try {
-    const plan = await post("/setup/audit", { action: "hook_preview" });
+    const plan = await post("/setup/audit", { action: "hook_preview", client: auditHookClient() });
     setMsg("audit-hook-msg", "", "");
     $("audit-hook-where").textContent = "Adds this entry under " + plan.event + " in " + plan.file + ".";
     $("audit-hook-preview").textContent = JSON.stringify(plan.change, null, 2);
@@ -1912,10 +1920,10 @@ $("btn-audit-hook-on").addEventListener("click", async () => {
     $("btn-audit-hook-write").onclick = async () => {
       $("btn-audit-hook-write").disabled = true;
       try {
-        const result = await post("/setup/audit", { action: "hook_install", token: plan.token });
+        const result = await post("/setup/audit", { action: "hook_install", token: plan.token, client: auditHookClient() });
         $("audit-hook-confirm").hidden = true;
         await loadAuditHook();
-        setMsg("audit-hook-msg", "ok", "Turned on. Backup: " + (result.backup || "none, the file was new") + ".");
+        setMsg("audit-hook-msg", "ok", "Turned on. Backup: " + (result.backup || "none, the file was new") + "." + (result.after_install ? " " + result.after_install : ""));
       } catch (error) {
         setMsg("audit-hook-msg", "error", error.message);
       } finally {
@@ -1929,7 +1937,7 @@ $("btn-audit-hook-on").addEventListener("click", async () => {
 $("btn-audit-hook-cancel").addEventListener("click", () => { $("audit-hook-confirm").hidden = true; });
 $("btn-audit-hook-off").addEventListener("click", async () => {
   try {
-    const result = await post("/setup/audit", { action: "hook_remove" });
+    const result = await post("/setup/audit", { action: "hook_remove", client: auditHookClient() });
     await loadAuditHook();
     setMsg("audit-hook-msg", "ok", "Turned off. Backup: " + (result.backup || "none") + ".");
   } catch (error) {

package/version.py

@@ -1,7 +1,7 @@
 """Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
 import re
 
-VERSION = "0.9.41"
+VERSION = "0.9.43"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")