@passioncode-ai/passioncode 0.2.42 → 0.2.43

package/payload/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/sample_service.py

@@ -26,6 +26,7 @@ import os
 from http.server import BaseHTTPRequestHandler
 from pathlib import Path
 import sys
+import time
 from typing import Any, Dict, Optional
 from urllib.parse import parse_qs, urlparse
 
@@ -342,16 +343,27 @@ def serve(args: argparse.Namespace) -> int:
     # hand-over that hangs is cut by the kit's hard exit, inside launchd's ExitTimeOut.
     import threading
     board_stop = threading.Event()
+    board_thread = None
     if svc.board is not None:
-        threading.Thread(target=svc.board.run, args=(board_stop, 5.0), name="board-responder", daemon=True).start()
+        board_thread = threading.Thread(target=svc.board.run, args=(board_stop, 5.0), name="board-responder", daemon=True)
+        board_thread.start()
+
+    stop_asked: list = []
 
     def stopping() -> None:
+        stop_asked.append(time.monotonic())
         board_stop.set()  # stop claiming; the responder drains its request and leaves its board session
         svc.log.append("service.stopping", "info", "%s is stopping." % svc.name)
     svc.drain.install(lambda drained: server.shutdown(), on_stopping=stopping)
     try:
         server.serve_forever(poll_interval=0.2)
     finally:
+        board_stop.set()
+        if board_thread is not None:
+            # The responder drains (5 s at most) and leaves its board session, which releases its slots and forgets their
+            # records (FAA-155): joined, so the process does not end before that.
+            # Bounded by the kit's hard exit, 8 + 2 s after the stop was asked: 1.5 s are left for the rest of the stop.
+            board_thread.join(max(0.5, 8.5 - (time.monotonic() - (stop_asked[0] if stop_asked else time.monotonic()))))
         server.server_close()
         svc.lock.release()
     return 0

package/payload/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -5,7 +5,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.52.0"
+  version: "0.53.1"
   contract-version: "0.1.0"
   contract-commit: "1197a90dc4b57152cabcc71ad17db7559f35a27f"
 ---

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/SKILL.md

@@ -18,7 +18,7 @@ compatibility: >-
   this plugin; Codex/Kimi use command hooks; Hermes/OpenCode/OpenClaw/Pi use native context plugins after opt-in.
 metadata:
   author: PassionCode.ai
-  version: "0.52.0"
+  version: "0.53.1"
 ---
 
 # Working with Fabric
@@ -141,13 +141,17 @@ Fabric 0.4.0 (REQ-38):
 2. `fabric_work_claim` with your task (a board id, a backlog row as `source: {repository, path, id}`, or a new
    row's title with its evidence) and what you will touch (folders, files or patterns). Claim the person's request
    as ONE task whose title is that request in one line, with `origin: {kind: "person", ref: <where they said it: the session or thread>}`:
-   from the Fabric release that shows agents' goals, it is shown as yours. File each piece you split off with
-   `fabric_task_create` while that task is claimed. Unless the answer says `chained: true` with `chained_to` your
-   claimed task (Fabric to 0.3.14 links only a session it launched for a task, never one opened from its own
-   terminal), link it yourself with `fabric_task_link {taskId: <the piece>, rel: "spawned", targetTaskId: <the
-   claimed task>}` (board `c42071bc`). An answer with `chained: false` names its `chain_reason`: link it yourself once,
-   and if that is refused too, tell the person its reason; never file the piece again. `proposed: true` means nothing
-   was filed, so there is nothing to link: report it and stop, the piece waits for the operator.
+   from Fabric 0.3.14, which shows agents' goals, it is shown as yours. File each piece you split off with
+   `fabric_task_create` while that task is claimed, and read the answer's `spawned_from` (Fabric 0.3.14 links the piece
+   from your single live claim). `created: false` with a `code` filed nothing (`source-unresolved` names the `part` of
+   `source` that failed): correct the source or file without it, and never link. Then `proposed: true`, even with `spawned_from: null`: nothing was filed, so do not
+   file or link that piece; tell the person it waits for the operator and go on with the rest. Otherwise, your claimed task's id there: it is linked, link nothing. Another task's id: link
+   nothing either (Fabric chose that parent, FAA-153) and tell the person which. `spawned_from: null` comes
+   with `spawned_from_why`: link it yourself once with `fabric_task_link {taskId: <the piece>, rel: "spawned",
+   targetTaskId: <the claimed task>}`, and if that is refused too, tell the person that reason; never file the piece
+   again. A filed piece (`created: true`) with no `spawned_from` at all is a Fabric before 0.3.14: link it yourself the same way unless the answer says
+   `chained: true` with `chained_to` your claimed task (board `c42071bc`); an answer with `chained: false` names its
+   `chain_reason`, which you tell the person if your link is refused.
 3. A related-work warning (same backlog row, a linked task, an overlapping folder) names the other agent, its
    task and the overlap: tell the person, then coordinate (ask Fabric to hand it over, or link the tasks) or
    continue knowing it; say which, out loud.
