@friedbotstudio/create-baseline 0.1.0

package/obj/template/.claude/hooks/lib/common.sh

@@ -0,0 +1,328 @@
+#!/usr/bin/env bash
+# Shared helpers for baseline Claude Code hook scripts.
+# Sourced by every hook in .claude/hooks/.
+#
+# Contract:
+#   - Hooks receive a JSON payload on stdin (the Claude Code hook event).
+#   - Hooks emit JSON to stdout for structured decisions, or exit non-zero with
+#     a stderr message to block/warn.
+#   - All hooks must be resilient to a missing/invalid project.json.
+#
+# Dependencies: bash >= 4, python3 (JSON parsing — POSIX-portable enough for
+# macOS + modern Linux). No jq requirement.
+
+set -u
+
+# Defensive PATH: hooks may be invoked with a minimal environment. Ensure the
+# standard utilities (dirname, cat, date, etc.) and python3 are findable.
+export PATH="${PATH:-}:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/usr/sbin:/sbin"
+if [ -z "${PATH%%:*}" ]; then
+  PATH="${PATH#:}"
+  export PATH
+fi
+
+CLAUDE_PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+CLAUDE_DOTDIR="$CLAUDE_PROJECT_ROOT/.claude"
+PROJECT_JSON="$CLAUDE_DOTDIR/project.json"
+STATE_DIR="$CLAUDE_DOTDIR/state"
+LOG_DIR="$STATE_DIR/logs"
+mkdir -p "$STATE_DIR" "$LOG_DIR" 2>/dev/null || true
+
+# Read the raw hook JSON payload from stdin into HOOK_PAYLOAD.
+read_payload() {
+  HOOK_PAYLOAD="$(cat)"
+  export HOOK_PAYLOAD
+}
+
+# Extract a field from the hook payload using a jsonpath-ish dotted path.
+# Usage: payload_get '.tool_input.command'
+# Requires read_payload to have been called first (so HOOK_PAYLOAD is set).
+payload_get() {
+  local path="$1"
+  python3 - "$path" <<'PY'
+import json, os, sys
+path = sys.argv[1]
+raw = os.environ.get("HOOK_PAYLOAD", "")
+if not raw:
+    sys.exit(0)
+try:
+    data = json.loads(raw)
+except Exception:
+    sys.exit(0)
+cur = data
+for part in path.strip('.').split('.'):
+    if part == '':
+        continue
+    if isinstance(cur, dict):
+        cur = cur.get(part)
+    else:
+        cur = None
+        break
+if cur is None:
+    sys.exit(0)
+if isinstance(cur, (dict, list)):
+    print(json.dumps(cur))
+else:
+    print(cur)
+PY
+}
+
+# Read a field from .claude/project.json at a dotted path.
+# Prints empty string if project.json or key is missing.
+project_get() {
+  local path="$1"
+  [ -f "$PROJECT_JSON" ] || { echo ""; return 0; }
+  python3 - "$path" "$PROJECT_JSON" <<'PY'
+import json, sys
+path, pj = sys.argv[1], sys.argv[2]
+try:
+    with open(pj) as f:
+        data = json.load(f)
+except Exception:
+    sys.exit(0)
+cur = data
+for part in path.strip('.').split('.'):
+    if part == '':
+        continue
+    if isinstance(cur, dict):
+        cur = cur.get(part)
+    else:
+        cur = None
+        break
+if cur is None:
+    sys.exit(0)
+if isinstance(cur, (dict, list)):
+    print(json.dumps(cur))
+else:
+    print(cur)
+PY
+}
+
+# Emit a structured block decision (PreToolUse).
+# Usage: emit_block "reason text"
+emit_block() {
+  local reason="$1"
+  python3 - "$reason" <<'PY'
+import json, sys
+print(json.dumps({
+    "hookSpecificOutput": {
+        "hookEventName": "PreToolUse",
+        "permissionDecision": "deny",
+        "permissionDecisionReason": sys.argv[1],
+    }
+}))
+PY
+  exit 0
+}
+
+# Emit a structured ask decision (PreToolUse).
+emit_ask() {
+  local reason="$1"
+  python3 - "$reason" <<'PY'
+import json, sys
+print(json.dumps({
+    "hookSpecificOutput": {
+        "hookEventName": "PreToolUse",
+        "permissionDecision": "ask",
+        "permissionDecisionReason": sys.argv[1],
+    }
+}))
+PY
+  exit 0
+}
+
+# Emit an allow (no-op) decision. Equivalent to exit 0 with no output, but
+# explicit for clarity.
+emit_allow() {
+  exit 0
+}
+
+# Emit an informational message (PostToolUse or advisory PreToolUse). Does not
+# block. Printed to stderr so it surfaces in the transcript without polluting
+# stdout (which Claude Code interprets as structured output).
+emit_info() {
+  printf '%s\n' "$1" >&2
+}
+
+# Append a line to a hook-specific log for debugging. Never fails the hook.
+log_line() {
+  local hook="$1" msg="$2"
+  printf '%s  %s\n' "$(date -u +%FT%TZ)" "$msg" >>"$LOG_DIR/$hook.log" 2>/dev/null || true
+}
+
+# True if the given path matches any glob in a JSON array (from project_get).
+# Usage: path_matches_globs "src/foo.py" "$(project_get .tdd.source_globs)"
+path_matches_globs() {
+  local path="$1" globs_json="$2"
+  [ -z "$globs_json" ] && return 1
+  python3 - "$path" "$globs_json" <<'PY'
+import json, sys, fnmatch
+path, globs_json = sys.argv[1], sys.argv[2]
+try:
+    globs = json.loads(globs_json)
+except Exception:
+    sys.exit(1)
+if not isinstance(globs, list):
+    sys.exit(1)
+for g in globs:
+    if fnmatch.fnmatchcase(path, g) or fnmatch.fnmatchcase(path, g.rstrip('/**') + '/*'):
+        sys.exit(0)
+    # also handle simple ** recursion
+    if '**' in g:
+        # translate ** to match any depth
+        import re
+        pat = re.escape(g).replace(r'\*\*', '.*').replace(r'\*', '[^/]*').replace(r'\?', '.')
+        if re.fullmatch(pat, path):
+            sys.exit(0)
+sys.exit(1)
+PY
+}
+
+# True if stdin command matches any pattern in a JSON-array-of-regex.
+# Usage: cmd_matches_any "$cmd" "$(project_get .destructive.hard_block_patterns)"
+cmd_matches_any() {
+  local cmd="$1" patterns_json="$2"
+  [ -z "$patterns_json" ] && return 1
+  python3 - "$cmd" "$patterns_json" <<'PY'
+import json, sys, re
+cmd, patterns_json = sys.argv[1], sys.argv[2]
+try:
+    patterns = json.loads(patterns_json)
+except Exception:
+    sys.exit(1)
+for p in patterns:
+    try:
+        if re.search(p, cmd):
+            sys.exit(0)
+    except re.error:
+        continue
+sys.exit(1)
+PY
+}
+
+# Canonicalize a path and make it relative to CLAUDE_PROJECT_ROOT.
+# Lexical only — collapses ./ and ../ via os.path.normpath, does NOT resolve
+# symlinks. This is deliberate: symlink resolution would let a path like
+# .claude/state/spec_approvals/foo.approval (whose final component is a
+# symlink to /tmp/x) silently redirect, defeating the case-pattern checks.
+# Symlink-swap defense is a separate hardening (see seed.md §16 follow-ups).
+#
+# Returns the project-relative canonical path on stdout, or an absolute
+# canonical path if the input escapes the project root. Empty if input is
+# empty or equals the project root.
+canonical_rel() {
+  python3 - "$1" "$CLAUDE_PROJECT_ROOT" <<'PY'
+import os, sys
+file_path = sys.argv[1]
+root = sys.argv[2]
+if not file_path:
+    sys.exit(0)
+norm = os.path.normpath(os.path.abspath(file_path))
+norm_root = os.path.normpath(os.path.abspath(root))
+sep = os.sep
+if norm == norm_root:
+    print("")
+elif norm.startswith(norm_root + sep):
+    print(norm[len(norm_root) + 1:])
+else:
+    print(norm)
+PY
+}
+
+# Consent-gate marker file paths — written ONLY by consent_gate_grant.sh
+# (UserPromptSubmit) when the user invokes the corresponding slash command,
+# read by the gate guards (PreToolUse) before allowing approval-token writes.
+# Hooks reference these constants instead of literal paths so a rename is a
+# one-line change. Relative variants are for case-pattern matching against
+# tool_input.file_path after CLAUDE_PROJECT_ROOT stripping.
+CONSENT_MARKER_SPEC="$STATE_DIR/.spec_approval_grant"
+CONSENT_MARKER_SWARM="$STATE_DIR/.swarm_approval_grant"
+CONSENT_MARKER_COMMIT="$STATE_DIR/.commit_consent_grant"
+CONSENT_MARKER_SPEC_REL=".claude/state/.spec_approval_grant"
+CONSENT_MARKER_SWARM_REL=".claude/state/.swarm_approval_grant"
+CONSENT_MARKER_COMMIT_REL=".claude/state/.commit_consent_grant"
+
+# Reduce any user-typed approval argument (bare slug, filename, or path) to a
+# bare slug. Called from BOTH ends of the consent handshake so the marker and
+# the expected-slug check produce the same shape:
+#   docs/specs/foo.md  -> foo
+#   foo.md             -> foo
+#   foo                -> foo
+#   approval-slug-canonicalization -> approval-slug-canonicalization
+# Also used by the approval guards: feed in basename(file, .approval) to
+# canonicalize legacy `<slug>.md.approval` and current `<slug>.approval` to
+# the same bare slug, so both filename shapes validate.
+canonical_slug() {
+  local s="${1##*/}"
+  printf '%s' "${s%.md}"
+}
+
+# Block Claude from writing a consent-marker file via Write/Edit/MultiEdit.
+# The marker's unforgeability is what makes the consent gate structural —
+# only consent_gate_grant (UserPromptSubmit, outside Claude's tool boundary)
+# may produce it.
+#
+# Args: $1 rel_path  $2 marker_rel_path  $3 gate_label  $4 user_command_hint
+# Calls emit_block (which exits) on match; returns 0 otherwise.
+block_marker_self_write() {
+  local rel="$1" marker_rel="$2" gate_label="$3" cmd_hint="$4"
+  local hook_log="${gate_label// /_}"
+  hook_log="${hook_log,,}"
+  if [ "$rel" = "$marker_rel" ]; then
+    log_line "$hook_log" "BLOCKED direct write to consent marker: $rel"
+    emit_block "$gate_label: '$rel' is a consent marker written by the consent_gate_grant UserPromptSubmit hook in response to \`$cmd_hint\`. Claude is not permitted to create or edit this marker — its unforgeability is what makes the gate structurally enforced."
+  fi
+}
+
+# Validate a consent marker (freshness + optional slug match) and consume it.
+# emit_blocks (and exits) on any failure; returns 0 on success after deleting
+# the marker. TTL comes from .consent.gate_marker_ttl_seconds (default 60).
+#
+# Args: $1 marker_path  $2 gate_label  $3 user_command_hint  [$4 expected_slug]
+#
+# Marker shape:
+#   - With slug ($4 non-empty):  line 1 = slug, line 2 = epoch.
+#   - Epoch-only ($4 empty):     line 1 = epoch.
+validate_consent_marker() {
+  local marker="$1" gate_label="$2" cmd_hint="$3" expected_slug="${4:-}"
+  local hook_log ttl marker_slug marker_epoch now age
+  hook_log="${gate_label// /_}"
+  hook_log="${hook_log,,}"
+
+  ttl="$(project_get .consent.gate_marker_ttl_seconds)"
+  [ -z "$ttl" ] && ttl=120
+
+  if [ ! -f "$marker" ]; then
+    log_line "$hook_log" "BLOCKED no marker: $marker"
+    emit_block "$gate_label: requires a fresh consent marker at $marker. The marker is produced by the consent_gate_grant hook when the user runs \`$cmd_hint\` — Claude cannot create it."
+  fi
+
+  if [ -n "$expected_slug" ]; then
+    { read -r marker_slug; read -r marker_epoch; } < "$marker" 2>/dev/null
+  else
+    read -r marker_epoch < "$marker" 2>/dev/null
+    marker_slug=""
+  fi
+
+  if ! [[ "$marker_epoch" =~ ^[0-9]+$ ]]; then
+    log_line "$hook_log" "BLOCKED malformed marker: $marker"
+    emit_block "$gate_label: marker at $marker is malformed. Ask the user to re-run \`$cmd_hint\`."
+  fi
+
+  now="$(date +%s)"
+  age=$(( now - marker_epoch ))
+  if [ "$age" -gt "$ttl" ]; then
+    log_line "$hook_log" "BLOCKED marker expired age=${age}s ttl=${ttl}s"
+    rm -f "$marker"
+    emit_block "$gate_label: consent marker expired (${age}s old, TTL ${ttl}s). Ask the user to re-run \`$cmd_hint\`."
+  fi
+
+  if [ -n "$expected_slug" ] && [ "$marker_slug" != "$expected_slug" ]; then
+    log_line "$hook_log" "BLOCKED slug mismatch marker=$marker_slug expected=$expected_slug"
+    emit_block "$gate_label: marker slug ($marker_slug) does not match expected ($expected_slug). Ask the user to re-run \`$cmd_hint\` with the correct argument."
+  fi
+
+  log_line "$hook_log" "ALLOWED marker=$marker age=${age}s slug=${marker_slug:-N/A}"
+  rm -f "$marker"
+  return 0
+}

