@raquezha/norpiv 0.0.7 → 0.1.0

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,51 +356,49 @@ 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"
 }
 
 create_task() {
-    mkdir -p "$TASK_DIR"
+    mkdir -p "$TASK_DIR/evidence"
     echo "Creating task workspace in $TASK_DIR..."
 
     case "$SOURCE" in
         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`.
@@ -21,6 +21,7 @@ Start RPIV by creating, resuming, or explicitly reopening a task workspace.
 - NEVER: guess source from `#123`; require explicit `jira:`, `github:`, `gitlab:`, or `local:`.
 - NEVER: strip or hide the Jira key for `jira:` tasks; preserve it in `[META]` and in the triage log so `/implement` can require it in the commit subject.
 - NEVER: mutate `done` or `archived` tasks unless the user explicitly requested `reopen`, `fresh`, or `reset`.
+- TASK EVIDENCE: Store task-acquired evidence (screenshots, attachments, PDFs, specs) under `.workflow/tasks/[source-id]/evidence/`.
 
 ## Command forms
 
@@ -60,17 +61,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 +83,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,18 +10,18 @@ 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.
 - NEVER: delete `.workflow` task folders without explicit user approval.
+- EVIDENCE ISOLATION: Resolve task evidence from active task workspace `.workflow/tasks/<task-id>/evidence/` or task state. Do not scan arbitrary repository files as task evidence.
 
 ## 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.