ticketwright 3.2.0__tar.gz → 3.3.0__tar.gz

ticketwright-3.3.0/.claude/config/stack.example.multi-warehouse.yaml

@@ -0,0 +1,104 @@
+# stack.example.multi-warehouse.yaml — a team that must reach TWO warehouses.
+#
+# Jira / Snowflake + Databricks / Slack / Google Drive / GitHub. Everything except the warehouse
+# seam is identical to stack.yaml; this file exists to prove one claim — one warehouse seam can
+# hold several named targets, and every target is independently reachable.
+#
+# Skills resolve which target to use per `adapters/README.md` § Multi-target seams; a `.sql` file
+# names its own target in a `-- warehouse-target: <name>` header comment.
+# Field docs: stack.schema.md  ·  Validate: bash bin/verify_stack.sh .claude/config/stack.example.multi-warehouse.yaml
+
+project:
+  key_prefix: ENG
+  key_prefixes: [ENG]
+  assignee_dir: alice
+  ticket_path: "tickets/{assignee}/{id}"
+  ticket_subdirs: [source_materials, final_deliverables, qc_queries, exploratory_analysis]
+  default_epic: ENG-100
+  terminal_status: Done
+  ticket_url_template: "https://acme.atlassian.net/browse/{id}"
+  word_limits: {tracker_comment: 100, chat: 100, pr: 200, ticket: 200}
+  graph_notes: true
+  graph_config: true
+
+seams:
+  tracker:
+    tool: jira
+    adapter: adapters/tracker/jira.md
+    transport: both
+    site: acme.atlassian.net
+    cli: acli
+    mcp: atlassian
+    verify: 'acli jira workitem search --jql "project = {key_prefix}" --limit 1'
+
+  # ── MULTI-TARGET warehouse seam ───────────────────────────────────────────────────────────────
+  # The presence of `targets:` is the discriminator — NOT `default:`, because other seams already
+  # use default_channel / default_mode / default_branch and `default` must never carry type meaning.
+  #
+  # List the DEFAULT target FIRST. Readers that predate this feature (an un-relaunched session's
+  # statusline and SessionStart banner) display the first target they find, so first == default
+  # keeps them honest instead of quietly naming the wrong warehouse.
+  #
+  # Scalar keys at the SEAM level are inherited by every target, and a target's own key wins —
+  # handy when two targets share an account (one `cli:` up here, differing `default_warehouse:`
+  # per target).
+  warehouse:
+    default: prod
+    targets:
+      prod:
+        tool: snowflake
+        adapter: adapters/warehouse/snowflake.md
+        transport: both
+        cli: snow
+        default_warehouse: ANALYTICS_WH
+        pii_role: PII_READER
+        dev_target: ANALYTICS_DEV       # canonical; a legacy `dev_db:` is still honored
+        verify: "snow connection test"
+      lake:
+        tool: databricks
+        adapter: adapters/warehouse/databricks.md
+        transport: cli
+        cli: dbsqlcli
+        warehouse_id: 0a1b2c3d4e5f6789
+        catalog: main
+        schema: analytics
+        dev_target: main_dev            # was `dev_catalog:`
+        profile: DEFAULT
+        verify: "databricks --profile {profile} current-user me"
+
+  chat:
+    tool: slack
+    adapter: adapters/chat/slack.md
+    transport: mcp
+    mcp: slack
+    default_channel: C0XXXXXXXXX
+    default_mode: draft
+    always_include: [Alice]
+    verify: null
+
+  docstore:
+    tool: gdrive
+    adapter: adapters/docstore/gdrive.md
+    transport: cli
+    base_path: "/path/to/your/Shared drives/Tickets"
+    verify: "test -d \"{base_path}\""
+
+  vcs:
+    tool: github
+    adapter: adapters/vcs/github.md
+    transport: cli
+    default_branch: main
+    semantic_pr: true
+    worktree_root: ".claude/worktrees"
+    verify: "gh auth status"
+
+policies:
+  hard_halt_before_external_posts: true
+  db_write_requires_approval: true
+  chat_default_draft: true
+  hyperlink_everything: true
+  skillify_everything: true
+  reduce_assumptions: true
+  commit_plan_before_implement: true
+  system_evolution: true
+  deterministic_outputs: true

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/config/stack.schema.md

