@passioncode-ai/passioncode 0.1.4

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

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""A complete, minimal fabric-service/0.1 service built on fabric_service.py.
+
+It is the worked example the skill points at, the target check_service.py tests
+itself against, and the fixture Fabric Dashboards runs its end-to-end tests on.
+
+  sample_service.py serve --port 47190 --data-dir DIR [--id sample] [--instance default]
+  sample_service.py register --port 47190 --data-dir DIR [--services-dir DIR]
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import os
+from http.server import BaseHTTPRequestHandler
+from pathlib import Path
+import signal
+import sys
+import threading
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs, urlparse
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import fabric_service as fs  # noqa: E402
+
+VERSION = "0.1.0"
+PAGE = """<!doctype html><html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1"><title>{name}</title>
+<style>body{{font:15px system-ui;margin:2rem;color:#e9e4ec;background:#0a070d}}li{{margin:.3rem 0}}</style>
+</head><body><h1>{name}</h1><p>Status: {status}</p><ul>{rows}</ul></body></html>"""
+
+
+class Service:
+    def __init__(self, args: argparse.Namespace):
+        self.id = args.id
+        self.instance = args.instance
+        self.name = args.name
+        self.port = args.port
+        self.data = Path(args.data_dir)
+        self.token_file = Path(args.token_file) if args.token_file else self.data / "service.token"
+        self.degraded = [{"source": "demo", "reason": args.degraded}] if args.degraded else []
+        self.started_at = fs.now_iso()
+        self.build = {"commit": os.environ.get("FABRIC_BUILD_COMMIT", "0000000"), "builtAt": self.started_at}
+
+    def start(self) -> None:
+        # Rule: the lock comes before ANY side effect, including creating the token.
+        self.lock = fs.hold_single_instance(self.data)
+        self.token = fs.ensure_token(self.token_file)
+        self.log = fs.JsonlEventLog(self.data / "events.jsonl")
+        self.codes = fs.LoginCodes(self.data / "auth")
+        self.log.append("service.started", "info", "%s started on build %s." % (self.name, self.build["commit"]))
+
+    def well_known(self) -> Dict[str, Any]:
+        return fs.build_well_known(
+            service_id=self.id, instance=self.instance, name=self.name, version=VERSION, build=self.build,
+            started_at=self.started_at, status="ready", degraded=self.degraded,
+            summary=[{"label": "Events", "value": len(self.log.fetch(None, fs.EVENTS_MAX_LIMIT))}],
+            surfaces={"dashboard": {"path": "/", "login": True}, "events": {"path": "/fabric/v1/events"}},
+        )
+
+
+def make_handler(svc: Service):
+    class Handler(BaseHTTPRequestHandler):
+        server_version = "fabric-sample/" + VERSION
+
+        def log_message(self, fmt: str, *args: Any) -> None:  # quiet by default
+            return
+
+        def _send(self, status: int, body: Any = None, headers: Optional[Dict[str, str]] = None,
+                  content_type: str = "application/json") -> None:
+            payload = b""
+            if body is not None:
+                payload = body.encode() if isinstance(body, str) else json.dumps(body).encode()
+            self.send_response(status)
+            self.send_header("Cache-Control", "no-store")
+            self.send_header("X-Content-Type-Options", "nosniff")
+            self.send_header("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'self'")
+            if body is not None:
+                self.send_header("Content-Type", content_type)
+                self.send_header("Content-Length", str(len(payload)))
+            for key, value in (headers or {}).items():
+                self.send_header(key, value)
+            self.end_headers()
+            if payload:
+                self.wfile.write(payload)
+
+        def _guard(self) -> bool:
+            reason = fs.check_request(svc.port, self.headers.get("Host"), self.headers.get("Origin"),
+                                      self.headers.get("Sec-Fetch-Site"))
+            if reason:
+                self._send(403, {"error": reason})
+                return False
+            return True
+
+        def _token_ok(self) -> bool:
+            if fs.token_matches(self.headers.get("Authorization"), svc.token):
+                return True
+            self._send(401, {"error": "The service token is required."}, {"WWW-Authenticate": "Bearer"})
+            return False
+
+        def _session_ok(self) -> bool:
+            return svc.codes.session_valid(fs.cookie_value(self.headers.get("Cookie")))
+
+        def do_GET(self) -> None:  # noqa: N802
+            if not self._guard():
+                return
+            url = urlparse(self.path)
+            query = parse_qs(url.query)
+            if url.path == "/.well-known/fabric-service":
+                return self._send(200, svc.well_known())
+            if url.path == "/fabric/v1/events":
+                if not self._token_ok():
+                    return
+                try:
+                    limit = fs.parse_limit((query.get("limit") or [None])[0])
+                    page = fs.events_page(svc.log.fetch, (query.get("after") or [None])[0], limit)
+                except fs.ServiceError as exc:
+                    return self._send(400, {"error": str(exc)})
+                return self._send(200, page)
+            if url.path == "/fabric/v1/login":
+                cookie = svc.codes.redeem((query.get("code") or [None])[0])
+                if not cookie:
+                    return self._send(403, "This sign-in link was already used or has expired.", content_type="text/plain")
+                return self._send(302, None, {"Location": "/", "Set-Cookie": fs.session_cookie_header(cookie)})
+            if url.path == "/":
+                if not self._session_ok():
+                    return self._send(401, "Open this dashboard from Fabric Dashboards.", content_type="text/plain")
+                rows = "".join("<li>%s — %s</li>" % (html.escape(e["at"]), html.escape(e["text"]))
+                               for e in reversed(svc.log.fetch(None, 20)))
+                return self._send(200, PAGE.format(name=html.escape(svc.name), status="ready", rows=rows),
+                                  content_type="text/html; charset=utf-8")
+            self._send(404, {"error": "Not found."})
+
+        def do_POST(self) -> None:  # noqa: N802
+            if not self._guard():
+                return
+            url = urlparse(self.path)
+            if url.path == "/fabric/v1/login-code":
+                if not self._token_ok():
+                    return
+                return self._send(200, svc.codes.issue())
+            if url.path == "/api/emit":
+                if not (self._session_ok() or fs.token_matches(self.headers.get("Authorization"), svc.token)):
+                    return self._send(401, {"error": "Sign in first."})
+                if self.headers.get("X-Fabric-Request") != "1":
+                    return self._send(403, {"error": "Missing request header."})
+                length = min(int(self.headers.get("Content-Length") or 0), 65536)
+                body = json.loads(self.rfile.read(length) or b"{}")
+                event = svc.log.append(body.get("kind", "demo.note"), body.get("level", "info"),
+                                       body.get("text", "A note from the sample service."),
+                                       notify=bool(body.get("notify")), link=body.get("link"))
+                return self._send(200, event)
+            self._send(404, {"error": "Not found."})
+
+    return Handler
+
+
+def make_server(svc: Service) -> fs.LoopbackHTTPServer:
+    return fs.LoopbackHTTPServer(("127.0.0.1", svc.port), make_handler(svc))
+
+
+def serve(args: argparse.Namespace) -> int:
+    svc = Service(args)
+    svc.start()
+    server = make_server(svc)
+
+    def stop(signum: int, _frame: Any) -> None:
+        svc.log.append("service.stopping", "info", "%s is stopping." % svc.name)
+        threading.Thread(target=server.shutdown, daemon=True).start()
+
+    signal.signal(signal.SIGTERM, stop)
+    signal.signal(signal.SIGINT, stop)
+    try:
+        server.serve_forever(poll_interval=0.2)
+    finally:
+        server.server_close()
+        svc.lock.release()
+    return 0
+
+
+def register(args: argparse.Namespace) -> int:
+    data = Path(args.data_dir)
+    descriptor = {
+        "protocol": fs.PROTOCOL, "id": args.id, "instance": args.instance, "name": args.name,
+        "summary": "Sample fabric-service/0.1 service.",
+        "origin": "http://127.0.0.1:%d" % args.port,
+        "auth": {"tokenFile": str(Path(args.token_file) if args.token_file else data / "service.token")},
+        "lifecycle": {"manager": "launchd", "label": args.label, "plist": args.plist} if args.label
+        else {"manager": "none"},
+        "paths": {"data": str(data), "logs": []},
+        "installedAt": fs.now_iso(), "installedBy": "sample_service.py register",
+    }
+    try:
+        path = fs.write_descriptor(descriptor, Path(args.services_dir) if args.services_dir else None)
+    except fs.ServiceError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    print(path)
+    return 0
+
+
+def main(argv: Optional[list] = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ("serve", "register"):
+        p = sub.add_parser(name)
+        p.add_argument("--port", type=int, required=True)
+        p.add_argument("--data-dir", required=True)
+        p.add_argument("--token-file")
+        p.add_argument("--id", default="sample")
+        p.add_argument("--instance", default="default")
+        p.add_argument("--name", default="Sample Service")
+        if name == "serve":
+            p.add_argument("--degraded", help="report one degraded source with this reason")
+        else:
+            p.add_argument("--services-dir")
+            p.add_argument("--label")
+            p.add_argument("--plist")
+    args = parser.parse_args(argv)
+    return serve(args) if args.command == "serve" else register(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,126 @@
+---
+name: creating-fabric-agents
+description: Use when designing and building a NEW agent or provider that must be Fabric-compatible from its first commit — «создай агента, совместимого с фабрикой Passion Code», «новый агент под Fabric», "create a fabric-compatible agent", "build a new Fabric provider", "fabric-ready agent from scratch". Runs the intake grill (capability, named consumer, workflow-or-agent, MCP/A2A/local-runner profile, effect declarations), distils source projects into a knowledge pack whose recorded failures become planted eval fixtures, scaffolds the pinned contract bundle, and sets the two-clock eval expectation with the conformance report. NOT for adapting an existing project (use adapting-projects-to-fabric), building the Fabric host or orchestrator, or generic agent design where Fabric compatibility is not part of the request.
+license: MIT
+compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned private fabric-agent-contract checkout. 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.4.2"
+  contract-version: "0.1.0"
+  contract-commit: "20a818e648a4c09a60df0126d11626922e8b9094"
+---
+
+# Creating Fabric-compatible agents
+
+Design a new agent so that Fabric compatibility is a property of its first commit, not a
+retrofit. The sibling skill `adapting-projects-to-fabric` wraps an interface that already
+exists; this one runs the stages that come *before* an interface exists — the intake
+grill and the knowledge intake — then hands the scaffolding and verification to the same
+pinned machinery, so both doors lead into one pipeline.
+
+## Boundary
+
+Use this skill to design and build a new provider. Do not use it to:
+
+- adapt a project that already has a stable API, MCP/A2A surface, or CLI — that is
+  `adapting-projects-to-fabric`, and entering there skips nothing;
+- design the Fabric host, registry, scheduler, admission service, or binding runtime;
+- build a generic agent with no Fabric requirement — nothing here helps a project that
+  will never be a provider;
+- claim admission: the deliverable is an admission-ready provider bundle, never a
+  connected provider.
+
+## Step 0 — the intake grill
+
+No file is created until every row has an answer. An answer of "later" fails the grill.
+
+| Question | The gate |
+|---|---|
+| **What capability?** | one capability, named as `domain.action` (optionally `@surface`), with input and output shapes statable now |
+| **Who calls it?** | **a named consumer** — the project, schedule, or workflow that will actually invoke this capability. No consumer, no agent: a role that "would be useful" is a catalogue entry, not a build order |
+| **Workflow or agent?** | if every step can be named now, build a deterministic workflow behind the capability and skip the autonomy — an agent buys flexibility with latency, cost, and a new failure class, and that price needs a reason |
+| **Which profile?** | `mcp` when Fabric owns planning and retries and the capability has a schema; `a2a` when the provider owns its task lifecycle end to end; `local-runner` when it is a terminal agent Fabric drives. When unsure, the sibling skill's profile-selection reference is the decision record |
+| **What effects?** | declare anything money-, deletion-, or publication-adjacent now — the host's floor and grants are designed against these declarations, and one discovered late invalidates the admission |
+| **Which tenancy?** | record whether the agent assumes one operator; the assumption is cheap to write down and expensive to excavate |
+
+## Step 1 — the knowledge intake
+
+If the estate holds prior art — a project that did this job, an audit that names its
+failures, a retro — distil it before writing code:
+
+1. Name the sources: repositories, `docs/`, audits, retrospectives, with references.
+2. Extract **patterns** (what worked, each citing its origin) and **traps** (recorded
+   failures and dead ends).
+3. **Convert every trap into a planted eval fixture.** The new agent is not done until
+   it has been watched rejecting the exact defects its predecessors were burned by —
+   knowledge transfers as a check, not as prose.
+4. Record the pack in the new project as `docs/knowledge-pack.md` with its sources, so
+   the provenance of every borrowed decision survives the person who borrowed it.
+
+Skipping this step because there is no prior art is legal; skipping it because reading
+is slower than generating is how the same collector truncates at the same row limit
+twice.
+
+## Step 2 — the project skeleton
+
+Create the minimal project: repository, `README.md` naming the capability and its
+consumer, and the eval **observables** — for each requirement, the pass/fail criterion
+that would show it met, written now, before the implementation. The input corpus is NOT
+authored now: it grows from real traces once the provider runs, and the step-1 fixtures
+are its seed because a source project's recorded failures count as production.
+
+## Step 3 — scaffold the provider bundle
+
+Reuse the sibling skill's scaffolder against the new skeleton with the profile chosen at
+step 0:
+
+```bash
+python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py \
+  scaffold <project-root> --profile <mcp|a2a|local-runner> \
+  --provider-id <stable-uri> --provider-name "<name>" \
+  --capability-id <stable-uri> --capability-name <domain.action> \
+  --schema-base <immutable-base-uri>
+```
+
+Pin exactly contract `0.1.0` at commit `20a818e648a4c09a60df0126d11626922e8b9094` and
+read the pinned guide before implementing protocol details. If this skill is installed
+without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
+contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check
+`NOT_RUN` — do not reconstruct normative rules from memory.
+
+The generated placeholders are deliberate blockers; a bundle still containing one is not
+ready for admission.
+
+## Step 4 — implement against the observables
+
+If the agent keeps running on the operator's computer — it answers other agents, runs
+long jobs or shows a dashboard — build it as a service with the sibling skill
+`building-fabric-services`: its instance lock, launchd plist, descriptor, well-known
+document and events feed are part of this step, not a later retrofit. If that skill is
+absent, apply the `fabric-service/0.1` rules from the pinned contract's
+`docs/specification/service.md` by hand and mark its probe `NOT_RUN`.
+
+Build the capability behind the chosen surface. Keep model choice and internal reasoning
+outside the contract; expose typed outcomes, evidence, and protocol-visible state. Every
+provider output is untrusted until schemas and semantic assertions pass. The step-2
+observables are the definition of done; an observable attached after the code exists
+lets the output decide what counts as success.
+
+## Step 5 — check, report, and set the canary expectation
+
+Run the sibling skill's `check` (structural, then exact when the contract checkout is
+available) and complete `fabric/FABRIC-CONFORMANCE.md` with dated receipts, exactly as
+its workflow steps 5–7 prescribe — this skill adds no second verification path on
+purpose. Then record one expectation the report must carry:
+
+> When a Fabric host admits this provider, it enters under a **canary binding** — a
+> checker on its output and a budget cap — regardless of who wrote it. Unsupervised
+> operation is a later, recorded promotion citing eval results and run history.
+
+## Completion format
+
+Report: capability, consumer, profile with the step-0 grill answers; the knowledge pack
+and which traps became fixtures; created files; contract version and commit; the gate
+table with `PASS`, `FAIL`, `NOT_RUN`, or `NOT_VERIFIED`; remaining placeholders; and the
+exact next command. Never summarize the outcome as "Fabric-compatible" unless every
+required admission gate passed against the real provider.

package/payload/plugins/observatory-log/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "name": "observatory-log",
+  "displayName": "Observatory Log",
+  "description": "Records what changed in a watched project at the end of every turn, and asks for the one thing a diff cannot contain: why.",
+  "version": "0.12.2",
+  "license": "MIT",
+  "author": {
+    "name": "Sergey Sheleg",
+    "url": "https://sshlg.me/"
+  },
+  "homepage": "https://github.com/passioncode-ai/project-observatory-dashboard",
+  "keywords": [
+    "observability",
+    "memory",
+    "git",
+    "ledger"
+  ]
+}

