@raquezha/norpiv 0.0.7 → 0.0.8

package/README.md

@@ -12,6 +12,7 @@ The RPIV engine splits task execution into separate, focused phases:
 
 | Phase | Command | Purpose | Input / Output Files |
 | :--- | :--- | :--- | :--- |
+| **0. Refine (optional)** | `/refine [source]:[id]` | Repair tracker readiness before RPIV when outcome, acceptance criteria, ownership, dependencies, or decomposition are still unclear. | Proposes tracker edits/child work with ownership/dependency recommendations; no `.workflow/` state |
 | **1. Ingest** | `/triage [source]:[id]` | Initial task verification and workspace setup. | Creates `.workflow/tasks/[source-id]/WORK.md` & `metadata.json` |
 | **2. Scoping** | `/frame` | Author a clear, structured task brief. | Populates `WORK.md` ➔ `[BRIEF]` section |
 | **3. Interrogate**| `/grill-with-docs` | Stress-test brief against rules and docs. | Records decisions in `WORK.md` ➔ `[GRILL]` |
@@ -46,6 +47,10 @@ Rules:
 - **Measure Twice, Cut Once**: Never implement code during scoping or planning. The agent will wait for an explicit `EXECUTE` statement before modifying files.
 - **One Source of Truth**: All task state belongs in `.workflow/tasks/[source-id]/WORK.md`. Avoid creating separate `PROBLEM.md` or `PLAN.md` files.
 - **Safe Branching**: Triage and planning happen on the main branch. Create the feature branch (`feat/*` or `fix/*`) only when starting `/implement`.
+- **Real In-Progress Starts at Implement**: `/refine`, `/triage`, `/frame`, and `/plan` are preparation, not execution. Move the remote Jira/GitHub/GitLab work item to an in-progress state only when `/implement` actually begins.
+- **Refine Preserves Intent**: `/refine` should preserve product-authored text, append acceptance criteria instead of rewriting it, and only assign or link child work when ownership/dependency signals are clear.
+- **Canonical Pointer**: `.workflow/active.json` is the active RPIV pointer. Legacy `active_task.json` is compatibility-only during migration.
+- **Normalized Intake**: `/triage` writes a small local projection into `WORK.md`; tracker snapshots live in `metadata.json`, not raw CLI dumps.
 
 ## 📦 Install as a skill bundle
 
@@ -55,7 +60,7 @@ Best for trying or handing off RPIV skills without installing the full `nothing`
 
 ```bash
 npx -y skills add raquezha/nothing --full-depth -g -a pi \
-  -s triage frame grill-with-docs plan implement verify sync post-merge-prune update-docs distill \
+  -s refine triage frame grill-with-docs plan implement verify sync post-merge-prune update-docs distill \
   -y
 ```
 
@@ -88,7 +93,7 @@ Targets:
 
 | Hat | Purpose |
 | :--- | :--- |
-| `pi --rpiv` | Full RPIV workflow. Loads triage, frame, grill-with-docs, plan, implement, verify, sync, post-merge-prune, and update-docs. |
+| `pi --rpiv` | Full RPIV workflow. Loads refine, triage, frame, grill-with-docs, plan, implement, verify, sync, post-merge-prune, and update-docs. |
 | `pi --notes` | Conversation distiller. Saves useful thinking to Obsidian without RPIV ceremony. |
 
 ## 📝 Pre-RPIV note capture
@@ -127,34 +132,39 @@ Research is a separate local workflow bundle in `packages/workflows/noresearch`
 
    If installed via `npx skills add` or `norpiv-install`, invoke the skills directly in your agent instead.
 
-2. **Triage an Issue**:
+2. **Optional Tracker Refinement**:
+   ```text
+   /refine github:45
+   ```
+
+3. **Triage an Issue**:
    ```text
    /triage github:45
    ```
 
-3. **Frame the Work**:
+4. **Frame the Work**:
    ```text
    /frame
    ```
 
-4. **Verify Constraints**:
+5. **Verify Constraints**:
    ```text
    /grill-with-docs
    ```
 
-5. **Write the Plan Slices**:
+6. **Write the Plan Slices**:
    ```text
    /plan
    ```
 
-6. **Authorize Execution**:
+7. **Authorize Execution**:
    Provide the agent explicit permission to implement:
    ```text
    EXECUTE
    /implement
    ```
 
-7. **Verify & Close**:
+8. **Verify & Close**:
    ```text
    /verify
    /sync
@@ -167,39 +177,24 @@ The bundle includes helper scripts used by the workflow skills:
 
 - `scripts/triage_helper.sh`
 - `scripts/validate_active_task.sh`
-- `scripts/reposcry-bootstrap.sh`
-- `scripts/reposcry-task-context.sh`
-- `scripts/reposcry-refresh.sh`
+- `scripts/graphify-grill.sh`
+- `scripts/graphify-grill.py`
 
 When skills are loaded directly from this package, relative references like `../scripts/...` resolve against the package root. When skills are installed with `norpiv-install`, the same layout is recreated under the target runtime.
 
-## 🔎 Optional RepoScry integration
+## 🔎 Optional Graphify grilling
 
-RepoScry is an optional repo-memory layer for RPIV. norpiv does **not** require it.
+Graphify is an optional grill-only evidence layer for RPIV. norpiv does **not** require it.
 
-If `reposcry` is installed:
+If bootstrap provisions `~/.graphify/venv`, `/grill-with-docs` may run:
 
 ```bash