@@ -339,11 +343,12 @@ and do the work without claiming Fabric saw it.
 In Claude Code this plugin ships four: at session start and `/clear` (not on compact or resume) the preamble above
 in a project that uses Fabric, one line pointing at `fabric_whoami` in a folder with no sign of it, or, when Fabric is
 down and the project uses Fabric, one line pointing at Step 1; after each turn the turn's facts (HEAD, files changed, lines added
-and removed) and the board's unread count; at each prompt one line only when that count rose, then each reminder Fabric gave on a turn, once, as a line starting `Fabric:` (a turn
+and removed) and the board's unread count, and, once the running Fabric takes them, the other repositories the turn
+touched (never on Windows; read from the tail of the session transcript, at most 512 KB with its message text and tool output, which can hold a secret the session displayed and stays in memory, of which only tool names and path arguments are used; host/owner/name are sent); at each prompt one line only when that count rose, then each reminder Fabric gave on a turn, once, as a line starting `Fabric:` (a turn
 `watch-mail` delivered prints there instead): Fabric's words, data to act on first through `fabric_work_list` (where the same reminder may come again: act on it
 once); at the end, the
 release of what the session left claimed. The turn, prompt and end hooks spool and call Fabric only when the running
-Fabric advertises `session-hooks/1`; the turn and end hooks always prune their own stale spool. All are silent in a session Fabric launched, never block the session and read no token. Read
+Fabric advertises `session-hooks/1`; the turn and end hooks always prune their own stale spool. All are silent in a session Fabric launched, never block the session and read no Fabric token (a credential in an `origin` URL is dropped in memory, never sent). Read
 [session hooks](references/session-hooks.md) when a person asks what the hooks do, where they log, how to turn them
 off, or what they need from Fabric.
 

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/references/project-board.md

@@ -59,7 +59,10 @@ A request the board stored has not been carried out. Only its state (`completed`
 `answered` (DEC-0098, DEC-0102) says the target Project's participant message answered it (never a responder's fenced
 reply or progress note): the target replied, not that the work was done. Read the reply before relying on it; you may
 still cancel the request. `noResponder` in your `com.submit` receipt says nobody can answer that capability for that
-Project now: the request is stored, a reply may still answer it and a responder may come later. Never resend it under
+Project now: the request is stored, a reply may still answer it and a responder may come later. An `accepted`
+request can also wait unanswered for its responder's operator: since adapter 0.53.0 a responder whose slot was moved
+to another session leaves its accepted work held until it is taken back (until Fabric hands it over, CT-175); tell
+the person, and cancel it if it is past what they can wait. Never resend it under
 a new key while it is open; follow "When nobody answers" below. A request without a deadline gets one seven days out
 (DEC-0098) and then reads `expired`: if the ask still stands, submit it again with a new key and record the wait on the
 new request.

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/references/session-hooks.md