package/payload/plugins/observatory-log/hooks/ask-why.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Turn a record_turn.py result into the Stop hook's structured output.
+
+Standard library only, and silent on anything unexpected: a hook that reports
+its own confusion as a failure teaches the operator to disable hooks.
+
+It never blocks. The facts are already on the record without the agent's
+cooperation, so the only thing left to ask for is the `why` — and asking is
+worth more than a veto that costs a turn. An absent `why` stays visible in the
+ledger as a proposed record with a null field, which is accountability without
+obstruction.
+"""
+from __future__ import annotations
+import json
+import sys
+
+OWNER = "agent:claude-code"
+
+
+def main() -> int:
+    try:
+        r = json.load(sys.stdin)
+    except Exception:
+        return 0
+    if not r.get("recorded"):
+        # A FAULT IS NOT A QUIET TURN. This returned 0 for every `recorded:
+        # false`, and the recorder's reasons are two different kinds: "nothing
+        # changed" is an answer about the work, while `IllegalTransition:
+        # observed -> proposed` is the recorder failing. Measured 2026-09-07:
+        # once `tools/corroborate.py` promoted a session's record, every later
+        # turn of that session raised that error and said nothing — roughly
+        # seventy-two turns in one session, and the only visible sign was a
+        # ledger row that had stopped moving.
+        #
+        # The recorder marks which kind it is; this only has to stop hiding it.
+        reason = r.get("reason") or ""
+        if not r.get("fault"):
+            return 0                   # nothing changed, not watched, or explained
+        print(json.dumps({"systemMessage":
+                          "Observatory could NOT record this turn: " + reason +
+                          "\n\nThe facts of this turn are not in the ledger. "
+                          "`store/raw/record-turn.json` holds the same reason, and "
+                          "`./observatory.py findings` raises it.",
+                          "suppressOutput": True}))
+        return 0
+    if r.get("hasWhy"):
+        return 0                                          # already explained
+
+    mid = r.get("memoryId")
+    rev = r.get("revision")
+    project = r.get("project", "this project")
+    files = r.get("files", 0)
+    plural = "" if files == 1 else "s"
+    unpushed = r.get("unpushed") or 0
+    extra = f", {unpushed} unpushed commit(s)" if unpushed else ""
+
+    message = (
+        f"Observatory recorded the facts of this turn in {project}: "
+        f"{files} file{plural} changed, +{r.get('insertions', 0)}/-{r.get('deletions', 0)}"
+        f"{extra}. Stored as {mid}@{rev}, state proposed, with no `why`.\n\n"
+        "The diff already says WHAT changed. Add WHY — one or two sentences a "
+        "reader in six months could not reconstruct from the diff: the constraint "
+        "that forced the shape, the alternative rejected, the trap avoided.\n\n"
+        f"  observatory_record(owner=\"{OWNER}\", memory_id=\"{mid}\", "
+        f"expected_revision={rev}, statement=<the same claim>, why=<the reason>)\n\n"
+        "If the change genuinely needs no explanation — a typo, a rename — say so "
+        "and skip it. An empty `why` on a trivial edit is honest; an invented one "
+        "is worse than nothing, because it will be read as true."
+    )
+    # THE NUDGE AT THE MOMENT OF WORK. The agent is already inside this project;
+    # rebuilding its graph or touching its note costs least right now. Thresholds
+    # match the board's grace (7 days), and None means the artefact does not
+    # exist — not adopting graphify is a choice this hook does not argue with.
+    stale_bits = []
+    g = r.get("graphAgeDays")
+    if isinstance(g, int) and g > 7:
+        stale_bits.append(f"its code graph is {g} days old — refresh it: "
+                          f"/graphify . --update")
+    w = r.get("wikiAgeDays")
+    if isinstance(w, int) and w > 7:
+        stale_bits.append(f"its wiki notes were last touched {w} days ago — if this "
+                          f"work changed what the project IS (modules, scope, "
+                          f"stack), update the overview note too")
+    if stale_bits:
+        message += ("\n\nWhile you are here — this project's recorded knowledge "
+                    "is behind its code:\n  - " + "\n  - ".join(stale_bits))
+    print(json.dumps({"systemMessage": message, "suppressOutput": True},
+                     ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except SystemExit:
+        raise
+    except Exception:
+        raise SystemExit(0)

package/payload/plugins/observatory-log/hooks/hooks.json

@@ -0,0 +1,31 @@
+{
+  "description": "Optional Claude Code hooks: record changes in watched Git projects and request missing reasoning. SessionStart reports brief actionable context. Missing workspace, interpreter or watched project degrades quietly; hooks do not block a turn. Project names and paths stay in the private workspace.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "shell": "bash",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh\"",
+            "timeout": 15,
+            "statusMessage": "What the observatory knows about this project"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "shell": "bash",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/record-turn.sh\"",
+            "timeout": 20,
+            "statusMessage": "Recording what changed"
+          }
+        ]
+      }
+    ]
+  }
+}

package/payload/plugins/observatory-log/hooks/record-turn.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+
+
+
+
+
+
+set -uo pipefail
+
+emit() { printf '%s\n' "$1"; exit 0; }
+
+
+if [ -t 0 ]; then payload=""; else payload=$(cat 2>/dev/null || true); fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+root="${OBSERVATORY_ROOT:-}"
+if [ -z "$root" ] && [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then
+  c="${CLAUDE_PLUGIN_ROOT}"
+  for _ in 1 2 3 4 5 6; do
+    [ -f "$c/observatory.py" ] && { root="$c"; break; }
+    n="$(cd "$c/.." 2>/dev/null && pwd)" || break
+    [ "$n" = "$c" ] && break                 # reached the filesystem root
+    c="$n"
+  done
+fi
+[ -n "$root" ] || exit 0                       # no checkout: silent, not an error
+[ -f "$root/tools/record_turn.py" ] || exit 0  # older checkout: silent
+
+py="${OBSERVATORY_PYTHON:-$root/.venv/bin/python}"   # set by `full agent install`
+[ -x "$py" ] || py="$(command -v python3 2>/dev/null)"
+[ -n "$py" ] || exit 0                         # no interpreter: silent
+
+read_field() {                     # read_field <key>
+  [ -n "$payload" ] || return 0
+  printf '%s' "$payload" | "$py" -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+print(d.get(sys.argv[1]) or "")
+' "$1" 2>/dev/null
+}
+
+
+
+
+[ "$(read_field stop_hook_active)" = "True" ] && exit 0
+[ "$(read_field stop_hook_active)" = "true" ] && exit 0
+
+cwd="$(read_field cwd)"; [ -n "$cwd" ] || cwd="${CLAUDE_PROJECT_DIR:-$PWD}"
+session="$(read_field session_id)"
+
+
+result="$("$py" "$root/tools/record_turn.py" --cwd "$cwd" --session-id "$session" 2>/dev/null)"
+[ -n "$result" ] || exit 0
+
+printf '%s' "$result" | "$py" "${CLAUDE_PLUGIN_ROOT:-$(dirname "$0")/..}/hooks/ask-why.py" 2>/dev/null
+exit 0

package/payload/plugins/observatory-log/hooks/session-start.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+
+
+
+
+
+
+set -uo pipefail
+if [ -t 0 ]; then payload=""; else payload=$(cat 2>/dev/null || true); fi
+root="${OBSERVATORY_ROOT:-}"
+if [ -z "$root" ] && [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then
+  c="${CLAUDE_PLUGIN_ROOT}"
+  for _ in 1 2 3 4 5 6; do
+    [ -f "$c/observatory.py" ] && { root="$c"; break; }
+    n="$(cd "$c/.." 2>/dev/null && pwd)" || break
+    [ "$n" = "$c" ] && break
+    c="$n"
+  done
+fi
+[ -n "$root" ] || exit 0
+[ -f "$root/tools/session_start.py" ] || exit 0
+py="${OBSERVATORY_PYTHON:-$root/.venv/bin/python}"   # set by `full agent install`
+[ -x "$py" ] || py="$(command -v python3 2>/dev/null)"
+[ -n "$py" ] || exit 0
+printf '%s' "$payload" | "$py" "$root/tools/session_start.py" 2>/dev/null || true
+exit 0