-./scripts/reposcry-bootstrap.sh
-./scripts/reposcry-task-context.sh "fix dependency graph rebuild"
-# edit code
-./scripts/reposcry-refresh.sh main
-reposcry validate main HEAD
+./scripts/graphify-grill.sh
 ```
 
-Typical usage by phase:
-
-- `/triage`: optionally seed `.reposcry/` with `scripts/reposcry-bootstrap.sh`
-- `/frame`: optionally generate `.reposcry/AI_CONTEXT.md` with `scripts/reposcry-task-context.sh`
-- `/grill-with-docs`: optionally use `reposcry query_graph`, `get_architecture_overview`, and `get_impact_radius`
-- `/implement`: optionally run `scripts/reposcry-refresh.sh` after edit batches
-- `/verify`: optionally add `reposcry validate main HEAD` and affected-flow output as extra evidence
-
-If RepoScry is absent, the helpers no-op and RPIV continues with normal repo reading, grep, and tests.
-
-RepoScry guardrails:
+Guardrails:
 
-- `.reposcry/` is generated local cache and must not be committed.
-- `scripts/reposcry-bootstrap.sh` automatically adds `.reposcry/` to the project `.gitignore` before initializing RepoScry.
-- If `.reposcry/` is already tracked or staged, bootstrap stops and tells you to remove it from the index.
-- `.reposcryignore` is indexing policy, not cache. Review and commit it when you want stable RepoScry behavior across machines.
+- input is a temporary `git archive HEAD` extraction, not the live repository root
+- extraction is structural only by default
+- Graphify warnings never block grilling; normal source reading remains the fallback
+- `INFERRED` or `AMBIGUOUS` edges are leads that still require source verification

package/frame/SKILL.md

@@ -10,15 +10,14 @@ description: Define the task brief inside the active WORK.md. Use after /triage
 Turn raw task context into the stable "what/why" brief.
 
 ## Guardrails
-- READ: `.workflow/active.json` / `.workflow/active_task.json`, active `WORK.md`, and `.reposcry/AI_CONTEXT.md` when present.
-- WRITE: `WORK.md` -> `[BRIEF]` section and append to `[LOG]` only; optional `.reposcry/AI_CONTEXT.md` when RepoScry is installed.
+- READ: `.workflow/active.json` first, then legacy compatibility `.workflow/active_task.json` only if needed, and active `WORK.md`.
+- WRITE: `WORK.md` -> `[BRIEF]` section and append to `[LOG]` only.
 - NEVER: create `PROBLEM.md`, `PRD.md`, or extra planning files.
 - NEVER: overwrite `[PLAN]` or `[GRILL]`.
 - NEVER: ask whether to frame if the user invoked `/frame`; do it.
 
 ## Workflow
 1. Read the active task and remote metadata.
-2. If RepoScry is available, run the bundled `../scripts/reposcry-task-context.sh "<task summary>"` helper to generate `.reposcry/AI_CONTEXT.md`, then use that file as supplemental repo context. The helper path must preserve RepoScry guardrails: `.reposcry/` ignored, cache never tracked, `.reposcryignore` treated as reviewable indexing policy. Continue normally when unavailable.
 3. Determine brief type:
    - **Problem** for bugs, regressions, crashes, broken behavior.
    - **Proposal** for features, enhancements, refactors, new behavior.

package/grill-with-docs/SKILL.md

@@ -10,31 +10,25 @@ description: Stress-test the active WORK.md brief against docs, code, and domain
 Challenge the brief before planning. This replaces passive ubiquitous-language collection with active clarification.
 
 ## Guardrails
-- READ: `.workflow/active.json` / `.workflow/active_task.json`, active `WORK.md` `[BRIEF]`, `CONTEXT.md`, relevant `docs/agents/*`, and `.reposcry/AI_CONTEXT.md` when present.
+- READ: `.workflow/active.json` first, then legacy compatibility `.workflow/active_task.json` only if needed, plus active `WORK.md` `[BRIEF]`, `CONTEXT.md`, and relevant `docs/agents/*`.
 - WRITE: `WORK.md` -> append to `[GRILL]` and `[LOG]` only; durable docs only when a stable rule is confirmed.
 - NEVER: edit `[BRIEF]` silently; propose brief changes if contradictions are found.
 - NEVER: plan or implement during grilling.
 - NEVER: ask questions the codebase can answer; inspect first.
 
 ## Workflow
-1. **Context Loading**: Read the active brief, `CONTEXT.md`, relevant `docs/agents/*`, and `.reposcry/AI_CONTEXT.md` when available.
+1. **Context Loading**: Read the active brief, `CONTEXT.md`, and relevant `docs/agents/*`.
 2. **Investigation & Trace**:
    - Locate the files/lines mentioned in the brief.
    - Trace the data flow related to the problem/proposal.
    - Search for "Impact Surface": Who else uses or depends on these components?
-3. **Optional RepoScry graph pass**: if `reposcry` is available, use it to ground architecture and blast radius. Before relying on it, ensure the bundled bootstrap/context helper has kept `.reposcry/` ignored and untracked. Use commands such as:
-   - `reposcry --repo . get_architecture_overview --format json`
-   - `reposcry --repo . query_graph "callers_of <symbol>"`
-   - `reposcry --repo . query_graph "tests_for <symbol>"`
-   - `reposcry --repo . get_impact_radius <symbol> --depth 4`
-   Proceed normally when RepoScry is absent.
+3. **Optional Graphify pass**: run `../scripts/graphify-grill.sh` once for bounded structural evidence. It reads only a temporary `git archive HEAD` extraction and warns instead of failing when unavailable. Treat `INFERRED` or `AMBIGUOUS` edges as leads: verify them in source before recording conclusions.
 4. **Cross-check**: Compare findings against docs, ADRs, and repo patterns.
-5. **Relentless Interview**:
-   - Ask one question at a time to resolve contradictions or clarify ambiguity.
-   - Challenge the brief if the code behaves differently than described.
-6. **Log Evidence**: Append resolved decisions, technical findings, edge cases, and constraints to `[GRILL]`.
-7. **Log Activity**: Append a timestamped summary of the grilling session to `[LOG]` (Format: `YYYY-MM-DD hh:mm AM/PM`).
-8. **Context Curation**: If a durable term/rule emerges, propose or apply a concise `docs/agents/*` update.
+5. **Challenge**: record confirmed constraints, challenged assumptions, chosen decisions, open blockers / HITL questions, and risks handed to `/plan` or `/implement`.
+6. **Interview**: ask one question at a time only for execution-blocking ambiguity the repository cannot answer.
+7. **Log Evidence**: Append resolved decisions, technical findings, edge cases, and constraints to `[GRILL]`.
+8. **Log Activity**: Append a timestamped summary of the grilling session to `[LOG]` (Format: `YYYY-MM-DD hh:mm AM/PM`).
+9. **Context Curation**: If a durable term/rule emerges, propose or apply a concise `docs/agents/*` update.
 
 ## Output contract
 End with:

package/implement/SKILL.md

@@ -10,34 +10,34 @@ description: Implement the next approved vertical slice from the active WORK.md
 Execute one functional vertical slice and hand it to the human for review.
 
 ## Guardrails
-- READ: `.workflow/active.json` / `.workflow/active_task.json` then active `WORK.md` `[PLAN]`, `[BRIEF]`, and relevant `[LOG]` evidence.
-- WRITE: code changes and `WORK.md` -> append to `[LOG]` only; optional `.reposcry/` cache refresh when RepoScry is installed.
+- READ: `.workflow/active.json` first, then compatibility `.workflow/active_task.json` only if needed, then active `WORK.md` `[PLAN]`, `[BRIEF]`, and relevant `[LOG]` evidence.
+- WRITE: code changes and `WORK.md` -> append to `[LOG]` only.
 - NEVER: edit `[BRIEF]` or `[GRILL]`.
 - NEVER: implement without explicit user instruction.
-- NEVER: commit a Jira-tracked task with a Jira-less subject; if the active task source is `jira`, the commit subject MUST include the Jira key from `.workflow/active_task.json` (e.g. `fix(PROJ-123): ...`).
-- NEVER: hide the Jira key only in the commit body/footer when the task is Jira-tracked; the subject itself must carry the key.
 - NEVER: add `Signed-off-by`; only the human can certify DCO.
 - NEVER: freestyle PR/MR descriptions; use the Draft PR/MR body contract below.
 
 ## Workflow
 1. Identify the first approved unchecked slice in `[PLAN]`.
-2. Move tracked task to **In Progress** only when implementation actually starts.
-3. **Mandatory Branch Check**: You MUST run the branch enforcement script before modifying any code.
+2. **Mandatory Branch Check**: You MUST run the branch enforcement script before modifying any code.
    - Use the absolute path if possible: `<skill_location>/scripts/enforce-branch.sh`.
    - This script prevents accidental implementation on `main`/`master`.
    - If the script switches branches, you must update the `[META]` section of `WORK.md` to reflect the new branch name.
    - If the script fails, STOP and ask the human for help. Do not proceed with code changes.
-4. Optional RepoScry blast-radius pass: if `reposcry` is available, inspect impact before wide edits (`reposcry --repo . get_impact_radius <symbol> --depth 4` or related graph queries). Continue normally when RepoScry is absent.
+3. Select the executable child item, not an umbrella parent; if it is unclear, STOP and ask.
+4. Move that remote item to **In Progress** immediately before code changes.
+   - Jira: transition only when an `In Progress`-style state exists.
+   - GitHub / GitLab: use an existing repository-specific status mapping only; do not invent a label, comment, or MR change. If none exists, leave the item unchanged and record why in `[LOG]`.
+   - If a configured transition fails, STOP and ask the human; do not begin code changes.
+   - Do not mark work in progress during `/refine`, `/triage`, `/frame`, or `/plan`.
 5. Implement test-first where practical; otherwise document why not in `[LOG]`.
-6. After each edit batch, if the bundled `../scripts/reposcry-refresh.sh` helper is present and `reposcry-update` is installed, run it. RepoScry refresh failure should not block implementation. Never stage or commit `.reposcry/`; it is generated cache. `.reposcryignore` may be committed only after review as indexing policy.
-7. Run the slice verification command and available quality gates.
-8. Commit with a Conventional Commit header and `Assisted-by: [AGENT]:[MODEL] [tools]` footer (populating the agent name and model ID from the current session context).
-   - For Jira-tracked tasks, the header MUST include the Jira key in the scope position: `fix(PROJ-123): ...` or `feat(PROJ-123): ...`.
-   - If release-note tooling also needs the key in parsed text, add `Refs: PROJ-123` in the body/footer as well.
-9. Push and open a Draft PR/MR with `gh` or `glab` when a remote exists.
-   - For Jira-tracked tasks, the PR/MR title MUST also include the Jira key and should mirror the commit subject.
-10. Use a temporary body file (`--body-file` or API equivalent) for PR/MR descriptions to avoid shell quoting and markdown escaping bugs.
-11. Append summary, commit hash, and PR/MR link to `[LOG]` (Format: `YYYY-MM-DD hh:mm AM/PM`).
+6. Run the slice verification command and available quality gates.
+7. Commit using the repository's normal conventions and hooks/CI rules.
+   - If the repo or tracker expects a Jira key, preserve it where that repository normally requires it.
+   - If AI attribution trailers are required, obtain them from the repository's documented policy rather than hard-coding RPIV-specific formatting.
+8. Push and open a Draft PR/MR with `gh` or `glab` when a remote exists.
+9. Use a temporary body file (`--body-file` or API equivalent) for PR/MR descriptions to avoid shell quoting and markdown escaping bugs.
+10. Append summary, commit hash, and PR/MR link to `[LOG]` (Format: `YYYY-MM-DD hh:mm AM/PM`).
 
 ## Draft PR/MR body contract
 

package/implement/scripts/enforce-branch.sh

@@ -44,22 +44,32 @@ json_pretty() {
 
 # Find repo root to ensure paths are absolute and reliable
 REPO_ROOT=$(git rev-parse --show-toplevel)
+ACTIVE_WORKFLOW_FILE="$REPO_ROOT/.workflow/active.json"
+# Deprecated compatibility fallback during active.json migration. Remove once all readers stop depending on active_task.json.
 ACTIVE_TASK_FILE="$REPO_ROOT/.workflow/active_task.json"
-
-if [[ ! -f "$ACTIVE_TASK_FILE" ]]; then
-    echo "ERROR: No active task found at $ACTIVE_TASK_FILE."
+POINTER_FILE=""
+POINTER_LABEL=""
+
+if [[ -f "$ACTIVE_WORKFLOW_FILE" ]]; then
+    POINTER_FILE="$ACTIVE_WORKFLOW_FILE"
+    POINTER_LABEL="active.json"
+elif [[ -f "$ACTIVE_TASK_FILE" ]]; then
+    POINTER_FILE="$ACTIVE_TASK_FILE"
+    POINTER_LABEL="active_task.json"
+else
+    echo "ERROR: No active task found at $ACTIVE_WORKFLOW_FILE or $ACTIVE_TASK_FILE."
     echo "Please run /triage [source]:[id] first."
     exit 1
 fi
 
 # Read canonical active task fields
-TASK_SOURCE=$(json_read "$ACTIVE_TASK_FILE" '.source // empty')
-TASK_ID=$(json_read "$ACTIVE_TASK_FILE" '.sourceId // .id // empty')
-TASK_PATH=$(json_read "$ACTIVE_TASK_FILE" '.taskPath // .path // empty')
+TASK_SOURCE=$(json_read "$POINTER_FILE" '.source // empty')
+TASK_ID=$(json_read "$POINTER_FILE" '.sourceId // .id // empty')
+TASK_PATH=$(json_read "$POINTER_FILE" '.taskPath // .path // empty')
 
 # Prefer explicit taskPath when available (most reliable)
 if [[ -n "$TASK_PATH" ]]; then
-    echo "INFO: Using taskPath from active_task.json: $TASK_PATH"
+    echo "INFO: Using taskPath from $POINTER_LABEL: $TASK_PATH"
     if [[ "$TASK_PATH" = /* ]]; then
         WORK_MD="$TASK_PATH/WORK.md"
     else
@@ -77,9 +87,9 @@ elif [[ -n "$TASK_ID" ]]; then
     WORK_MD="$REPO_ROOT/.workflow/tasks/$TASK_FOLDER/WORK.md"
 
 else
-    echo "ERROR: No 'sourceId' or 'taskPath' found in $ACTIVE_TASK_FILE."
-    echo "Please run /triage [source]:[id] to initialize a task. Here are the file contents for debugging:" 
-    json_pretty "$ACTIVE_TASK_FILE" || true
+    echo "ERROR: No 'sourceId' or 'taskPath' found in $POINTER_LABEL."
+    echo "Please run /triage [source]:[id] to initialize a task. Here are the file contents for debugging:"
+    json_pretty "$POINTER_FILE" || true
     exit 1
 fi
 
@@ -88,8 +98,8 @@ echo "DEBUG: Computed WORK.md path: $WORK_MD"
 
 if [[ ! -f "$WORK_MD" ]]; then
     echo "ERROR: WORK.md not found at $WORK_MD."
-    echo "Checked active_task.json values:" 
-    json_pretty "$ACTIVE_TASK_FILE" || true
+    echo "Checked $POINTER_LABEL values:"
+    json_pretty "$POINTER_FILE" || true
     echo "Please ensure the task was initialized with /triage and that WORK.md exists." 
     exit 1
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raquezha/norpiv",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Bundled RPIV workflow skills for Pi, Claude, and Codex-style coding agents",
   "type": "commonjs",
   "bin": {
@@ -12,6 +12,7 @@
     "distill",
     "frame",
     "grill-with-docs",
+    "refine",
     "implement",
     "plan",
     "scripts",
@@ -36,6 +37,7 @@
   },
   "pi": {
     "skills": [
+      "refine",
       "triage",
       "frame",
       "grill-with-docs",

package/refine/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: refine
+workflow: pre-rpiv
+workflowPhase: refine
+description: "Repair tracker work-item readiness before RPIV intake. Use for jira:, github:, or gitlab: items that still need clarified outcome, acceptance criteria, or child work before /triage."
+---
+
+# Skill: refine
+
+Make a tracker item ready for engineering handoff without inventing product decisions.
+
+## Guardrails
+- READ: tracker item, linked/child work, relevant comments, and targeted repo context only when needed for ownership or feasibility.
+- WRITE: proposals in chat first; tracker comments/field edits/child creation only after explicit human approval.
+- NEVER: implement code, create branches, or start RPIV task state.
+- NEVER: invent missing product intent when a human decision is required.
+- NEVER: duplicate existing child work or spam repeated agent comments.
+- NEVER: move work across trackers.
+
+## Workflow
+1. Parse namespaced source: `jira:KEY`, `github:ID`, or `gitlab:ID`.
+2. Read the item, current structure, and recent comments.
+3. Classify readiness gaps: missing outcome, acceptance criteria, ownership, dependencies, blockers, or decomposition.
+4. For every proposed child item, state intended owner, confidence, and fallback `unassigned`. Auto-assign only when the signal is strong from the tracker, comments, or existing team ownership patterns.
+5. Decide dependency handling explicitly for each child pair or blocker:
+   - no dependency
+   - description note only
+   - real tracker link
+   Prefer actual Jira `Blocks` links when child A must precede child B.
+6. Return one outcome:
+   - `ready-single`: one executable owner, no decomposition needed
+   - `ready-decomposed`: split is needed and children, links, and owners are clear
+   - `needs-decision`: missing product decision or not truly ready-decomposed because ownership/dependencies are still muddy
+7. Propose the smallest useful tracker edits and child items before mutating anything.
+8. Before any approved mutation, walk this checklist in order:
+   - preserve product-authored text
+   - append acceptance criteria instead of rewriting existing acceptance criteria
+   - create child?
+   - assign child?
+   - link child?
+   - then mutate parent text/fields
+9. On explicit approval, apply the approved tracker edits only.
+10. Re-run idempotently: reuse existing child items and any prior agent-owned refinement marker/comment.
+11. Recommend `/triage` only once the item is execution-ready.
+
+## Output contract
+End with:
+- **Outcome**: ready-single / ready-decomposed / needs-decision
+- **Missing information**
+- **Proposed tracker edits**
+- **Proposed child work**
+- **Proposed ownership**
+- **Proposed dependency links**
+- **Next step**: approve edits / answer question / `/triage`

package/scripts/graphify-grill.py

@@ -0,0 +1,42 @@
+"""Emit bounded structural Graphify evidence from a disposable archive."""
+import json
+import sys
+from contextlib import redirect_stdout
+from pathlib import Path
+
+EDGE_LIMIT = 100
+
+
+def normalize_edge(edge):
+    return {
+        "confidence": edge.get("confidence", "EXTRACTED"),
+        "source": edge.get("source", edge.get("from", "")),
+        "target": edge.get("target", edge.get("to", "")),
+        "type": edge.get("type", edge.get("relation", "")),
+    }
+
+
+def render_evidence(graph, limit=EDGE_LIMIT):
+    edges = graph.get("edges", [])[:limit]
+    return {
+        "edges": [normalize_edge(edge) for edge in edges],
+        "truncated": len(graph.get("edges", [])) > len(edges),
+    }
+
+
+def main(root_arg):
+    root = Path(root_arg)
+    out = root / "graphify-out"
+    from graphify.extract import collect_files, extract
+
+    with redirect_stdout(sys.stderr):
+        graph = extract(collect_files(root), cache_root=out, root=root, parallel=False)
+    print(json.dumps(render_evidence(graph)))
+
+
+if __name__ == "__main__":
+    try:
+        main(sys.argv[1])
+    except Exception as error:
+        print(f"Graphify extraction failed: {error}", file=sys.stderr)
+        raise

package/scripts/graphify-grill.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Optional structural Graphify pass over committed HEAD only.
+set -u
+
+repo_root=$(git rev-parse --show-toplevel 2>/dev/null) || { echo "WARN: Graphify skipped: not a git repository." >&2; exit 0; }
+python=${GRAPHIFY_PYTHON:-"$HOME/.graphify/venv/bin/python"}
+if [[ ! -x "$python" ]]; then
+  python="$repo_root/.graphify/venv/bin/python"
+fi
+script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+temp=$(mktemp -d "${TMPDIR:-/tmp}/norpiv-graphify.XXXXXX") || { echo "WARN: Graphify skipped: cannot create temporary directory." >&2; exit 0; }
+trap 'rm -rf "$temp"' EXIT
+
+if [[ ! -x "$python" ]]; then
+  echo "WARN: Graphify skipped: machine-wide or repo-local Python is unavailable." >&2
+  exit 0
+fi
+if ! git -C "$repo_root" archive HEAD | tar -x -C "$temp"; then
+  echo "WARN: Graphify skipped: cannot archive HEAD." >&2
+  exit 0
+fi
+if ! "$python" "$script_dir/graphify-grill.py" "$temp"; then
+  echo "WARN: Graphify failed; continue with normal source reading." >&2
+fi

package/scripts/test_graphify_grill.py

@@ -0,0 +1,21 @@
+import importlib.util
+from pathlib import Path
+
+module_path = Path(__file__).with_name("graphify-grill.py")
+spec = importlib.util.spec_from_file_location("graphify_grill", module_path)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+
+edge = module.normalize_edge({"from": "a", "to": "b", "relation": "calls"})
+assert edge == {
+    "confidence": "EXTRACTED",
+    "source": "a",
+    "target": "b",
+    "type": "calls",
+}
+
+rendered = module.render_evidence({"edges": [{"source": str(i)} for i in range(105)]}, limit=100)
+assert len(rendered["edges"]) == 100
+assert rendered["truncated"] is True
+
+print("graphify-grill.py self-check passed")

package/scripts/triage_helper.sh

@@ -120,21 +120,12 @@ PY
 
 write_active_pointer() {
     mkdir -p ".workflow"
-    python3 - ".workflow/active_task.json" ".workflow/active.json" "$TASK_FOLDER" "$SOURCE" "$ID" "$TASK_DIR" "$WORK_MD" "$BRANCH_NAME" "$ISO_NOW" <<'PY'
+    python3 - ".workflow/active.json" "$TASK_FOLDER" "$SOURCE" "$ID" "$TASK_DIR" "$WORK_MD" "$BRANCH_NAME" "$ISO_NOW" <<'PY'
 import json
 import sys
 from pathlib import Path
 
-active_task_path, active_workflow_path, active_task, source, raw_id, task_path, state_file, branch, now = sys.argv[1:]
-legacy_data = {
-    "active_task": active_task,
-    "source": source,
-    "id": raw_id,
-    "sourceId": raw_id,
-    "taskPath": task_path,
-    "path": task_path,
-    "branch": branch,
-}
+active_workflow_path, active_task, source, raw_id, task_path, state_file, branch, now = sys.argv[1:]
 workflow_data = {
     "workflow": "rpiv",
     "id": active_task,
@@ -147,9 +138,7 @@ workflow_data = {
     "branch": branch,
     "startedAt": now,
     "updatedAt": now,
-    "compatPointer": ".workflow/active_task.json",
 }
-Path(active_task_path).write_text(json.dumps(legacy_data, indent=2) + "\n")
 Path(active_workflow_path).write_text(json.dumps(workflow_data, indent=2) + "\n")
 PY
 }
@@ -202,24 +191,43 @@ PY
 }
 
 update_work_meta() {
-    local status phase
+    local status
     status=$(json_get "$METADATA_JSON" status)
-    phase=$(json_get "$METADATA_JSON" phase)
     status=${status:-active}
-    phase=${phase:-triaged}
 
-    python3 - "$WORK_MD" "$BRANCH_NAME" "$status" "$phase" "$SOURCE" "$ID" <<'PY'
+    python3 - "$WORK_MD" "$BRANCH_NAME" "$status" "$SOURCE" "$ID" <<'PY'
 import re
 import sys
 from pathlib import Path
 
 path = Path(sys.argv[1])
-branch, status, phase, source, raw_id = sys.argv[2:]
+branch, status, source, raw_id = sys.argv[2:]
 text = path.read_text() if path.exists() else ""
 lines = text.splitlines()
 header_re = re.compile(r"^(## )?\[[A-Z0-9_-]+\]\s*$")
 meta_re = re.compile(r"^(## )?\[META\]\s*$")
 
+
+def section_body(section):
+    header = re.compile(rf"^(## )?\[{re.escape(section)}\]\s*$")
+    start = next((i for i, line in enumerate(lines) if header.match(line)), None)
+    if start is None:
+        return ""
+    end = len(lines)
+    for i in range(start + 1, len(lines)):
+        if header_re.match(lines[i]):
+            end = i
+            break
+    return "\n".join(lines[start + 1:end]).strip()
+
+
+def meaningful(section):
+    body = section_body(section)
+    return any(line.strip() and line.strip() not in {"-", "- [ ]"} for line in body.splitlines())
+
+
+phase = "planned" if meaningful("PLAN") else "grilled" if meaningful("GRILL") else "framed" if meaningful("BRIEF") else "triaged"
+
 new_block = [
     "## [META]",
     f"- Branch: `{branch}`",
@@ -247,6 +255,100 @@ path.write_text("\n".join(updated).rstrip() + "\n")
 PY
 }
 
+write_work_snapshot() {
+    python3 - "$WORK_MD" "$METADATA_JSON" "$SOURCE" "$ID" <<'PY'
+import json
+import re
+import sys
+from pathlib import Path
+
+work_md, metadata_json, source, raw_id = sys.argv[1:]
+
+try:
+    metadata = json.loads(Path(metadata_json).read_text())
+    if not isinstance(metadata, dict):
+        metadata = {}
+except Exception:
+    metadata = {}
+
+
+def pick(*values, fallback=""):
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return fallback
+
+
+def squash(value):
+    if isinstance(value, dict):
+        value = json.dumps(value, ensure_ascii=False)
+    if not isinstance(value, str):
+        return ""
+    text = re.sub(r"```.*?```", " ", value, flags=re.S)
+    text = re.sub(r"^(## )?\[[A-Z0-9_-]+\]\s*$", " ", text, flags=re.M)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text[:280].rstrip() + ("..." if len(text) > 280 else "")
+
+
+fields = metadata.get("fields") if isinstance(metadata.get("fields"), dict) else {}
+title = {
+    "github": pick(metadata.get("title"), fallback=f"GitHub #{raw_id}"),
+    "gitlab": pick(metadata.get("title"), fallback=f"GitLab #{raw_id}"),
+    "jira": pick(fields.get("summary"), metadata.get("key"), fallback=f"Jira {raw_id}"),
+}.get(source, pick(metadata.get("title"), fallback=f"Local Task {raw_id}"))
+url = {
+    "github": pick(metadata.get("url"), fallback=f"https://github.com/issues/{raw_id}"),
+    "gitlab": pick(metadata.get("web_url"), metadata.get("url")),
+    "jira": pick(metadata.get("self")),
+}.get(source, "")
+summary = {
+    "github": squash(metadata.get("body")),
+    "gitlab": squash(metadata.get("description")),
+    "jira": squash(fields.get("description")),
+}.get(source, squash(metadata.get("body"))) or title
+tracker_updated = {
+    "github": pick(metadata.get("updatedAt"), metadata.get("createdAt")),
+    "gitlab": pick(metadata.get("updated_at"), metadata.get("created_at")),
+    "jira": pick(fields.get("updated"), metadata.get("updated")),
+}.get(source, "")
+
+lines = [
+    f"# WORK: {title}",
+    "",
+    "## [INTAKE]",
+    "### Outcome",
+    summary,
+    "",
+    "### Acceptance Criteria",
+    "- [ ] Confirm concrete acceptance criteria from tracker or refine them during `/frame`.",
+    "",
+    "### Scope / Non-goals",
+    "- Keep local execution state concise; do not copy raw tracker or CLI rendering into `WORK.md`.",
+    "",
+    "### Dependencies / Blockers",
+    "- None noted from intake snapshot.",
+    "",
+    "### Tracker Context",
+    f"- Task: `{source}:{raw_id}`",
+    f"- URL: {url}" if url else "- URL: None noted",
+    f"- Tracker updated: `{tracker_updated}`" if tracker_updated else "- Tracker updated: None noted",
+    "",
+    "## [BRIEF]",
+    "- ",
+    "",
+    "## [GRILL]",
+    "- ",
+    "",
+    "## [PLAN]",
+    "- [ ] ",
+    "",
+    "## [LOG]",
+]
+
+Path(work_md).write_text("\n".join(lines).rstrip() + "\n")
+PY
+}
+
 backfill_metadata() {
     json_upsert "$METADATA_JSON" \
         "id=$ID" \
@@ -254,21 +356,18 @@ backfill_metadata() {
         "branch=$BRANCH_NAME" \
         "taskFolder=$TASK_FOLDER" \
         "?status=active" \
-        "?phase=triaged" \
         "createdAt=$ISO_NOW" \
         "updatedAt=$ISO_NOW"
 }
 
 set_metadata_status_phase() {
     local status="$1"
-    local phase="$2"
     json_upsert "$METADATA_JSON" \
         "id=$ID" \
         "source=$SOURCE" \
         "branch=$BRANCH_NAME" \
         "taskFolder=$TASK_FOLDER" \
         "status=$status" \
-        "phase=$phase" \
         "createdAt=$ISO_NOW" \
         "updatedAt=$ISO_NOW"
 }
@@ -281,24 +380,25 @@ create_task() {
         github)
             command -v gh >/dev/null 2>&1 || { echo "ERROR: gh CLI is required for github tasks."; exit 1; }
             echo "Fetching GitHub Issue #$ID..."
-            gh issue view "$ID" --json title,body,author,labels,comments > "$METADATA_JSON"
-            echo "# WORK: GitHub #$ID" > "$WORK_MD"
-            gh issue view "$ID" >> "$WORK_MD"
+            gh issue view "$ID" --json title,body,author,labels,url,number,createdAt,updatedAt > "$METADATA_JSON"
             ;;
         gitlab)
             command -v glab >/dev/null 2>&1 || { echo "ERROR: glab CLI is required for gitlab tasks."; exit 1; }
             echo "Fetching GitLab Issue #$ID..."
-            glab issue view "$ID" > "$WORK_MD"
-            echo '{}' > "$METADATA_JSON"
+            if ! glab issue view "$ID" --output json > "$METADATA_JSON" 2>/dev/null; then
+                echo '{}' > "$METADATA_JSON"
+                json_upsert "$METADATA_JSON" "title=GitLab Issue $ID"
+            fi
             ;;
         jira)
             echo "Fetching Jira Ticket $ID..."
             if command -v jira >/dev/null 2>&1; then
-                jira issue view "$ID" > "$WORK_MD"
                 jira issue view "$ID" --raw > "$METADATA_JSON"
             elif command -v acli >/dev/null 2>&1; then
-                acli jira workitem view "$ID" > "$WORK_MD"
-                echo '{}' > "$METADATA_JSON"
+                if ! acli jira workitem view "$ID" --json > "$METADATA_JSON" 2>/dev/null; then
+                    echo '{}' > "$METADATA_JSON"
+                    json_upsert "$METADATA_JSON" "title=Jira $ID"
+                fi
             else
                 echo "ERROR: jira or acli CLI is required for jira tasks."
                 exit 1
@@ -306,8 +406,8 @@ create_task() {
             ;;
         local)
             echo "Initializing local task workspace: $ID..."
-            echo "# WORK: Local Task $ID" > "$WORK_MD"
             echo '{}' > "$METADATA_JSON"
+            json_upsert "$METADATA_JSON" "title=Local Task $ID"
             ;;
         *)
             echo "Unknown source: $SOURCE"
@@ -315,11 +415,8 @@ create_task() {
             ;;
     esac
 
-    set_metadata_status_phase "active" "triaged"
-    ensure_section "BRIEF" "- "
-    ensure_section "GRILL" "- "
-    ensure_section "PLAN" "- [ ] "
-    ensure_section "LOG" ""
+    set_metadata_status_phase "active"
+    write_work_snapshot
     update_work_meta
     append_log "Task initialized via /triage"
     write_active_pointer

package/scripts/validate_active_task.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 # validate_active_task.sh
-# Lightweight, print-only validation of .workflow/active_task.json and related files.
+# Lightweight, print-only validation of .workflow/active.json and compatibility .workflow/active_task.json.
 # This script never mutates task state; it only reports inconsistencies and suggested fixes.
 
 set -euo pipefail
@@ -9,6 +9,7 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 TRIAGE_HELPER="$SCRIPT_DIR/triage_helper.sh"
 REPO_ROOT=$(git rev-parse --show-toplevel)
+ACTIVE_JSON="$REPO_ROOT/.workflow/active.json"
 ATF="$REPO_ROOT/.workflow/active_task.json"
 CURRENT_BRANCH=$(git branch --show-current 2>/dev/null || true)
 WORK_MD=""
@@ -152,29 +153,52 @@ print_json_field_report() {
   done
 }
 
-if [[ ! -f "$ATF" ]]; then
-  error "No active_task.json found at $ATF"
+POINTER_LABEL=""
+TASK_PATH=""
+TASK_SOURCE=""
+TASK_ID=""
+ACTIVE_TASK=""
+POINTER_BRANCH=""
+
+if [[ -f "$ACTIVE_JSON" ]]; then
+  if ! python3 -m json.tool "$ACTIVE_JSON" >/dev/null 2>&1; then
+    error "active.json is not valid JSON: $ACTIVE_JSON"
+    exit 1
+  fi
+  POINTER_LABEL="active.json"
+  echo "Active workflow file: $ACTIVE_JSON"
+  json_pretty "$ACTIVE_JSON" || true
+
+  TASK_PATH=$(json_read "$ACTIVE_JSON" '.taskPath // .path')
+  TASK_SOURCE=$(json_read "$ACTIVE_JSON" '.source')
+  TASK_ID=$(json_read "$ACTIVE_JSON" '.sourceId // .id')
+  ACTIVE_TASK=$(json_read "$ACTIVE_JSON" '.taskId // .id')
+  POINTER_BRANCH=$(json_read "$ACTIVE_JSON" '.branch')
+
+  print_json_field_report "active.json" "$ACTIVE_JSON" workflow id taskId source sourceId taskPath path branch stateFile
+elif [[ -f "$ATF" ]]; then
+  if ! python3 -m json.tool "$ATF" >/dev/null 2>&1; then
+    error "active_task.json is not valid JSON: $ATF"
+    exit 1
+  fi
+  POINTER_LABEL="active_task.json"
+  echo "Legacy active task file: $ATF"
+  json_pretty "$ATF" || true
+
+  TASK_PATH=$(json_read "$ATF" '.taskPath // .path')
+  TASK_SOURCE=$(json_read "$ATF" '.source')
+  TASK_ID=$(json_read "$ATF" '.sourceId // .id')
+  ACTIVE_TASK=$(json_read "$ATF" '.active_task')
+  POINTER_BRANCH=$(json_read "$ATF" '.branch')
+
+  print_json_field_report "active_task.json" "$ATF" active_task source id sourceId taskPath path branch
+else
+  error "No active workflow pointer found at $ACTIVE_JSON or $ATF"
   echo "Suggested fixes (dry):"
   echo "  - Run: $TRIAGE_HELPER <source> <id>"
   exit 1
 fi
 
-if ! python3 -m json.tool "$ATF" >/dev/null 2>&1; then
-  error "active_task.json is not valid JSON: $ATF"
-  exit 1
-fi
-
-echo "Active task file: $ATF"
-json_pretty "$ATF" || true
-
-TASK_PATH=$(json_read "$ATF" '.taskPath // .path')
-TASK_SOURCE=$(json_read "$ATF" '.source')
-TASK_ID=$(json_read "$ATF" '.sourceId // .id')
-ACTIVE_TASK=$(json_read "$ATF" '.active_task')
-POINTER_BRANCH=$(json_read "$ATF" '.branch')
-
-print_json_field_report "active_task.json" "$ATF" active_task source id sourceId taskPath path branch
-
 echo
 if [[ -n "$TASK_PATH" ]]; then
   if [[ "$TASK_PATH" = /* ]]; then
@@ -184,7 +208,7 @@ if [[ -n "$TASK_PATH" ]]; then
   fi
   echo "Using taskPath -> checking: $WORK_MD"
 elif [[ -n "$TASK_ID" ]]; then
-  echo "No taskPath in active_task.json; attempting to derive from source+id"
+  echo "No taskPath in $POINTER_LABEL; attempting to derive from source+id"
   if [[ -n "$TASK_SOURCE" ]]; then
     TASK_FOLDER="$TASK_SOURCE-$TASK_ID"
   else
@@ -193,7 +217,7 @@ elif [[ -n "$TASK_ID" ]]; then
   WORK_MD="$REPO_ROOT/.workflow/tasks/$TASK_FOLDER/WORK.md"
   echo "Derived path: $WORK_MD"
 else
-  error "Neither taskPath/path nor sourceId/id present in active_task.json"
+  error "Neither taskPath/path nor sourceId/id present in $POINTER_LABEL"
 fi
 
 if [[ -n "$WORK_MD" && -f "$WORK_MD" ]]; then
@@ -209,7 +233,7 @@ if [[ -n "$ACTIVE_TASK" && -n "$TASK_DIR" ]]; then
   if [[ "$ACTIVE_TASK" == "$ACTUAL_TASK_FOLDER" ]]; then
     ok "active_task matches task folder ($ACTIVE_TASK)"
   else
-    warn "active_task ($ACTIVE_TASK) differs from task folder ($ACTUAL_TASK_FOLDER)"
+    warn "pointer task id ($ACTIVE_TASK) differs from task folder ($ACTUAL_TASK_FOLDER)"
   fi
 fi
 
@@ -225,8 +249,8 @@ META_ID=""
 META_SOURCE=""
 META_TASK_FOLDER=""
 META_STATUS=""
-META_PHASE=""
 META_BRANCH=""
+DERIVED_PHASE=""
 
 if [[ -n "$META" ]]; then
   if [[ -f "$META" ]]; then
@@ -234,20 +258,19 @@ if [[ -n "$META" ]]; then
       echo
       echo "Metadata file: $META"
       json_pretty "$META" || true
-      print_json_field_report "metadata.json" "$META" id source taskFolder status phase branch createdAt updatedAt
+      print_json_field_report "metadata.json" "$META" id source taskFolder status branch createdAt updatedAt
 
       META_ID=$(json_read "$META" '.id')
       META_SOURCE=$(json_read "$META" '.source')
       META_TASK_FOLDER=$(json_read "$META" '.taskFolder')
       META_STATUS=$(json_read "$META" '.status')
-      META_PHASE=$(json_read "$META" '.phase')
       META_BRANCH=$(json_read "$META" '.branch')
 
       if [[ -n "$META_ID" && -n "$TASK_ID" && "$META_ID" != "$TASK_ID" ]]; then
-        warn "metadata.id ($META_ID) differs from active_task id/sourceId ($TASK_ID)"
+        warn "metadata.id ($META_ID) differs from pointer id/sourceId ($TASK_ID)"
       fi
       if [[ -n "$META_SOURCE" && -n "$TASK_SOURCE" && "$META_SOURCE" != "$TASK_SOURCE" ]]; then
-        warn "metadata.source ($META_SOURCE) differs from active_task.source ($TASK_SOURCE)"
+        warn "metadata.source ($META_SOURCE) differs from pointer source ($TASK_SOURCE)"
       fi
       if [[ -n "$META_TASK_FOLDER" && -n "$TASK_DIR" && "$META_TASK_FOLDER" != "$(basename "$TASK_DIR")" ]]; then
         warn "metadata.taskFolder ($META_TASK_FOLDER) differs from task folder ($(basename "$TASK_DIR"))"
@@ -275,16 +298,19 @@ if [[ -n "$WORK_MD" && -f "$WORK_MD" ]]; then
     esac
   done
 
-  if [[ "$META_PHASE" =~ ^(planned|implementing|verifying|synced|closed)$ ]]; then
-    if [[ "$(has_plan_checkbox "$WORK_MD")" == "yes" ]]; then
-      ok "[PLAN] contains checkboxes for phase=$META_PHASE"
-    else
-      warn "phase=$META_PHASE but [PLAN] has no checkboxes"
-    fi
+  if [[ "$(section_body_nonempty "PLAN" "$WORK_MD")" == "yes" ]]; then
+    DERIVED_PHASE="planned"
+  elif [[ "$(section_body_nonempty "GRILL" "$WORK_MD")" == "yes" ]]; then
+    DERIVED_PHASE="grilled"
+  elif [[ "$(section_body_nonempty "BRIEF" "$WORK_MD")" == "yes" ]]; then
+    DERIVED_PHASE="framed"
+  else
+    DERIVED_PHASE="triaged"
   fi
+  ok "derived phase from WORK.md: $DERIVED_PHASE"
 
-  if [[ "$META_PHASE" == "triaged" && "$(section_body_nonempty "BRIEF" "$WORK_MD")" == "yes" ]]; then
-    warn "phase=triaged but [BRIEF] appears populated; consider updating phase metadata"
+  if [[ "$DERIVED_PHASE" == "planned" && "$(has_plan_checkbox "$WORK_MD")" != "yes" ]]; then
+    warn "derived phase=planned but [PLAN] has no checkboxes"
   fi
 fi
 
@@ -296,12 +322,12 @@ echo
 echo "Suggested fixes (dry):"
 if [[ -n "$WORK_MD" && ! -f "$WORK_MD" ]]; then
   echo "  - Re-run triage: $TRIAGE_HELPER <source> <id>"
-  echo "  - Or update .workflow/active_task.json to include a correct taskPath or source+id"
+  echo "  - Or update the active workflow pointer to include a correct taskPath or source+id"
 fi
 if [[ -n "$META" && ! -f "$META" ]]; then
   echo "  - Resume/backfill metadata: $TRIAGE_HELPER ${TASK_SOURCE:-local} ${TASK_ID:-task} resume"
 elif [[ -n "$META" && -f "$META" ]]; then
-  if [[ -z "$META_STATUS" || -z "$META_PHASE" || -z "$(json_read "$META" '.createdAt')" || -z "$(json_read "$META" '.updatedAt')" ]]; then
+  if [[ -z "$META_STATUS" || -z "$(json_read "$META" '.createdAt')" || -z "$(json_read "$META" '.updatedAt')" ]]; then
     echo "  - Backfill missing metadata fields: $TRIAGE_HELPER ${TASK_SOURCE:-local} ${TASK_ID:-task} resume"
   fi
 fi

package/sync/SKILL.md

@@ -10,11 +10,13 @@ description: Synchronizes local RPIV task state (WORK.md) to external trackers (
 Maintains consistency between local `.workflow` state and the remote source of truth using a single Pi-owned living status comment per task.
 
 ## Guardrails
-- **Pre-flight**: Always read `.workflow/active.json` / `.workflow/active_task.json` and the active `WORK.md` before executing.
+- **Pre-flight**: Always read `.workflow/active.json` first, then compatibility `.workflow/active_task.json` only if needed, and the active `WORK.md` before executing.
 - **Privacy**: NEVER sync secrets, environment variables, or private notes not intended for stakeholders.
 - **Integrity**: Do not modify `[BRIEF]` or `[GRILL]` sections.
 - **Idempotency**: If the remote Pi status already reflects the current local state, do not post or update.
 - **Human safety**: NEVER edit human-authored comments. Only update comments/notes containing the Pi sync marker.
+- **Target ownership**: Sync the executable child issue/MR/PR that the work completed, not the umbrella parent, unless the user explicitly asks for parent status. If the active GitHub issue has sub-issues, verify the PR/body/current request points to the right child before posting.
+- **Shell safety**: Never pass markdown bodies inline through shell strings. Write bodies to files and use `--body-file` or JSON `--input` API calls so backticks and `$()` cannot execute.
 
 ## Living status marker
 Every sync body MUST include this marker at the end:
@@ -46,7 +48,12 @@ Do **not** use latest-comment ownership as the primary decision. Latest-comment-
 ## Workflow
 
 ### 1. Discovery & State Loading
-- Identify the platform and ID from `.workflow/active.json` or compatibility `.workflow/active_task.json`.
+- Identify the platform and ID from `.workflow/active.json`, falling back to compatibility `.workflow/active_task.json` only when required.
+- For GitHub, check hierarchy before syncing umbrella issues:
+  ```bash
+  gh issue view <id> --json parent,subIssues --jq '{parent:.parent, subIssues:.subIssues}'
+  ```
+  If the issue has sub-issues and the work maps to one child, switch the sync target to that child or ask once. Do not sync a child deliverable to the parent just because the active task points at the parent.
 - Extract **Slices** from `[PLAN]`, **Status** from `[LOG]`, and **Artifacts** such as PR/MR links, commit hashes, and verification output.
 
 ### 2. Payload Preparation
@@ -81,8 +88,9 @@ gh api repos/:owner/:repo/issues/<id>/comments --paginate \
 
 Update:
 ```bash
+jq -n --rawfile body body.md '{body: $body}' > body.json
 gh api -X PATCH repos/:owner/:repo/issues/comments/<comment_id> \
-  -f body=@body.md
+  --input body.json
 ```
 
 Create:
@@ -94,6 +102,7 @@ Rules:
 - update only a comment containing the marker
 - no-op when normalized body is already current
 - create only when no marker comment exists
+- keep markdown in files; do not use inline `-f body="$(cat body.md)"` or shell-expanded PR/comment bodies
 
 #### GitLab Issues / MRs
 Use notes API for issues or merge requests.

package/triage/SKILL.md

@@ -10,10 +10,10 @@ description: "Ingest or resume a tracked/local task in the RPIV workspace. Use w
 Start RPIV by creating, resuming, or explicitly reopening a task workspace.
 
 ## Guardrails
-- READ: user argument, `.workflow/active.json` / `.workflow/active_task.json` if present, target `metadata.json`, and target `WORK.md` if resuming.
-- WRITE: `.workflow/tasks/[source-id]/WORK.md`, `.workflow/tasks/[source-id]/metadata.json`, `.workflow/active.json`, `.workflow/active_task.json`; optional `.reposcry/` cache files only if RepoScry is installed.
+- READ: user argument, `.workflow/active.json` first and compatibility `.workflow/active_task.json` only if present/needed, target `metadata.json`, and target `WORK.md` if resuming.
+- WRITE: `.workflow/tasks/[source-id]/WORK.md`, `.workflow/tasks/[source-id]/metadata.json`, `.workflow/active.json`.
 - On **create**, initialize required guarded sections only if absent: `[BRIEF]`, `[GRILL]`, `[PLAN]`, `[LOG]`, `[META]`.
-- On **resume**, only update `.workflow/active.json`, `.workflow/active_task.json`, metadata timestamps/state as needed, and `[META]`, then append one concise `[LOG]` entry.
+- On **resume**, only update `.workflow/active.json`, metadata timestamps/state as needed, and `[META]`, then append one concise `[LOG]` entry.
 - NEVER: duplicate guarded sections.
 - NEVER: overwrite existing `[BRIEF]`, `[GRILL]`, or `[PLAN]` during triage.
 - NEVER: create `PROBLEM.md`, `PRD.md`, `PLAN.md`, or `EVIDENCE.md`.
@@ -60,17 +60,14 @@ Start RPIV by creating, resuming, or explicitly reopening a task workspace.
    - Preferred absolute path: `<skill_dir>/../scripts/triage_helper.sh`.
 3. Read the resulting active pointer, metadata, and `WORK.md`.
 4. Determine action based on helper output and task state: `created`, `resumed`, `reopened`, `refused`, `fresh/reset`.
-5. Optional RepoScry bootstrap: if bundled `../scripts/reposcry-bootstrap.sh` available, run it to seed `.reposcry/` for later `/frame` and `/grill-with-docs`.
-   - Run `../scripts/reposcry-bootstrap.sh --pulse` to determine "Repo Pulse" (Warm/Cold/Missing) for the output contract.
-   - Run `../scripts/reposcry-bootstrap.sh` to ensure the local cache is initialized.
-   - The helper must ensure `.reposcry/` is ignored, must stop if `.reposcry/` tracked/staged, and continue normally if RepoScry is unavailable.
-6. Verify branch: ensure current branch matches metadata `branch` (or is `main`/`master` for planning).
-7. If task was newly created, infer classification:
+6. New task creation should store structured tracker facts in `metadata.json` and write a concise normalized intake snapshot into `WORK.md`; never paste raw tracker CLI rendering.
+7. Verify branch: ensure current branch matches metadata `branch` (or is `main`/`master` for planning).
+8. If task was newly created, infer classification:
    - `github:`, `gitlab:`, `jira:` labels/type often indicate Problem (bug) or Proposal (feature).
    - Local tasks default to Proposal unless specified.
-8. If resuming, check `[BRIEF]` and `[PLAN]` completion status.
-9. **Final Guidance**: record current branch in `[META]`. For `jira:` tasks, also preserve the Jira key in `[META]` and mention `/implement` must use it in the commit subject. Planning on `main`/`master` allowed; implementation will use `/implement` branch enforcement.
-10. End by recommending next valid command:
+9. If resuming, check `[BRIEF]` and `[PLAN]` completion status.
+10. **Final Guidance**: record current branch in `[META]`. For `jira:` tasks, preserve the Jira key in `[META]`. Planning on `main`/`master` allowed; implementation will use `/implement` branch enforcement.
+11. End by recommending next valid command:
     - newly created -> `/frame`
     - existing empty `[BRIEF]` -> `/frame`
     - framed but not grilled -> `/grill-with-docs`
@@ -85,6 +82,5 @@ End with:
 - **Status**: active / blocked / done / archived / unknown
 - **Phase**: triaged / framed / grilled / planned / implementing / verifying / synced / closed / unknown
 - **Branch**: current branch
-- **Repo Pulse**: Warm / Cold / Missing / Not applicable
 - **Classification**: Problem / Proposal
 - **Next step**: `/frame`, `/grill-with-docs`, `/plan`, `/implement`, or explicit reopen/fresh choice

package/verify/SKILL.md

@@ -10,7 +10,7 @@ description: Verify the active slice or task against WORK.md, quality gates, and
 The final gate for a slice or task. Verify truth before reporting progress.
 
 ## Guardrails
-- READ: `.workflow/active.json` / `.workflow/active_task.json`, active `WORK.md` `[BRIEF]`, `[PLAN]`, and `[LOG]`.
+- READ: `.workflow/active.json` first, then compatibility `.workflow/active_task.json` only if needed, plus active `WORK.md` `[BRIEF]`, `[PLAN]`, and `[LOG]`.
 - WRITE: `WORK.md` -> `[PLAN]` checkboxes and append to `[LOG]` only.
 - NEVER: add `Signed-off-by`; tell the human to sign if needed.
 - NEVER: transition tracker state if verification fails.
@@ -19,9 +19,8 @@ The final gate for a slice or task. Verify truth before reporting progress.
 ## Workflow
 1. Compare code changes against `[BRIEF]` and the current `[PLAN]` slice.
 2. Run stated verification commands and available quality gates.
-3. If RepoScry is available, optionally add graph-aware evidence with commands such as `reposcry validate main HEAD` and `reposcry --repo . get_affected_flows main HEAD`. Treat RepoScry as supplemental evidence, not a hard requirement. Verify `.reposcry/` is not staged or tracked before reporting review readiness.
 4. Check for AI artifacts: placeholder comments, fake APIs, dead code, inconsistent naming.
-5. Confirm commit messages include Conventional Commit format. When AI contributed, you MUST append an `Assisted-by` trailer. Do NOT guess or hallucinate the model name from your system prompt. You must run `bash ~/RQZ/personal/nothing/packages/norpiv/scripts/get-pi-model.sh` and use its exact output to construct the trailer: `Assisted-by: <EXACT_OUTPUT> [tools]`.
+5. Confirm commits and PR/MR metadata satisfy the repository's own hooks, CI, and release policies. Do not invent or enforce extra RPIV-specific formatting here.
 6. If passing, mark the slice checkbox complete in `[PLAN]` and append verification evidence to `[LOG]` (Format: `YYYY-MM-DD hh:mm AM/PM`).
 7. Recommend `/sync` for tracker update, or `/post-merge-prune` if the task is fully merged and user approves.
 

package/scripts/reposcry-bootstrap.sh

@@ -1,108 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-cd "$REPO_ROOT"
-
-ensure_reposcry_gitignore() {
-  local gitignore=".gitignore"
-  touch "$gitignore"
-
-  if ! grep -qxF ".reposcry/" "$gitignore"; then
-    {
-      printf '\n# RepoScry local cache\n'
-      printf '.reposcry/\n'
-    } >> "$gitignore"
-    echo "Added .reposcry/ to .gitignore"
-  fi
-}
-
-refuse_tracked_reposcry_cache() {
-  local tracked staged
-  tracked=$(git ls-files .reposcry 2>/dev/null || true)
-  staged=$(git diff --cached --name-only -- .reposcry 2>/dev/null || true)
-
-  if [[ -n "$tracked" || -n "$staged" ]]; then
-    echo "ERROR: .reposcry/ cache is tracked or staged. It is generated local state and must not be committed." >&2
-    if [[ -n "$tracked" ]]; then
-      echo "Tracked files:" >&2
-      printf '%s\n' "$tracked" >&2
-    fi
-    if [[ -n "$staged" ]]; then
-      echo "Staged files:" >&2
-      printf '%s\n' "$staged" >&2
-    fi
-    echo "Fix: git rm --cached -r .reposcry && keep .reposcry/ in .gitignore" >&2
-    exit 1
-  fi
-}
-
-reposcry_indexed_files() {
-  reposcry stats 2>/dev/null | awk '/Files indexed:/ {print $3; exit}'
-}
-
-# Quick health check for Pulse info
-check_pulse() {
-  if ! command -v reposcry >/dev/null 2>&1; then
-    echo "PULSE: Missing (Not installed)"
-    return
-  fi
-  if [[ ! -d .reposcry ]]; then
-    echo "PULSE: Cold (No cache)"
-    return
-  fi
-  local files
-  files=$(reposcry_indexed_files || echo "0")
-  if [[ "$files" == "0" ]]; then
-    echo "PULSE: Cold (Zero files)"
-  else
-    echo "PULSE: Warm ($files files)"
-  fi
-}
-
-if [[ "${1:-}" == "--pulse" ]]; then
-  check_pulse
-  exit 0
-fi
-
-ensure_reposcry_gitignore
-refuse_tracked_reposcry_cache
-
-if ! command -v reposcry >/dev/null 2>&1; then
-  echo "RepoScry not installed; skipping bootstrap."
-  exit 0
-fi
-
-HAD_REPOSCRYIGNORE=0
-[[ -f .reposcryignore ]] && HAD_REPOSCRYIGNORE=1
-
-FORCE_REINDEX=0
-if [[ "${1:-}" == "--force" || "${1:-}" == "--reindex" ]]; then
-  FORCE_REINDEX=1
-fi
-
-if [[ ! -d .reposcry ]]; then
-  echo "Initializing RepoScry..."
-  reposcry init >/dev/null 2>&1 || reposcry init || {
-    echo "RepoScry init failed; continuing without RepoScry." >&2
-    exit 0
-  }
-fi
-
-INDEXED_FILES=$(reposcry_indexed_files || true)
-INDEXED_FILES=${INDEXED_FILES:-0}
-
-if [[ $FORCE_REINDEX -eq 1 || "$INDEXED_FILES" == "0" ]]; then
-  echo "Indexing repository with RepoScry (--no-semantic)..."
-  reposcry index --no-semantic || {
-    echo "RepoScry index failed; continuing without RepoScry." >&2
-    exit 0
-  }
-else
-  echo "RepoScry index already present ($INDEXED_FILES files indexed)."
-fi
-
-if [[ $HAD_REPOSCRYIGNORE -eq 0 && -f .reposcryignore ]]; then
-  echo "RepoScry created .reposcryignore. Review and commit it if you want stable RepoScry indexing rules."
-fi

package/scripts/reposcry-refresh.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-BASE_REF=${1:-${REPOSCRY_BASE_REF:-main}}
-
-if ! command -v reposcry-update >/dev/null 2>&1; then
-  echo "reposcry-update not installed; skipping refresh."
-  exit 0
-fi
-
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-cd "$REPO_ROOT"
-
-echo "Refreshing RepoScry for changed files against base '$BASE_REF'..."
-if ! reposcry-update --changed --base "$BASE_REF"; then
-  echo "RepoScry refresh failed; continuing without refreshed graph state." >&2
-  exit 0
-fi

package/scripts/reposcry-task-context.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-TASK_TEXT=${*:-}
-if [[ -z "$TASK_TEXT" ]]; then
-  echo "Usage: $0 <task summary>"
-  exit 1
-fi
-
-if ! command -v reposcry >/dev/null 2>&1; then
-  echo "RepoScry not installed; skipping task context generation."
-  exit 0
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-cd "$REPO_ROOT"
-
-"$SCRIPT_DIR/reposcry-bootstrap.sh" || true
-
-mkdir -p .reposcry
-
-# Detect low-token modes (Caveman, etc.)
-DEFAULT_BUDGET=20000
-if [[ "${CAVEMAN_MODE:-off}" != "off" ]] || [[ "${LOW_TOKEN_MODE:-0}" == "1" ]]; then
-  DEFAULT_BUDGET=5000
-  echo "Low-token mode detected: reducing context budget to $DEFAULT_BUDGET"
-fi
-
-BUDGET=${REPOSCRY_CONTEXT_BUDGET:-$DEFAULT_BUDGET}
-OUTPUT_PATH=".reposcry/AI_CONTEXT.md"
-
-echo "Generating RepoScry task context at $OUTPUT_PATH..."
-if reposcry context "$TASK_TEXT" --strict --budget "$BUDGET" --format markdown > "$OUTPUT_PATH"; then
-  echo "Wrote $OUTPUT_PATH"
-else
-  echo "RepoScry context generation failed; leaving RPIV flow unchanged." >&2
-  rm -f "$OUTPUT_PATH"
-fi