@@ -34,10 +34,13 @@ policies:       # behavioral rules every skill inherits (the kit's "global rules
 | `ticket_url_template` | template \| null | `https://acme.atlassian.net/browse/{id}` | How `tickets/INDEX.md` links each ticket (`{id}` token). Null/omitted → the index renders no per-ticket link. |
 | `word_limits` | map | `{tracker_comment: 100, chat: 100, pr: 200, ticket: 200}` | Hard caps the comms skills enforce. |
 | `graph_notes` | bool | `true` | Generate the Obsidian graph layer (`tickets/graph/` + `tickets/objects/`). On by default; set `false` to disable. |
+| `graph_config` | bool | `true` | Also write/merge `.obsidian/graph.json` (tickets↔objects filter + color groups) so the Graph view opens ready-to-read. Create/merge-only — never clobbers manual tweaks. On by default; set `false` to keep the nodes but not manage the Obsidian config. Ignored when `graph_notes` is `false`. |
 
 ## `seams`
 
-Exactly these five keys: `tracker`, `warehouse`, `chat`, `docstore`, `vcs`. Each:
+Exactly these five keys: `tracker`, `warehouse`, `chat`, `docstore`, `vcs`. Each is **either** a
+single mapping (below) **or** a *multi-target* mapping — see "Multiple warehouses". Fields of a
+single mapping:
 
 | Field | Type | Meaning |
 |---|---|---|
@@ -50,6 +53,51 @@ Exactly these five keys: `tracker`, `warehouse`, `chat`, `docstore`, `vcs`. Each
 The `warehouse` seam may also be `null`/omitted for non-data repos — `review`, `spec-and-build`,
 and `refresh context` degrade gracefully (skip warehouse steps) when it is.
 
+### Multiple warehouses (named targets)
+
+A repo that must reach more than one warehouse — prod Snowflake plus a Databricks lakehouse, or two
+Snowflake accounts — declares **named targets** instead of one flat mapping:
+
+```yaml
+  warehouse:
+    default: prod              # REQUIRED when `targets:` is present; must name a key below
+    cli: snow                  # seam-level scalars are inherited by every target
+    targets:
+      prod: { tool: snowflake,  adapter: adapters/warehouse/snowflake.md,  verify: "snow connection test" }
+      lake: { tool: databricks, adapter: adapters/warehouse/databricks.md, verify: "…" }
+```
+
+| Field | Type | Meaning |
+|---|---|---|
+| `targets` | map | Named targets. **Its presence is the discriminator** for a multi-target seam. |
+| `default` | string | Which target skills use when nothing else selects one. Required with `targets`. |
+
+Rules:
+
+- **Inheritance.** A target inherits any key it doesn't define itself, including `tool` / `adapter` /
+  `verify` — so two targets on one account can share all three and differ only in, say,
+  `default_warehouse`. A target's own key wins. Inheritance is keyed on *absence*: an explicit
+  `verify: null` on a target means "skip", it does not fall back to the seam's command.
+- **List the default first.** Readers that predate this feature (an un-relaunched session's statusline
+  and SessionStart banner) show the first target they find, so first == default keeps them honest.
+  `bin/verify_stack.sh` warns when the default isn't first, and fails when `default` is missing or
+  names an unknown target.
+- **Which target is active** is resolved per `adapters/README.md` § Multi-target seams. A `.sql` file
+  names its own target in a `-- warehouse-target: <name>` header comment; that never goes in a CSV,
+  whose header must stay on row 1 with no preamble.
+- v1 implements multi-target for **`warehouse`** only. `verify_stack.sh` handles the shape for any
+  seam, but no skill resolves targets for the other four, so don't rely on it there yet.
+
+**Known limitation:** `tickets/OBJECTS.md` and the graph layer fold object names case-insensitively
+and are warehouse-blind, so `ANALYTICS.CUSTOMERS` on one target and `analytics.customers` on another
+collapse into one node. Usually that's the useful reading (a genuine cross-system relationship), but
+it is not a per-target index.
+
+**Dev target.** The dev environment is `seams.warehouse[.targets.<name>].dev_target`. When that key
+is absent it falls back to the key named by the warehouse adapter's `dev_key:` frontmatter (`dev_db`
+for Snowflake, `dev_dataset` for BigQuery, `dev_catalog` for Databricks, `dev_schema` for
+Postgres/Redshift/Synapse) — so configs written before `dev_target` existed keep working untouched.
+
 ## `policies` (the 9 kit policies — see kit README "AI-layer" section)
 
 | Policy | Default | Enforced by |
@@ -71,7 +119,9 @@ and `refresh context` degrade gracefully (skip warehouse steps) when it is.
 
 ## Worked example
 