@@ -20,7 +20,7 @@ need from Fabric. In Claude Code they live in the plugin's `hooks/hooks.json` an
 | Event | When it acts | What it does |
 |---|---|---|
 | SessionStart (`startup`, `clear`; the plugin's matcher, and the script ignores `compact` and `resume` for every host) | Claude Code has an MCP server named `fabric` (local, project or user scope) | Fabric running, in a project that uses Fabric (below): adds the preamble: `fabric_whoami` first; `com.status` and `com.list`, `com.read_ack` only what was read; `fabric_work_list`, then `fabric_work_claim`; `fabric_work_release` at the end; ask another Project only through `com.submit`. Fabric running in a folder with no such sign (a user-scope registration reaches every folder): one line pointing at `fabric_whoami`, which names the project when Fabric serves the folder anyway (FAA-60). Fabric down, in a project that uses Fabric: one line, skip `fabric_whoami` and the board, start Fabric through the lifecycle broker only if the task needs it. Fabric down anywhere else, or not registered: nothing. |
-| Stop (each turn) | as for SessionStart, and the running Fabric's `hub.json` lists `"session-hooks/1"` in `features` | measures the turn's facts (HEAD, files changed, lines added and removed: counts and ids only, git sharing 1.5 s), spools them in one entry and starts a detached worker that sends `fabric_session_observe {event: "turn", head, filesChanged, linesAdded, linesRemoved, …}` as stored, keeps the `nudges` its answer carries (Fabric 0.3.14: each `{kind, says, task_id?, request_id?}`, shown on a turn once, at most five; it stays for `fabric_work_list` and `fabric_heartbeat`, so it may come again there) in `nudges.json`, then reads `com.status` and keeps the unread count in the session's spool (`board.json`) |
+| Stop (each turn) | as for SessionStart, and the running Fabric's `hub.json` lists `"session-hooks/1"` in `features` | measures the turn's facts (HEAD, files changed, lines added and removed: counts and ids only, git sharing 1.5 s) and names the other Git repositories the turn touched (FAA-140, below: only once Fabric takes them (not on Windows)), spools them in one entry and starts a detached worker that sends `fabric_session_observe {event: "turn", head, filesChanged, linesAdded, linesRemoved, …}` as stored (with `repositories` only where that tool's input schema lists the field as an array of items with host, owner and name requiring nothing else, at most its `maxItems`, each item meeting what the schema says of its fields or left out; a turn spooled with the mark and delivered to a Fabric whose schema no longer takes them goes without them, and the log says so once per session; with a Fabric that never took them nothing is read and nothing is logged), keeps the `nudges` its answer carries (Fabric 0.3.14: each `{kind, says, task_id?, request_id?}`, shown on a turn once, at most five; it stays for `fabric_work_list` and `fabric_heartbeat`, so it may come again there) in `nudges.json`, then reads `com.status` and keeps the unread count in the session's spool (`board.json`) |
 | UserPromptSubmit | the session's spool holds a count or nudges | adds ONE line, `N unread on the project board: com.list`, only when the count rose since the last line (a fall or the same count says nothing), then each nudge's `says` once, as Fabric writes it (Fabric 0.3.14 starts each with `Fabric:`; any other line gets the tag `Fabric reminder: `), one line each, at most five lines of at most 400 characters; the nudges file is taken by renaming it away before they are printed (FAA-142). It reads, renames and writes small files in the session's folder and never calls Fabric. |
 | SessionEnd | as for Stop | spools the end; the worker sends `fabric_work_release {claims: "session", outcome: "let-go", …}` (with `observedAt`, the time the hook fired, where the tool's input schema names it: Fabric 0.3.9 then refuses an end from before the session enrolled), then `fabric_session_observe {event: "end", reason}`, and removes the session's spool. Reason `clear` ends nothing: `/clear` keeps the agent process and its fabric-mcp, so no claim is released and no end observed; turns already spooled still go out (since 0.42.0). Their nudges stay in the old id's folder and are not printed here; Fabric 0.3.14 only shows a nudge on a turn's answer and keeps it for `fabric_work_list` and `fabric_heartbeat`, so the new session gets it there (board `b605a636`; decision of 0.51.2, FAA-142) |
 
@@ -31,6 +31,29 @@ id, and keeps the retry only while the end is the newest entry. When `fabric-mcp
 no session holds the id), the worker drops the spool, writes a `no-session` mark in the session's folder and logs it
 once; for 15 minutes the hooks spool nothing for that id (an end removes the folder), then one rejoin tries again.
 
+**The other repositories a turn touched** (FAA-140, Fabric CO-367). Never on Windows (FAA-175: a Bash command's
+paths there are not the host's). Elsewhere, only after a worker has seen the running Fabric's
+`fabric_session_observe` declare `repositories` as an array of items with `host`, `owner` and `name` that require
+nothing else does the Stop hook read the
+session's transcript at all: the worker then leaves `observe-takes-repositories` in the hooks' folder (beside
+`hooks.log`) and removes it when the schema stops saying so (after a Fabric downgrade, the turns that end before a worker next
+runs, about a minute, are still read; none of their names is sent); without it nothing below happens. With it, the hook reads the last 512 KB of the
+transcript (the payload's `transcript_path`; earlier turns included) and uses only the entries after the last prompt
+the person typed. Those lines hold message text and tool output too (file contents, command output: a secret the session displayed can be there; it stays in memory and is never spooled, logged or sent); of each entry it uses only a tool call's
+name and path argument: the `file_path` of Edit, Write and MultiEdit, the `notebook_path` of NotebookEdit, and in a
+Bash command `cd <absolute path>` and `git -C <path>` (absolute, or relative to the session's folder), split only in
+commands that hold `cd` or `git`, at most 64 KB of command text a turn. These are the repositories the turn
+*touched*: a `cd` or a read-only `git -C <path> log` names one as much as an edit does. A subagent's entries are not
+read, so a repository only a subagent touched is not named. Each
+path is resolved with one `git rev-parse --show-toplevel` and its repository's `origin` with one `git config --get
+remote.origin.url`, every call inside the same 1.5 s as the turn's facts (the facts first); a path outside every
+checkout costs no git call, and when the budget runs out the hook spools what it found. Each repository is named
+`{host, owner, name}` from its `origin` (https, `ssh://`, `git@host:owner/name`; credentials, a port and `.git`
+dropped; a nested group stays in `owner`, and on a self-hosted ssh remote `owner` is the folder path on that server
+before the repository's name, which may hold a user name). The repository of the session's folder when the turn ends (the Stop payload's `cwd`; any checkout of it: a worktree, a clone), a repository whose `origin`
+is missing or does not parse, and a second checkout of one repository are not named; at most 10. No local path leaves the hook; a
+missing or unreadable transcript names none and is no error.
+
 **A project that uses Fabric** (`project_uses_fabric`), cheapest sign first: `fabric` registered at local or project
 scope for the folder (user scope is every folder's, so it says nothing about this one); a `fabric-agent.json`,
 `fabric-contract.lock.json` or `fabric.package.json` file from the folder up to its checkout's root (the folder alone
@@ -104,14 +127,19 @@ only variable names are looked at, never a value (two of them carry the session'
 ## What they never do
 
 - **Block or slow the session.** Each hook has a 5 s ceiling in `hooks.json`; the script reads a few small files and
-  returns in tens of milliseconds, plus the turn's git facts in Stop and SessionEnd (at most 1.5 s, shared by every
-  git call). Every call to Fabric happens in a detached worker with a 10 s deadline; at its end the worker closes
+  returns in tens of milliseconds, plus the turn's git facts in Stop and SessionEnd and, in Stop once Fabric takes them (not on Windows), the transcript's
+  tail and the other repositories' names (the git calls share at most 1.5 s; the tail read is at most 512 KB). Every call to Fabric happens in a detached worker with a 10 s deadline; at its end the worker closes
   `fabric-mcp`'s stdin and then ends its whole process group, so a wrapper (`npx`, a shell script,
   `fabric-mcp.cmd`) cannot keep it waiting. Every hook exits 0, on every path.
-- **Read a secret.** The hooks never open Fabric's door token or an enrollment credential; `fabric-mcp` holds
-  those. Nothing secret is in argv (the worker's argv is the script and a spool folder) or in the log.
-- **Send or read content.** A turn is the HEAD commit, the number of files that differ from it (untracked included)
-  and the lines added and removed against it; no path, branch name, commit message or diff text. The board is read
+- **Keep a secret.** The hooks never open Fabric's door token or an enrollment credential; `fabric-mcp` holds
+  those. Nothing secret is in argv (the worker's argv is the script and a spool folder) or in the log. Once Fabric
+  takes repositories (not on Windows), an `origin` URL that embeds a credential (`https://user:token@host/...`) is read by
+  `git config` with it; the Stop hook drops the credential in memory before anything is spooled, logged or sent.
+- **Send content, or use more than it reads for.** A turn is the HEAD commit, the number of files that differ from it
+  (untracked included) and the lines added and removed against it, and, once Fabric takes them (not on Windows), the other repositories
+  it touched by their `origin` name (`{host, owner, name}`); no path, branch name, commit message or diff text. The
+  transcript's tail is read, message text and tool output with it, and only tool names and path arguments are used; a sent turn's log
+  line counts its repositories, never names them. The board is read
   as a count (`com.status`), never a message. Git runs with `--no-optional-locks`.
 - **Start a second Fabric session.** A `fabric-mcp` started on its own would enroll a new session, and Fabric ends a
   binding's oldest live session past eight (ADR-0134 amendment 2): the agent's own. The worker and `watch-mail` run
@@ -129,7 +157,8 @@ only variable names are looked at, never a value (two of them carry the session'
 One line per event that did something, never content: `~/Library/Caches/ai.passioncode.fabric-agent-adapter/hooks.log`
 (macOS), `$XDG_CACHE_HOME/fabric-agent-adapter/hooks.log` (Linux, default `~/.cache`),
 `%LOCALAPPDATA%\fabric-agent-adapter\hooks.log` (Windows). Mode 0600, rotated at 1 MB to `hooks.log.1`. The
-per-session spool is `sessions/<session id>/` beside it (turn entries capped at 50, `board.json`, `board.shown`, and the nudges not yet printed: `nudges.json` for the prompt
+per-session spool is `sessions/<session id>/` beside it (turn entries capped at 50, each holding the session's folder when
+the turn ended (the Stop payload's `cwd`) and, when the turn touched another repository (only once Fabric takes them (not on Windows)), `repositories` as `{host, owner, name}`; `board.json`, `board.shown`, `repositories.degraded` (the once-a-session note that repositories were left out: the schema no longer takes them, or refused every item), and the nudges not yet printed: `nudges.json` for the prompt
 hook, `nudges.watch.json` for `watch-mail`, each taken by renaming it away; a
 folder untouched for 7 days, whose worker failed or whose session ended without SessionEnd, is removed by the next
 Stop or SessionEnd hook, even while the hooks are inert; an end entry whose release or observation got no answer stays
@@ -151,6 +180,6 @@ launched-session check exact.
 | D1 | `fabric-mcp` enrolls with the runtime session id | for `--runner claude-code`, `runtimeSessionId` = env `CLAUDE_CODE_SESSION_ID` in `fabric.session.enroll {cwd, runtimeSessionId}` (Claude Code 2.1.296 gives MCP stdio servers and Bash commands that variable, equal to the hooks' `session_id`) |
 | D2 | rejoin only | `fabric-mcp --runner claude-code --rejoin-only --runtime-session-id <id>` attaches to that runtime session's live enrolled session; never asks, never mints; otherwise only `fabric_whoami`, as not enrolled; Fabric 0.3.9 exits 3 at once when no session holds the id |
 | D3 | the flag | `hub.json` `"features": ["session-hooks/1"]` once D1, D2, D4 and D5 ship |
-| D4 | `fabric_session_observe` | `{event: "turn" or "end", runtime: "claude-code", runtimeSessionId, observedAt, head, filesChanged, linesAdded, linesRemoved, reason (end only), idempotencyKey}` → `session.turn.observed@1`, `session.ended@1`; from Fabric 0.3.14 a turn's answer is `{recorded, seq, nudges?}`, each nudge `{kind, says, task_id?, request_id?}` shown on a turn once, at most five, the same on a repeated turn, and kept for `fabric_work_list` and `fabric_heartbeat` (FAA-142) |
+| D4 | `fabric_session_observe` | `{event: "turn" or "end", runtime: "claude-code", runtimeSessionId, observedAt, head, filesChanged, linesAdded, linesRemoved, reason (end only), repositories (turn only, optional), idempotencyKey}` → `session.turn.observed@1`, `session.ended@1`; `repositories` (FAA-140, proposed to Fabric on `a8bdda7a`, accepted on `d3f9e6fb`) is at most 10 `{host, owner, name}` and is sent only where the tool's input schema lists it with items carrying host, owner and name, so a Fabric without it gets the call it gets today; from Fabric 0.3.14 a turn's answer is `{recorded, seq, nudges?}`, each nudge `{kind, says, task_id?, request_id?}` shown on a turn once, at most five, the same on a repeated turn, and kept for `fabric_work_list` and `fabric_heartbeat` (FAA-142) |
 | D5 | release a whole session | `fabric_work_release {claims: "session", outcome: "let-go", reason, idempotencyKey}`; `observedAt` too where its input schema names it (Fabric 0.3.9: `stale-end` for an end observed before the session enrolled) |
 | D6 | a launched-session marker | `FABRIC_LAUNCHED_SESSION=1` in the environment of every session Fabric launches, whatever its adapter; until then, the inference above |

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session.py

@@ -76,6 +76,8 @@ from fabric_session_env import (  # noqa: F401
     spawn_worker,
     _remove_tree,
     NO_SESSION_MARK,
+    REPOSITORIES_MARK,
+    repositories_wanted,
     NO_SESSION_HOLD_S,
     no_session_held,
 )
@@ -100,6 +102,15 @@ from fabric_session_mcp import (  # noqa: F401
     _wait_for_session_tools,
     NO_SESSION_EXIT,
     NoSessionError,
+    TRANSCRIPT_TAIL_BYTES,
+    MAX_REPOSITORIES,
+    BASH_BYTES,
+    _takes_repositories,
+    parse_origin,
+    bash_paths,
+    turn_paths,
+    turn_repositories,
+    stored_repositories,
 )
 from fabric_session_mail import (  # noqa: F401
     WATCH_MIN_INTERVAL_S,

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_cli.py

@@ -36,6 +36,7 @@ from fabric_session_env import (  # noqa: E402 - the kit (FAA-65)
     prune_stale_sessions,
     read_small,
     rejoined_recently,
+    repositories_wanted,
     session_dir,
     spawn_worker,
     spool,
@@ -44,6 +45,7 @@ from fabric_session_mcp import (  # noqa: E402 - the kit (FAA-65)
     FACTS_BUDGET_S,
     deliver,
     git_facts,
+    turn_repositories,
 )
 from fabric_session_mail import (  # noqa: E402 - the kit (FAA-65)
     watch_mail_cli,
@@ -164,7 +166,8 @@ def hook_user_prompt_submit(payload: Dict[str, Any], env: Optional[Dict[str, str
 
 
 def hook_spool(payload: Dict[str, Any], event: str, env: Optional[Dict[str, str]] = None, spawn=spawn_worker) -> str:
-    """Stop (`turn`) and SessionEnd (`end`): spool one entry, with the turn's facts measured now, and start the worker.
+    """Stop (`turn`) and SessionEnd (`end`): spool one entry, with the turn's facts measured now (and a turn's other
+    repositories, FAA-140), and start the worker.
     Returns what happened, for the tests. Nothing is spooled and no worker runs unless the running Fabric advertises
     `session-hooks/1` and `fabric` is registered: hub.json is read first because it is the cheap check that fails for
     every Fabric before the one that ships the hooks' dependency (`status` says so: "Session hooks: inert"). Stale
@@ -213,10 +216,16 @@ def hook_spool(payload: Dict[str, Any], event: str, env: Optional[Dict[str, str]
                 directory.mkdir(parents=True, exist_ok=True, mode=0o700)
                 _write_private(directory / LAUNCHED_MARK, "")
             return "skipped: launched by Fabric"
-    # The turn's own facts, measured when it ended (counts and ids only, never a path), not when a worker runs.
+    # The turn's own facts, measured when it ended (counts and ids only, never a path), not when a worker runs. The
+    # other repositories the turn changed (FAA-140) share the same budget: git_facts first, then what time is left.
+    until = time.monotonic() + FACTS_BUDGET_S
     entry = {"event": event, "runtimeSessionId": session_id, "cwd": str(cwd),
              "observedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-             "facts": git_facts(cwd, budget_s=FACTS_BUDGET_S)}
+             "facts": git_facts(cwd, until=until)}
+    if event == "turn" and repositories_wanted(env):  # only once Fabric takes them: no transcript read before (FAA-140)
+        repositories = turn_repositories(payload.get("transcript_path"), cwd, until)
+        if repositories:
+            entry["repositories"] = repositories
     if event == "end" and isinstance(payload.get("reason"), str):
         entry["reason"] = payload["reason"][:64]
     spool(directory, entry)

package/payload/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_env.py

@@ -58,7 +58,7 @@ SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 
 
-VERSION = "0.52.0"
+VERSION = "0.53.1"
 
 
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code",
@@ -476,6 +476,10 @@ LAUNCHED_MARK = "launched"
 #: (Fabric 0.3.9, TR-11). For NO_SESSION_HOLD_S the hooks spool nothing for that id; after it, one rejoin tries again,
 #: so a Fabric that restarted and enrolled the id again is found (board thread 02bf19c5, ask 4).
 NO_SESSION_MARK = "no-session"
+#: The file in the hooks' own folder (state_root) that says the running Fabric's fabric_session_observe takes
+#: `repositories` as {host, owner, name}: a worker writes it from the tool's schema and removes it when the schema stops
+#: saying so. Until it exists the Stop hook reads no transcript (FAA-140, seam and product readings 1).
+REPOSITORIES_MARK = "observe-takes-repositories"
 NO_SESSION_HOLD_S = 15 * 60.0
 
 
@@ -527,6 +531,12 @@ def _write_private(path: Path, text: str) -> None:
     os.replace(str(tmp), str(path))
 
 
+def repositories_wanted(env: Optional[Dict[str, str]] = None) -> bool:
+    """Whether the Stop hook reads the transcript for the turn's other repositories (FAA-140): only once a worker
+    left the mark, and never on Windows, where a Bash command's paths are not this host's (FAA-175)."""
+    return sys.platform != "win32" and (state_root(env=env) / REPOSITORIES_MARK).exists()
+
+
 def session_dir(session_id: str, env: Optional[Dict[str, str]] = None) -> Path:
     return state_root(env=env) / "sessions" / session_id