package/obj/template/.claude/hooks/lib/resume_writer.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""Continuity snapshot writer.
+
+Walks a Claude Code transcript JSONL plus state files and writes a
+single-snapshot `.claude/memory/_resume.md`. Shared by:
+
+  - memory_pre_compact.sh (PreCompact event — capture before compaction)
+  - memory_stop.sh        (Stop event      — refresh every turn-end)
+
+The snapshot answers "where were we / what's next?" so a session that
+gets compacted, /clear'd, or resumed in a new shell can pick up without
+the user re-explaining context.
+
+Heuristic only: scrapes the transcript for recent user prompts, recent
+file writes, and the most recent Skill invocation, then merges with
+.claude/state/workflow.json if present.
+
+Invoked as:
+    python3 resume_writer.py <transcript_path> <project_dir> <trigger>
+
+trigger is one of: pre-compact, stop, harness — recorded in frontmatter.
+Exits 0 on success or any failure (this is best-effort; it must never
+break the hook that called it).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable
+
+# How many most-recent items of each kind to retain in the snapshot.
+MAX_USER_PROMPTS = 3
+MAX_FILES = 12
+MAX_SKILLS = 5
+MAX_BASH = 5
+USER_PROMPT_CHARS = 400  # truncate per-prompt; the snapshot is bounded
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _read_json(path: Path) -> dict | list | None:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _iter_transcript_events(transcript: Path) -> Iterable[dict]:
+    if not transcript.is_file():
+        return
+    try:
+        with transcript.open("r", encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    yield json.loads(line)
+                except Exception:
+                    continue
+    except Exception:
+        return
+
+
+def _extract_text_blocks(content) -> list[str]:
+    """A message's `content` is either a string or list of typed blocks."""
+    out: list[str] = []
+    if isinstance(content, str):
+        if content.strip():
+            out.append(content.strip())
+        return out
+    if not isinstance(content, list):
+        return out
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        if block.get("type") == "text":
+            t = block.get("text", "")
+            if isinstance(t, str) and t.strip():
+                out.append(t.strip())
+    return out
+
+
+def _walk(transcript: Path) -> dict:
+    """Single pass over the transcript collecting everything we need."""
+    user_prompts: list[str] = []
+    file_writes: list[tuple[str, str]] = []  # (path, tool)
+    skill_calls: list[str] = []
+    bash_cmds: list[str] = []
+    last_assistant_text: str = ""
+
+    for ev in _iter_transcript_events(transcript):
+        msg = ev.get("message") if isinstance(ev, dict) else None
+        if not isinstance(msg, dict):
+            # Some transcripts put role/content at top level.
+            msg = ev if isinstance(ev, dict) else {}
+        role = msg.get("role") or ev.get("role") if isinstance(ev, dict) else None
+        content = msg.get("content")
+
+        if role == "user":
+            for t in _extract_text_blocks(content):
+                # Skip system-reminder noise and hook injections.
+                if t.startswith("<system-reminder>") or "<command-name>" in t[:64]:
+                    continue
+                if t.startswith("<local-command-"):
+                    continue
+                user_prompts.append(t)
+        elif role == "assistant":
+            text_blocks = _extract_text_blocks(content)
+            if text_blocks:
+                last_assistant_text = text_blocks[-1]
+            if isinstance(content, list):
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") != "tool_use":
+                        continue
+                    name = block.get("name", "")
+                    inp = block.get("input") or {}
+                    if name in ("Edit", "Write", "MultiEdit"):
+                        fp = inp.get("file_path") or ""
+                        if fp:
+                            file_writes.append((fp, name))
+                    elif name == "Skill":
+                        sk = inp.get("skill") or ""
+                        if sk:
+                            skill_calls.append(sk)
+                    elif name == "Bash":
+                        cmd = inp.get("command") or ""
+                        if cmd:
+                            bash_cmds.append(cmd.strip().splitlines()[0][:160])
+
+    return {
+        "user_prompts": user_prompts,
+        "file_writes": file_writes,
+        "skill_calls": skill_calls,
+        "bash_cmds": bash_cmds,
+        "last_assistant_text": last_assistant_text,
+    }
+
+
+def _read_workflow(project_dir: Path) -> dict:
+    """Return whatever .claude/state/workflow.json holds, or {}."""
+    p = project_dir / ".claude" / "state" / "workflow.json"
+    data = _read_json(p)
+    return data if isinstance(data, dict) else {}
+
+
+def _last_harness_log_line(project_dir: Path, slug: str) -> str:
+    log = project_dir / ".claude" / "state" / "harness" / f"{slug}.log"
+    if not log.is_file():
+        return ""
+    try:
+        lines = [ln for ln in log.read_text(encoding="utf-8", errors="replace").splitlines() if ln.strip()]
+        return lines[-1] if lines else ""
+    except Exception:
+        return ""
+
+
+def _rel(path: str, project_dir: Path) -> str:
+    """Make project-relative if possible."""
+    try:
+        p = Path(path)
+        if p.is_absolute():
+            return str(p.relative_to(project_dir))
+    except Exception:
+        pass
+    return path
+
+
+def _dedup_keep_order(items: Iterable[str]) -> list[str]:
+    seen: set[str] = set()
+    out: list[str] = []
+    for it in items:
+        if it in seen:
+            continue
+        seen.add(it)
+        out.append(it)
+    return out
+
+
+def compose_snapshot(transcript: Path, project_dir: Path, trigger: str) -> str:
+    walk = _walk(transcript)
+    workflow = _read_workflow(project_dir)
+
+    slug = workflow.get("slug") or "(none)"
+    entry_phase = workflow.get("entry_phase") or "(unknown)"
+    completed = workflow.get("completed") or []
+    exceptions = workflow.get("exceptions") or []
+    phases = workflow.get("phases") or []
+
+    # Next phase = first phase not in completed, after entry_phase.
+    next_phase = "(unknown)"
+    if phases and isinstance(completed, list):
+        try:
+            start = phases.index(entry_phase) if entry_phase in phases else 0
+        except ValueError:
+            start = 0
+        for ph in phases[start:]:
+            if ph in exceptions:
+                continue
+            if ph not in completed:
+                next_phase = ph
+                break
+        else:
+            next_phase = "(workflow complete)"
+
+    last_completed = completed[-1] if completed else "(none)"
+
+    # File writes — most recent unique paths, project-relative.
+    files_recent = []
+    for fp, _tool in reversed(walk["file_writes"]):
+        rel = _rel(fp, project_dir)
+        if rel.startswith(".claude/state/") or rel.startswith(".claude/memory/_pending"):
+            continue
+        if rel not in files_recent:
+            files_recent.append(rel)
+        if len(files_recent) >= MAX_FILES:
+            break
+
+    # User prompts — last K, most-recent first.
+    prompts_recent = walk["user_prompts"][-MAX_USER_PROMPTS:]
+    prompts_recent = list(reversed(prompts_recent))
+
+    # Skill calls — last K, dedup keep-order, most-recent first.
+    skills_recent = list(reversed(_dedup_keep_order(walk["skill_calls"][-MAX_SKILLS * 3:])))[:MAX_SKILLS]
+
+    # Bash — last K (chatty, so keep small).
+    bash_recent = walk["bash_cmds"][-MAX_BASH:]
+    bash_recent = list(reversed(bash_recent))
+
+    last_log = _last_harness_log_line(project_dir, slug) if slug != "(none)" else ""
+
+    # Continue-with hint.
+    if slug == "(none)":
+        hint = "No active workflow. Run `/triage \"<request>\"` to start one, or `/harness` if you have a concrete request."
+    elif next_phase == "(workflow complete)":
+        hint = f"Workflow `{slug}` is complete. Run `/grant-commit` then `/harness` to commit."
+    else:
+        hint = f"Run `/harness` to resume `{slug}` at phase `{next_phase}`."
+
+    # Compose markdown.
+    lines: list[str] = []
+    lines.append("---")
+    lines.append("name: resume")
+    lines.append("type: continuity")
+    lines.append(f"last-updated: {_utc_now_iso()}")
+    lines.append(f"trigger: {trigger}")
+    lines.append("---")
+    lines.append("")
+    lines.append("# Resume snapshot")
+    lines.append("")
+    lines.append("## Active workflow")
+    lines.append(f"- Slug: `{slug}`")
+    lines.append(f"- Entry phase: `{entry_phase}`")
+    lines.append(f"- Last completed phase: `{last_completed}`")
+    lines.append(f"- Next phase due: `{next_phase}`")
+    if exceptions:
+        lines.append(f"- Exceptions: {', '.join(f'`{e}`' for e in exceptions)}")
+    if last_log:
+        lines.append(f"- Last harness log: `{last_log}`")
+    lines.append("")
+
+    lines.append("## In-flight files (most recent writes this session)")
+    if files_recent:
+        for fp in files_recent:
+            lines.append(f"- `{fp}`")
+    else:
+        lines.append("- (none captured)")
+    lines.append("")
+
+    lines.append("## Recent skill invocations")
+    if skills_recent:
+        for sk in skills_recent:
+            lines.append(f"- `/{sk}`")
+    else:
+        lines.append("- (none captured)")
+    lines.append("")
+
+    if bash_recent:
+        lines.append("## Recent shell commands")
+        for cmd in bash_recent:
+            lines.append(f"- `{cmd}`")
+        lines.append("")
+
+    lines.append("## Recent user requests (most recent first)")
+    if prompts_recent:
+        for p in prompts_recent:
+            text = p.replace("\r", " ")
+            if len(text) > USER_PROMPT_CHARS:
+                text = text[:USER_PROMPT_CHARS].rstrip() + "…"
+            block = "\n".join(f"> {ln}" for ln in text.splitlines())
+            lines.append(block)
+            lines.append("")
+    else:
+        lines.append("- (none captured)")
+        lines.append("")
+
+    lines.append("## Continue with")
+    lines.append(hint)
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def write_snapshot(transcript: Path, project_dir: Path, trigger: str) -> Path | None:
+    mem_dir = project_dir / ".claude" / "memory"
+    if not mem_dir.is_dir():
+        return None
+    body = compose_snapshot(transcript, project_dir, trigger)
+    out = mem_dir / "_resume.md"
+    try:
+        out.write_text(body, encoding="utf-8")
+        return out
+    except Exception:
+        return None
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) < 4:
+        sys.stderr.write("usage: resume_writer.py <transcript> <project_dir> <trigger>\n")
+        return 0  # never fail the caller
+    try:
+        transcript = Path(argv[1])
+        project_dir = Path(argv[2])
+        trigger = argv[3]
+        write_snapshot(transcript, project_dir, trigger)
+    except Exception as e:
+        sys.stderr.write(f"resume_writer: {e}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))