-A worked example lives at [`stack.yaml`](stack.yaml) (Jira/Snowflake/Slack/Drive/GitHub). Two more
+A worked example lives at [`stack.yaml`](stack.yaml) (Jira/Snowflake/Slack/Drive/GitHub). Three more
 prove the abstraction holds with zero skill edits: `stack.example.asana-bq.yaml`
-(Asana/BigQuery/Teams/SharePoint/GitLab) and `stack.example.azure.yaml`
-(Azure DevOps/Synapse/Teams/SharePoint/Azure Repos). To validate any config: `bash bin/verify_stack.sh`.
+(Asana/BigQuery/Teams/SharePoint/GitLab), `stack.example.azure.yaml`
+(Azure DevOps/Synapse/Teams/SharePoint/Azure Repos), and `stack.example.multi-warehouse.yaml`
+(Jira/**Snowflake + Databricks**/Slack/Drive/GitHub — the named-targets shape above). To validate any
+config: `bash bin/verify_stack.sh`.

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/config/stack.yaml

@@ -18,6 +18,7 @@ project:
   ticket_url_template: "https://acme.atlassian.net/browse/{id}"  # how INDEX.md links a ticket ({id} token); omit/null = no link
   word_limits: {tracker_comment: 100, chat: 100, pr: 200, ticket: 200}
   graph_notes: true                     # Obsidian graph layer (tickets/graph + tickets/objects); false to disable
+  graph_config: true                    # also write .obsidian/graph.json (tickets↔objects filter + colors); create/merge-only, never clobbers manual tweaks
 
 seams:
   tracker:

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/hooks/db_write_guard.py

@@ -51,15 +51,95 @@ def find_stack_yaml(cwd: str) -> Path | None:
     return None
 
 
+_COMMENT = re.compile(r"^\s*#")
+# `note: |`, `- note: |-`, `"note": >2`, … — a key whose value is a literal/folded block scalar.
+_BLOCK_SCALAR = re.compile(
+    r"""^\s*(?:-\s+)?(?:"[^"]*"|'[^']*'|[A-Za-z0-9_.-]+):\s*[|>][-+0-9]*\s*(?:#.*)?$"""
+)
+
+
+def seam_block(text: str, seam: str) -> str:
+    """The lines under `<seam>:` inside the top-level `seams:` mapping.
+
+    Three properties matter, all of them about never *narrowing* what gets gated:
+
+    * The seam-key indent is **inferred** from the file, not assumed to be two spaces — a
+      four-space-indented stack.yaml is valid YAML that `yq` reads fine.
+    * Comment-only lines carry no indentation and never terminate the scan, so a comment
+      between `seams:` and the first seam can't hide it.
+    * A config with no `seams:` anchor (malformed or partial) is scanned whole rather than
+      skipped. Gating too much only costs a confirmation prompt; gating too little is a
+      destructive statement running unreviewed.
+
+    Block-scalar bodies are skipped so prose can't be read as configuration. No yaml dep — this
+    hook has to stay a standalone stdlib script.
+    """
+    # A mapping key may carry a YAML anchor/alias/tag before its nested block (`warehouse: &wh`),
+    # which yq resolves fine — so the key patterns tolerate one.
+    prop = r"(?:[&*!][^\s#]*\s*)?"
+    lines = text.splitlines()
+    start = next((i for i, ln in enumerate(lines)
+                  if re.match(rf"^seams:\s*{prop}(?:#.*)?$", ln)), None)
+    if start is None:
+        body, min_indent = lines, 0          # no anchor: a bare `warehouse:` may sit at column 0
+    else:
+        body, min_indent = lines[start + 1:], 1
+
+    indent = depth = skip_deeper_than = None
+    out = []
+    for ln in body:
+        if not ln.strip() or _COMMENT.match(ln):
+            if depth is not None and ln.strip() == "":
+                out.append(ln)
+            continue                              # comments define neither indent nor an end
+        cur = len(ln) - len(ln.lstrip())
+        if cur < min_indent:
+            break                                 # dedented out of `seams:`
+        if skip_deeper_than is not None:
+            if cur > skip_deeper_than:
+                continue                          # still inside a block scalar
+            skip_deeper_than = None
+        if depth is None:
+            if indent is None:
+                indent = cur                      # the first real child sets the seam-key column
+            if cur == indent:
+                km = re.match(rf"^\s*{re.escape(seam)}:\s*(.*)$", ln)
+                if km:
+                    rest = re.sub(r"^[&*!][^\s#]*\s*", "", km.group(1).strip())
+                    rest = re.sub(r"\s*#.*$", "", rest).strip()
+                    if rest.startswith("{"):
+                        return rest               # inline flow mapping — the seam is all on this line
+                    if rest == "":
+                        depth = cur               # normal nested block
+                    # any other inline scalar (`warehouse: null`) opens nothing
+            continue
+        if cur <= depth:
+            break                                 # next seam at the same level
+        if _BLOCK_SCALAR.match(ln):
+            skip_deeper_than = cur
+            continue
+        out.append(ln)
+    return "\n".join(out)
+
+
 def warehouse_clis(stack: Path | None) -> list[str]:
+    """Defaults + every `cli:` declared inside the warehouse seam.
+
+    Scoped to the seam block for two reasons. A multi-target seam declares one `cli:` per target,
+    so all of them must be gated. And the previous `DOTALL` scan was unanchored: on a warehouse
+    seam with no `cli:` of its own (only Snowflake requires one) that was listed *before* the
+    tracker, it captured the tracker's CLI — making `<tracker-cli> ... create ...` trip the
+    destructive-statement check and prompt for approval on a plain ticket edit.
+    """
     clis = list(DEFAULT_WAREHOUSE_CLIS)
     if stack:
         try:
-            text = stack.read_text(errors="replace")
-            # tiny scan: a `cli: <name>` line under the warehouse seam (no yaml dep)
-            m = re.search(r"warehouse:.*?(?:\n\s+cli:\s*([A-Za-z0-9_-]+))", text, re.DOTALL)
-            if m and m.group(1) not in clis:
-                clis.insert(0, m.group(1))
+            blk = seam_block(stack.read_text(errors="replace"), "warehouse")
+            # Unanchored within the block (which is already scoped to the seam) so a flow mapping
+            # — `prod: {tool: trino, cli: trino}` — is read too, not just one-key-per-line style.
+            for c in re.findall(r"(?:^|[\s{,])cli:\s*([A-Za-z0-9_.-]+)", blk, re.MULTILINE):
+                if c not in clis:
+                    clis.insert(0, c)
         except OSError:
             pass
     return clis

ticketwright-3.3.0/.claude/hooks/session_context.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""SessionStart hook — prime every session with the configured stack + AI-layer index.
+
+Prints a compact summary (becomes session additionalContext) so the agent always knows
+which tools are wired, which skills/commands exist, and the lifecycle — without anyone
+having to load all of AGENTS.md. This is the always-on, *tiny* slice of context; the
+`/prime-*` commands load the rest on demand.
+
+Wire it in settings.json:
+  "hooks": { "SessionStart": [ { "hooks": [
+    { "type": "command", "command": "python3 .claude/hooks/session_context.py" } ] } ] }
+
+Stdlib only. Fails open (prints nothing) if the kit isn't configured yet.
+"""
+from __future__ import annotations
+
+import os
+import re
+import sys
+from pathlib import Path
+
+
+def project_root() -> Path:
+    if os.environ.get("CLAUDE_PROJECT_DIR"):
+        return Path(os.environ["CLAUDE_PROJECT_DIR"])
+    # hook lives at <root>/.claude/hooks/
+    return Path(__file__).resolve().parent.parent.parent
+
+
+_COMMENT = re.compile(r"^\s*#")
+_BLOCK_SCALAR = re.compile(
+    r"""^\s*(?:-\s+)?(?:"[^"]*"|'[^']*'|[A-Za-z0-9_.-]+):\s*[|>][-+0-9]*\s*(?:#.*)?$"""
+)
+_PROP = r"(?:[&*!][^\s#]*\s*)?"      # an optional YAML anchor/alias/tag after a mapping key
+
+
+def seam_block(text: str, seam: str) -> str:
+    """The lines under `<seam>:` inside the top-level `seams:` mapping.
+
+    The seam-key indent is inferred from the file rather than assumed, comment-only lines carry no
+    indentation, a key may hold a YAML anchor, and block-scalar bodies are skipped. Deliberately
+    duplicated from db_write_guard.py — hooks are copied individually on a vendored install, so each
+    has to stand alone as a stdlib-only script.
+    """
+    lines = text.splitlines()
+    start = next((i for i, ln in enumerate(lines)
+                  if re.match(rf"^seams:\s*{_PROP}(?:#.*)?$", ln)), None)
+    if start is None:
+        return ""
+
+    indent = depth = skip_deeper_than = None
+    out = []
+    for ln in lines[start + 1:]:
+        if not ln.strip() or _COMMENT.match(ln):
+            continue
+        cur = len(ln) - len(ln.lstrip())
+        if cur == 0:
+            break
+        if skip_deeper_than is not None:
+            if cur > skip_deeper_than:
+                continue
+            skip_deeper_than = None
+        if depth is None:
+            if indent is None:
+                indent = cur
+            if cur == indent:
+                km = re.match(rf"^\s*{re.escape(seam)}:\s*(.*)$", ln)
+                if km:
+                    rest = re.sub(r"^[&*!][^\s#]*\s*", "", km.group(1).strip())
+                    rest = re.sub(r"\s*#.*$", "", rest).strip()
+                    if rest.startswith("{"):
+                        return rest        # inline flow mapping — the seam is all on this line
+                    if rest == "":
+                        depth = cur
+            continue
+        if cur <= depth:
+            break
+        if _BLOCK_SCALAR.match(ln):
+            skip_deeper_than = cur
+            continue
+        out.append(ln)
+    return "\n".join(out)
+
+
+def seam_tools(text: str, seam: str) -> list[str]:
+    """Every `tool:` declared in a seam — one for a single mapping, one per target otherwise.
+
+    A multi-target seam returns the default's tool FIRST, so the banner never implies the wrong
+    warehouse is the active one.
+    """
+    blk = seam_block(text, seam)
+    if not blk:
+        return []
+
+    # A wholly inline seam (`warehouse: {default: prod, targets: {…}}`) has no lines to walk, so
+    # read it positionally: tools in document order, default's tool hoisted to the front.
+    if blk.lstrip().startswith("{"):
+        tools = re.findall(r"\btool:\s*([A-Za-z0-9_.-]+)", blk)
+        dm = re.search(r"\bdefault:\s*([A-Za-z0-9_.-]+)", blk)
+        if dm:
+            # `<name>: {… tool: X …}` — find the tool belonging to the default target.
+            tm = re.search(rf"\b{re.escape(dm.group(1))}:\s*\{{[^}}]*\btool:\s*([A-Za-z0-9_.-]+)", blk)
+            if tm and tm.group(1) in tools:
+                tools = [tm.group(1)] + [t for t in tools if t != tm.group(1)]
+        return tools
+
+    pairs, cur_target, target_indent = [], None, None
+    for ln in blk.splitlines():
+        m = re.match(r"^(\s*)([A-Za-z0-9_.-]+):\s*(.*)$", ln)
+        if not m:
+            continue
+        ind, key = len(m.group(1)), m.group(2)
+        val = re.sub(r"\s*#.*$", "", m.group(3)).strip()
+        if key == "tool" and val:
+            pairs.append((cur_target, val))
+            continue
+        if key == "targets":
+            continue
+        if val == "" or val.startswith("{"):
+            # the header of one target — bare `name:`, or `name: {…}` in flow style
+            if target_indent is None or ind <= target_indent:
+                target_indent, cur_target = ind, key
+            tm = re.search(r"\btool:\s*([A-Za-z0-9_.-]+)", val)
+            if tm:
+                pairs.append((key, tm.group(1)))   # flow style: its tool is on this same line
+    dm = re.search(r"^\s+default:\s*([A-Za-z0-9_.-]+)", blk, re.MULTILINE)
+    if dm:
+        d = dm.group(1)
+        pairs.sort(key=lambda p: 0 if p[0] == d else 1)   # stable: others keep file order
+    return [t for _, t in pairs]
+
+
+def scan_stack(stack: Path) -> dict:
+    text = stack.read_text(errors="replace")
+    out = {}
+    m = re.search(r"^\s*key_prefix:\s*([A-Za-z0-9_-]+)", text, re.MULTILINE)
+    out["key_prefix"] = m.group(1) if m else "?"
+    for seam in ("tracker", "warehouse", "chat", "docstore", "vcs"):
+        tools = seam_tools(text, seam)
+        # A multi-target seam renders as "a+b" (default first) so no target is hidden.
+        out[seam] = "+".join(tools) if tools else "—"
+    return out
+
+
+def main() -> int:
+    root = project_root()
+    stack = root / ".claude/config/stack.yaml"
+    if not stack.is_file():
+        return 0  # not configured — say nothing
+
+    try:
+        s = scan_stack(stack)
+    except OSError:
+        return 0
+
+    skills = sorted(p.parent.name for p in (root / ".claude/skills").glob("*/SKILL.md")) \
+        if (root / ".claude/skills").is_dir() else []
+    commands = sorted(
+        p.stem for p in (root / ".claude/commands").glob("*.md")
+    ) if (root / ".claude/commands").is_dir() else []
+
+    lines = [
+        "## Ticketwright — session context",
+        f"Stack ({s['key_prefix']}-tickets): tracker={s['tracker']} · warehouse={s['warehouse']} · "
+        f"chat={s['chat']} · docstore={s['docstore']} · vcs={s['vcs']}.",
+        "Lifecycle: /ticket (opens + auto-primes context) → /spec-and-build → /review → /ship.",
+    ]
+    if skills:
+        lines.append("Skills: " + ", ".join(skills) + ".")
+    if commands:
+        lines.append("Commands: " + ", ".join(commands) + ".")
+    lines.append("Policies enforced: DB writes & external posts require approval (db_write_guard hook + "
+                 "skill hard-halts); chat defaults to draft; outputs deterministic. See AGENTS.md.")
+    print("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/hooks/ticket_index_context.py

@@ -95,6 +95,8 @@ def main() -> int:
         lines.append(f"- {t.get('owner')}/{t.get('id')} ({d}) — {title}")
     if total > len(tickets):
         lines.append(f"({total - len(tickets)} newer ticket(s) on disk not yet enriched — run the index workflow.)")
+    elif len(tickets) > total:
+        lines.append(f"({len(tickets) - total} record(s) have no folder on disk — run /refresh index --prune.)")
     print("\n".join(lines))
     return 0
 

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/settings.json.tmpl

@@ -1,5 +1,5 @@
 {
-  "_README": "Rendered to .claude/settings.json by /setup. The hooks block below is for a VENDORED (cp -r) install, where nothing else wires the kit's hooks. On a PLUGIN install (CLAUDE_PLUGIN_ROOT set), .claude-plugin/plugin.json already wires these same hooks from the plugin dir, so /setup OMITS this hooks block to avoid double-firing (double db-write prompts, double index regen) AND ADDS an 'extraKnownMarketplaces' (ticketwright github source, autoUpdate:true) + 'enabledPlugins' (ticketwright@ticketwright:true) block so the REPO opts every user into the plugin at PROJECT scope (a plugin cannot set its own install scope — the repo does; teammates are prompted to install), committed with the repo, and self-updates on formal releases only (version-string change; never un-released main commits). Do NOT add those two keys on a vendored install — there is no marketplace to enable from. permissions + statusLine are written in both modes (setup appends stack-specific CLI allows); on a plugin install setup copies statusline.sh into .claude/ so the relative command resolves. The db_write_guard hook turns 'db_write_requires_approval' into a mechanical ask before any destructive warehouse statement.",
+  "_README": "Rendered to .claude/settings.json by /setup. The hooks block below is for a VENDORED (cp -r) install, where nothing else wires the kit's hooks. On a PLUGIN install (CLAUDE_PLUGIN_ROOT set), .claude-plugin/plugin.json already wires these same hooks from the plugin dir, so /setup OMITS this hooks block to avoid double-firing (double db-write prompts, double index regen) AND ADDS an 'extraKnownMarketplaces' (ticketwright https url source, autoUpdate:true) + 'enabledPlugins' (ticketwright@ticketwright:true) block so the REPO opts every user into the plugin at PROJECT scope (a plugin cannot set its own install scope — the repo does; teammates are prompted to install), committed with the repo, and self-updates on formal releases only (version-string change; never un-released main commits). Do NOT add those two keys on a vendored install — there is no marketplace to enable from. permissions + statusLine are written in both modes (setup appends stack-specific CLI allows); on a plugin install setup copies statusline.sh into .claude/ so the relative command resolves. The db_write_guard hook turns 'db_write_requires_approval' into a mechanical ask before any destructive warehouse statement.",
   "hooks": {
     "PreToolUse": [
       {

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/refresh/index.md

@@ -22,8 +22,16 @@ Two layers, kept separate so the catalog is reproducible and CI/pre-commit-safe:
    marked `▱`).
 
 ## Phase 2 — Enrich (the model half)
-4. Decide scope: the given ticket id(s); `--all` for the whole backlog; or default to the
-   un-enriched/stale set from `--stats`.
+4. Decide scope (enrichment is the model (re)writing curated summaries — **never rewrite curated
+   summaries silently**):
+   - a **specific ticket id (or ids)** — enrich just those;
+   - **default** (no flag): only the **un-enriched + stale** set from `--stats` — the safe day-to-day
+     scope;
+   - **`--all`**: cover every ticket **but skip those already enriched and fresh** — the bootstrap
+     scope for a new or newly-adopted backlog (render everything, then enrich only what's missing or
+     changed);
+   - **`--force`** (a.k.a. `--reenrich-all`): genuinely re-enrich **everything**, rewriting even
+     hand-curated, non-stale summaries. Rare, and destructive to curation — only on an explicit ask.
 5. For each target ticket, read its `README.md` and write ONE record:
    `{id, owner, title, status, date, summary (<=180 chars, lead with what was delivered + key
    numbers), tags (1-4 kebab-case), cross_refs (other ticket ids), objects (qualified data objects

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/setup/SKILL.md

@@ -53,11 +53,17 @@ include the key commented with a `# TODO` and keep going — `verify` will point
    `private/` subfolder), the AI-layer index, and the seeded ticket index.
 
 ### Phase 4 — Verify & hand off
-6. Run `!bash "${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR}/bin/selftest.sh"` (kit integrity — a failure here is fatal) and
-   `!bash "${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR}/bin/verify_stack.sh"` (per-seam reachability — an unreachable seam is
-   **not** fatal at setup time; print its adapter's auth notes as the fix).
-7. **Report:** the chosen stack, files written, any `# TODO` keys or stub adapters, and the next
-   step — `/ticket <id>` to start work, or `/setup --teammate` for a new person.
+6. **Two distinct checks — keep them labeled as such in the report:**
+   - `!bash "${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR}/bin/selftest.sh"` — **kit integrity**. It
+     validates the plugin's *own bundled example* stacks, **not** your repo's config. A failure here
+     is fatal.
+   - `!bash "${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR}/bin/verify_stack.sh" .claude/config/stack.yaml`
+     — **your repo's stack** reachability (pass the repo stack path explicitly so it's unambiguous
+     which config was checked). An unreachable seam is **not** fatal at setup time; print its
+     adapter's auth notes as the fix.
+7. **Report:** name which check is which (selftest = kit integrity; verify_stack = *your* seams), then
+   the chosen stack, files written, any `# TODO` keys or stub adapters, and the next step —
+   `/ticket <id>` to start work, or `/setup --teammate` for a new person.
 8. **Offer to commit the scaffold.** What setup just wrote (`.claude/config/stack.yaml`, `AGENTS.md`,
    `CLAUDE.md`, `.claude/settings.json`, `.gitignore`, `documentation/AI_LAYER_INDEX.md`, the seeded `tickets/`
    index — plus, on a vendored install, the kit itself) is untracked; if it isn't committed, a later

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/setup/adopt.md

@@ -39,5 +39,7 @@ Include: what was auto-configured, what needs a human decision, and the suggeste
 real ticket through `/ticket → /review → /ship` before deleting anything custom.
 
 ## 5 · Verify & report
-Same as Phase 4 of the default mode (selftest + verify_stack). The report leads with the
-MIGRATION.md path and the trial-ticket suggestion — adoption is incremental by design.
+Same as Phase 4 of the default mode: `selftest.sh` (**kit integrity** — the plugin's own example
+stacks) then `verify_stack.sh .claude/config/stack.yaml` (**your repo's** seams). Label the two in
+the report so the kit's example stack is never mistaken for the repo's config. The report leads with
+the MIGRATION.md path and the trial-ticket suggestion — adoption is incremental by design.

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/setup/scaffold.md

@@ -33,7 +33,7 @@ itself:
 {
   "extraKnownMarketplaces": {
     "ticketwright": {
-      "source": { "source": "github", "repo": "kyle-chalmers/ticketwright" },
+      "source": { "source": "url", "url": "https://github.com/kyle-chalmers/ticketwright.git" },
       "autoUpdate": true
     }
   },
@@ -43,6 +43,10 @@ itself:
 }
 ```
 
+The source is an explicit `https://…git` URL, not the `owner/repo` shorthand — the shorthand can
+resolve to SSH and fail for users without GitHub SSH keys, whereas the URL clones over HTTPS via the
+git credential helper. A fork edits just this URL.
+
 `autoUpdate` re-installs **only when the plugin's version string changes** — i.e. only on a formal
 release (the release commit bumps `plugin.json`/`marketplace.json`/`__init__.py` in lockstep and tags
 `v*`). Between releases, ordinary commits to the default branch leave the version untouched, so
@@ -77,4 +81,7 @@ SessionStart surfacing, curated summaries at ship time). An existing backlog get
 `/refresh index --all`.
 
 That renderer also writes the Obsidian graph layer (`tickets/graph/` + `tickets/objects/`) when
-`project.graph_notes` is on (the default), committed alongside `INDEX.md`/`OBJECTS.md`.
+`project.graph_notes` is on (the default), committed alongside `INDEX.md`/`OBJECTS.md`. It then seeds
+`.obsidian/graph.json` (unless `project.graph_config: false`) with the tickets↔objects filter + color
+groups so the Graph view opens ready-to-read — create/merge-only, so it never clobbers a user's manual
+graph tweaks.

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/ship/SKILL.md

@@ -40,14 +40,20 @@ authorization, execute in order:
 7. **chat.draft** to `seams.chat.default_channel` (policy `chat_default_draft` — the human clicks
    send unless they said "send it", in which case `chat.send`). Smart links for ticket id(s),
    files, PR.
-8. **vcs.commit** — stage this ticket's paths (deliverable files included: they're committed by
-   default so results live with the ticket and show in the PR) **plus `tickets/INDEX.md` +
-   `tickets/OBJECTS.md` + `tickets/index_data.json`** (all three, or `--check` flags drift in CI;
-   semantic message + Co-Authored-By). **Before staging, list the `final_deliverables/` files that
-   will be committed and confirm none carry PII/customer data that shouldn't be in git** — if any do,
-   have the user rename them `*.private.csv` (etc.) or move them under a `private/` subfolder (both
-   gitignored) first. Then **vcs.open_pr** (semantic title; body = Business Impact / Deliverables /
-   Technical Notes / QC).
+8. **vcs.commit** — **first, isolate repo-setup / AI-layer files.** If any are dirty
+   (`.claude/settings.json`, `.claude/config/stack.yaml`, `.claude/statusline.sh`, `AGENTS.md`/
+   `CLAUDE.md`, `documentation/AI_LAYER_INDEX.md`, `.gitignore`) they belong to the repo's plugin
+   setup, not this ticket — give them a separate `chore(plugins): …` commit on this ticket's branch
+   (a distinct commit that rides the ticket's one PR — not a second PR, never folded into the ticket
+   commit); `.claude/settings.local.json` +
+   `.claude/worktrees/` are gitignored, leave them. Then stage this ticket's paths (deliverable files
+   included: they're committed by default so results live with the ticket and show in the PR) **plus
+   `tickets/INDEX.md` + `tickets/OBJECTS.md` + `tickets/index_data.json`** (all three, or `--check`
+   flags drift in CI; semantic message + Co-Authored-By). **Before staging, list the
+   `final_deliverables/` files that will be committed and confirm none carry PII/customer data that
+   shouldn't be in git** — if any do, have the user rename them `*.private.csv` (etc.) or move them
+   under a `private/` subfolder (both gitignored) first. Then **vcs.open_pr** (semantic title; body =
+   Business Impact / Deliverables / Technical Notes / QC).
 9. **transition** the ticket toward `project.terminal_status` if appropriate.
 
 ## Phase C — System-evolution retro (always, even on success)

{ticketwright-3.2.0 → ticketwright-3.3.0}/.claude/skills/spec-and-build/SKILL.md

@@ -30,8 +30,8 @@ context-engineering core idea: AI fails from missing context, not weak models.
 3. **Write the spec** from `${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR}/templates/spec.md.tmpl` into the ticket's folder
    (`specs/<id>-<slug>.md` or `final_deliverables/`): operation type (new/alter), data grain,
    sources + join/cast rules, transformation logic, **validation gates** (the exact QC the build must
-   pass), downstream impact, dev-env target (`seams.warehouse.dev_db`), and a **confidence score
-   (1–10)**.
+   pass), downstream impact, the **dev target** (`seams.warehouse.dev_target`, else the key the
+   warehouse adapter names in its `dev_key:` frontmatter), and a **confidence score (1–10)**.
 4. **Reduce assumptions:** before finalizing, list open questions and **ask the user** (don't guess).
 5. **Commit the spec** via vcs `commit` (`docs: <id> spec for <thing>`) — policy
    `commit_plan_before_implement` enables blame-free retry if the build later reveals a gap.
@@ -41,7 +41,7 @@ context-engineering core idea: AI fails from missing context, not weak models.
 6. **Load** the committed spec (path arg or newest in the ticket's `specs/`). Treat it as the source
    of truth, but **validate each step independently** — don't blindly follow; the spec can be wrong.
 7. **Implement in small build-and-check sub-loops:** one object/step at a time. Develop against
-   `seams.warehouse.dev_db` first; parameterize values at the top **via a CTE params row
+   the warehouse's **dev target** first; parameterize values at the top **via a CTE params row
    (`WITH params AS (SELECT … AS anchor) … CROSS JOIN params`), not a session `DECLARE`/`SET`** —
    CTE params stay portable and keep CSV exports clean; explicit `ORDER BY` on any export
    (deterministic outputs).