all-for-claudecode 2.0.0 → 2.2.0

package/scripts/afc-schema-validate.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+set -euo pipefail
+
+# afc-schema-validate.sh — Validate JSON files against JSON Schema definitions
+# Usage: afc-schema-validate.sh [--json-file FILE --schema FILE | --all]
+# Exit: 0 = valid, 1 = validation error
+
+# shellcheck disable=SC2329
+cleanup() { :; }
+trap cleanup EXIT
+
+PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}"
+SCHEMAS_DIR="${PLUGIN_ROOT}/schemas"
+
+# --- Node.js embedded validator ---
+validate_with_node() {
+  local json_file="$1" schema_file="$2"
+  # shellcheck disable=SC2016
+  node -e '
+const fs = require("fs");
+const jsonFile = process.argv[1];
+const schemaFile = process.argv[2];
+
+let data, schema;
+try { data = JSON.parse(fs.readFileSync(jsonFile, "utf8")); }
+catch (e) { console.error("[afc:schema] JSON parse error in " + jsonFile + ": " + e.message); process.exit(1); }
+try { schema = JSON.parse(fs.readFileSync(schemaFile, "utf8")); }
+catch (e) { console.error("[afc:schema] Schema parse error in " + schemaFile + ": " + e.message); process.exit(1); }
+
+const errors = [];
+
+function validate(value, sch, path) {
+  if (!sch || typeof sch !== "object") return;
+
+  // type check
+  if (sch.type) {
+    const t = sch.type;
+    const actual = Array.isArray(value) ? "array" : typeof value;
+    if (actual === "number" && t === "integer") {
+      if (!Number.isInteger(value)) errors.push(path + ": expected integer, got float");
+    } else if (t !== actual) {
+      errors.push(path + ": expected " + t + ", got " + actual);
+      return;
+    }
+  }
+
+  // enum check
+  if (sch.enum && !sch.enum.includes(value)) {
+    errors.push(path + ": value \"" + value + "\" not in enum [" + sch.enum.join(", ") + "]");
+  }
+
+  // pattern check
+  if (sch.pattern && typeof value === "string") {
+    if (!new RegExp(sch.pattern).test(value)) {
+      errors.push(path + ": \"" + value + "\" does not match pattern " + sch.pattern);
+    }
+  }
+
+  // minLength
+  if (sch.minLength !== undefined && typeof value === "string" && value.length < sch.minLength) {
+    errors.push(path + ": string length " + value.length + " < minLength " + sch.minLength);
+  }
+
+  // minimum (integer/number)
+  if (sch.minimum !== undefined && typeof value === "number" && value < sch.minimum) {
+    errors.push(path + ": value " + value + " < minimum " + sch.minimum);
+  }
+
+  // minItems (array)
+  if (sch.minItems !== undefined && Array.isArray(value) && value.length < sch.minItems) {
+    errors.push(path + ": array length " + value.length + " < minItems " + sch.minItems);
+  }
+
+  // object validations
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    // required
+    if (sch.required) {
+      for (const r of sch.required) {
+        if (!(r in value)) errors.push(path + "." + r + ": required field missing");
+      }
+    }
+
+    // properties
+    if (sch.properties) {
+      for (const [k, v] of Object.entries(value)) {
+        if (sch.properties[k]) {
+          validate(v, sch.properties[k], path + "." + k);
+        } else if (sch.patternProperties) {
+          let matched = false;
+          for (const [pat, patSch] of Object.entries(sch.patternProperties)) {
+            if (new RegExp(pat).test(k)) { validate(v, patSch, path + "." + k); matched = true; break; }
+          }
+          if (!matched && sch.additionalProperties === false) {
+            errors.push(path + "." + k + ": unexpected property");
+          }
+        } else if (sch.additionalProperties === false) {
+          errors.push(path + "." + k + ": unexpected property");
+        }
+      }
+    } else if (sch.patternProperties) {
+      for (const [k, v] of Object.entries(value)) {
+        let matched = false;
+        for (const [pat, patSch] of Object.entries(sch.patternProperties)) {
+          if (new RegExp(pat).test(k)) { validate(v, patSch, path + "." + k); matched = true; break; }
+        }
+        if (!matched && sch.additionalProperties === false) {
+          errors.push(path + "." + k + ": unexpected property");
+        }
+      }
+    }
+  }
+
+  // array validations
+  if (Array.isArray(value) && sch.items) {
+    for (let i = 0; i < value.length; i++) {
+      validate(value[i], sch.items, path + "[" + i + "]");
+    }
+  }
+
+  // $ref resolution (local definitions only)
+  if (sch["$ref"]) {
+    const refPath = sch["$ref"].replace("#/definitions/", "");
+    if (schema.definitions && schema.definitions[refPath]) {
+      validate(value, schema.definitions[refPath], path);
+    }
+  }
+}
+
+validate(data, schema, "$");
+
+if (errors.length > 0) {
+  console.error("[afc:schema] " + jsonFile + " validation failed:");
+  errors.forEach(e => console.error("  " + e));
+  process.exit(1);
+} else {
+  console.log("[afc:schema] " + jsonFile + " — valid");
+}
+' "$json_file" "$schema_file"
+}
+
+# --- jq fallback (basic structure only) ---
+validate_with_jq() {
+  local json_file="$1" schema_file="$2"
+
+  # Step 1: valid JSON?
+  if ! jq empty "$json_file" 2>/dev/null; then
+    printf '%s\n' "[afc:schema] JSON parse error in ${json_file}" >&2
+    return 1
+  fi
+
+  # Step 2: check required top-level keys from schema
+  local required_keys
+  required_keys=$(jq -r '.required[]? // empty' "$schema_file" 2>/dev/null || true)
+  if [ -n "$required_keys" ]; then
+    local missing=0
+    while IFS= read -r key; do
+      if ! jq -e ".[\"${key}\"]" "$json_file" >/dev/null 2>&1; then
+        printf '%s\n' "[afc:schema] ${json_file}: required field missing: ${key}" >&2
+        missing=1
+      fi
+    done <<< "$required_keys"
+    if [ "$missing" -eq 1 ]; then
+      return 1
+    fi
+  fi
+
+  printf '%s\n' "[afc:schema] ${json_file} — valid (jq basic)"
+  return 0
+}
+
+# --- Main ---
+validate_file() {
+  local json_file="$1" schema_file="$2"
+
+  if [ ! -f "$json_file" ]; then
+    printf '%s\n' "[afc:schema] File not found: ${json_file}" >&2
+    return 1
+  fi
+  if [ ! -f "$schema_file" ]; then
+    printf '%s\n' "[afc:schema] Schema not found: ${schema_file}" >&2
+    return 1
+  fi
+
+  if command -v node >/dev/null 2>&1; then
+    validate_with_node "$json_file" "$schema_file"
+  elif command -v jq >/dev/null 2>&1; then
+    printf '%s\n' "[afc:schema] WARNING: node not found, using jq basic validation" >&2
+    validate_with_jq "$json_file" "$schema_file"
+  else
+    printf '%s\n' "[afc:schema] WARNING: neither node nor jq found, skipping validation" >&2
+    return 0
+  fi
+}
+
+# Parse arguments
+MODE="all"
+JSON_FILE=""
+SCHEMA_FILE=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --json-file) JSON_FILE="$2"; MODE="single"; shift 2 ;;
+    --schema) SCHEMA_FILE="$2"; shift 2 ;;
+    --all) MODE="all"; shift ;;
+    *) printf '%s\n' "[afc] Usage: afc-schema-validate.sh [--json-file FILE --schema FILE | --all]" >&2; exit 1 ;;
+  esac
+done
+
+if [ "$MODE" = "single" ]; then
+  if [ -z "$JSON_FILE" ] || [ -z "$SCHEMA_FILE" ]; then
+    printf '%s\n' "[afc] Usage: afc-schema-validate.sh --json-file FILE --schema FILE" >&2
+    exit 1
+  fi
+  validate_file "$JSON_FILE" "$SCHEMA_FILE"
+else
+  ERRORS=0
+  validate_file "${PLUGIN_ROOT}/hooks/hooks.json" "${SCHEMAS_DIR}/hooks.schema.json" || ERRORS=$((ERRORS + 1))
+  validate_file "${PLUGIN_ROOT}/.claude-plugin/plugin.json" "${SCHEMAS_DIR}/plugin.schema.json" || ERRORS=$((ERRORS + 1))
+  validate_file "${PLUGIN_ROOT}/.claude-plugin/marketplace.json" "${SCHEMAS_DIR}/marketplace.schema.json" || ERRORS=$((ERRORS + 1))
+  if [ "$ERRORS" -gt 0 ]; then
+    printf '%s\n' "[afc:schema] ${ERRORS} file(s) failed validation" >&2
+    exit 1
+  fi
+  printf '%s\n' "[afc:schema] All 3 files valid"
+fi

package/scripts/afc-session-end.sh

@@ -5,6 +5,9 @@ set -euo pipefail
 #
 # Gap fix: Ensures resumability via /afc:resume even after session ends
 
+# shellcheck source=afc-state.sh
+. "$(dirname "$0")/afc-state.sh"
+
 # shellcheck disable=SC2329
 cleanup() {
   # Extend here if temporary file cleanup is needed
@@ -12,18 +15,15 @@ cleanup() {
 }
 trap cleanup EXIT
 
-PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-PIPELINE_FLAG="${PROJECT_DIR}/.claude/.afc-active"
-
 # Consume stdin early (required -- pipe breaks if not consumed)
 INPUT=$(cat)
 
 # If pipeline is not active -> exit silently
-if [ ! -f "$PIPELINE_FLAG" ]; then
+if ! afc_state_is_active; then
   exit 0
 fi
 
-FEATURE=$(head -1 "$PIPELINE_FLAG" | tr -d '\n\r')
+FEATURE=$(afc_state_read feature || echo '')
 
 # Parse reason: jq preferred, grep/sed fallback
 REASON=""

package/scripts/afc-state.sh

@@ -0,0 +1,256 @@
+#!/bin/bash
+# afc-state.sh — Shared state library for pipeline state management
+# Source this file: . "$(dirname "$0")/afc-state.sh"
+# Replaces 4 flag files (.afc-active, .afc-phase, .afc-ci-passed, .afc-changes.log)
+# with a single .afc-state.json file.
+
+# State file path
+_AFC_STATE_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude"
+_AFC_STATE_FILE="${_AFC_STATE_DIR}/.afc-state.json"
+
+# --- Phase Constants (SSOT) ---
+# All valid pipeline phases. Update HERE when adding a new phase.
+AFC_VALID_PHASES="spec|plan|tasks|implement|review|clean|clarify|test-pre-gen|blast-radius|fast-path"
+# Phases that do NOT require CI gate to pass (preparatory phases)
+AFC_CI_EXEMPT_PHASES="spec|plan|tasks|clarify|test-pre-gen|blast-radius"
+
+# Check if a phase name is valid
+# Usage: afc_is_valid_phase <phase>
+# Returns: 0 if valid, 1 if not
+afc_is_valid_phase() {
+  printf '%s\n' "$AFC_VALID_PHASES" | tr '|' '\n' | grep -qxF "$1"
+}
+
+# Check if a phase is exempt from CI gate
+# Usage: afc_is_ci_exempt <phase>
+# Returns: 0 if exempt, 1 if CI required
+afc_is_ci_exempt() {
+  printf '%s\n' "$AFC_CI_EXEMPT_PHASES" | tr '|' '\n' | grep -qxF "$1"
+}
+
+# --- Public API ---
+
+# Check if pipeline is active (state file exists and has feature)
+# Returns: 0 if active, 1 if not
+afc_state_is_active() {
+  [ -f "$_AFC_STATE_FILE" ] && [ -s "$_AFC_STATE_FILE" ]
+}
+
+# Read a field from state file
+# Usage: afc_state_read <field>
+# Fields: feature, phase, ciPassedAt, startedAt
+# Returns: field value on stdout, exit 1 if not found
+afc_state_read() {
+  local field="$1"
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    return 1
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    local val
+    val=$(jq -r --arg f "$field" '.[$f] // empty' "$_AFC_STATE_FILE" 2>/dev/null) || return 1
+    [ -n "$val" ] && printf '%s\n' "$val" && return 0
+    return 1
+  else
+    # grep/sed fallback for simple string/number fields
+    local val
+    val=$(grep -o "\"${field}\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" "$_AFC_STATE_FILE" 2>/dev/null \
+      | head -1 | sed 's/.*:[[:space:]]*"\(.*\)"/\1/')
+    if [ -z "$val" ]; then
+      # Try numeric value
+      val=$(grep -o "\"${field}\"[[:space:]]*:[[:space:]]*[0-9]*" "$_AFC_STATE_FILE" 2>/dev/null \
+        | head -1 | sed 's/.*:[[:space:]]*//')
+    fi
+    [ -n "$val" ] && printf '%s\n' "$val" && return 0
+    return 1
+  fi
+}
+
+# Write/update a field in state file
+# Usage: afc_state_write <field> <value>
+afc_state_write() {
+  local field="$1" value="$2"
+  mkdir -p "$_AFC_STATE_DIR"
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    printf '{}' > "$_AFC_STATE_FILE"
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    local tmp
+    tmp=$(mktemp)
+    local jq_ok=0
+    if printf '%s' "$value" | grep -qE '^[0-9]+$'; then
+      jq --arg f "$field" --argjson v "$value" '.[$f] = $v' "$_AFC_STATE_FILE" > "$tmp" 2>/dev/null && jq_ok=1
+    else
+      jq --arg f "$field" --arg v "$value" '.[$f] = $v' "$_AFC_STATE_FILE" > "$tmp" 2>/dev/null && jq_ok=1
+    fi
+    if [ "$jq_ok" -eq 1 ]; then
+      mv "$tmp" "$_AFC_STATE_FILE"
+    else
+      rm -f "$tmp"
+    fi
+  else
+    # sed fallback: replace or append field
+    # Escape sed-special chars in value: \ first, then &
+    local safe_val="$value"
+    safe_val="${safe_val//\\/\\\\}"
+    safe_val="${safe_val//&/\\&}"
+    if grep -q "\"${field}\"" "$_AFC_STATE_FILE" 2>/dev/null; then
+      local tmp
+      tmp=$(mktemp)
+      if printf '%s' "$value" | grep -qE '^[0-9]+$'; then
+        sed "s/\"${field}\"[[:space:]]*:[[:space:]]*[^,}]*/\"${field}\": ${value}/" "$_AFC_STATE_FILE" > "$tmp"
+      else
+        sed "s/\"${field}\"[[:space:]]*:[[:space:]]*[^,}]*/\"${field}\": \"${safe_val}\"/" "$_AFC_STATE_FILE" > "$tmp"
+      fi
+      mv "$tmp" "$_AFC_STATE_FILE"
+    else
+      # Append before closing brace
+      local tmp
+      tmp=$(mktemp)
+      if printf '%s' "$value" | grep -qE '^[0-9]+$'; then
+        sed "s/}$/,\"${field}\": ${value}}/" "$_AFC_STATE_FILE" > "$tmp"
+      else
+        sed "s/}$/,\"${field}\": \"${safe_val}\"}/" "$_AFC_STATE_FILE" > "$tmp"
+      fi
+      # Fix leading comma on empty object
+      sed 's/{,/{/' "$tmp" > "$_AFC_STATE_FILE"
+      rm -f "$tmp"
+    fi
+  fi
+}
+
+# Remove a field from state file
+# Usage: afc_state_remove <field>
+afc_state_remove() {
+  local field="$1"
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    return 0
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    local tmp
+    tmp=$(mktemp)
+    if jq --arg f "$field" 'del(.[$f])' "$_AFC_STATE_FILE" > "$tmp" 2>/dev/null; then
+      mv "$tmp" "$_AFC_STATE_FILE"
+    else
+      rm -f "$tmp"
+    fi
+  fi
+  # sed fallback: skip removal (non-critical)
+}
+
+# Initialize state for a new pipeline
+# Usage: afc_state_init <feature>
+afc_state_init() {
+  local feature="$1"
+  local now
+  now=$(date +%s)
+  mkdir -p "$_AFC_STATE_DIR"
+  if command -v jq >/dev/null 2>&1; then
+    jq -n --arg f "$feature" --argjson t "$now" \
+      '{feature: $f, phase: "spec", startedAt: $t}' > "$_AFC_STATE_FILE"
+  else
+    local safe_feature="${feature//\\/\\\\}"
+    safe_feature="${safe_feature//\"/\\\"}"
+    printf '{"feature": "%s", "phase": "spec", "startedAt": %s}\n' "$safe_feature" "$now" > "$_AFC_STATE_FILE"
+  fi
+}
+
+# Delete the state file (pipeline ended)
+afc_state_delete() {
+  rm -f "$_AFC_STATE_FILE"
+}
+
+# Append a file path to the changes array
+# Usage: afc_state_append_change <file_path>
+afc_state_append_change() {
+  local file_path="$1"
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    return 1
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    local tmp
+    tmp=$(mktemp)
+    if jq --arg p "$file_path" '.changes = ((.changes // []) + [$p] | unique)' "$_AFC_STATE_FILE" > "$tmp" 2>/dev/null; then
+      mv "$tmp" "$_AFC_STATE_FILE"
+    else
+      rm -f "$tmp"
+    fi
+  else
+    # Fallback: use a sidecar changes file
+    printf '%s\n' "$file_path" >> "${_AFC_STATE_FILE%.json}.changes.log"
+    sort -u -o "${_AFC_STATE_FILE%.json}.changes.log" "${_AFC_STATE_FILE%.json}.changes.log"
+  fi
+}
+
+# Read all changes as newline-separated list
+# Usage: afc_state_read_changes
+afc_state_read_changes() {
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    return 1
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    jq -r '.changes[]? // empty' "$_AFC_STATE_FILE" 2>/dev/null
+  else
+    # Fallback: read sidecar file
+    if [ -f "${_AFC_STATE_FILE%.json}.changes.log" ]; then
+      cat "${_AFC_STATE_FILE%.json}.changes.log"
+    fi
+  fi
+}
+
+# Invalidate CI (remove ciPassedAt)
+afc_state_invalidate_ci() {
+  afc_state_remove "ciPassedAt"
+}
+
+# Record CI pass timestamp
+afc_state_ci_pass() {
+  local now
+  now=$(date +%s)
+  afc_state_write "ciPassedAt" "$now"
+}
+
+# Record a phase checkpoint with git SHA
+# Usage: afc_state_checkpoint <phase>
+afc_state_checkpoint() {
+  local phase="$1"
+  if [ ! -f "$_AFC_STATE_FILE" ]; then
+    return 1
+  fi
+  local git_sha=""
+  if cd "${CLAUDE_PROJECT_DIR:-$(pwd)}" 2>/dev/null; then
+    git_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "")
+  fi
+  local now
+  now=$(date +%s)
+  if command -v jq >/dev/null 2>&1; then
+    local tmp
+    tmp=$(mktemp)
+    if jq --arg p "$phase" --arg s "$git_sha" --argjson t "$now" \
+      '.phaseCheckpoints = ((.phaseCheckpoints // []) + [{"phase": $p, "gitSha": $s, "timestamp": $t}])' \
+      "$_AFC_STATE_FILE" > "$tmp" 2>/dev/null; then
+      mv "$tmp" "$_AFC_STATE_FILE"
+    else
+      rm -f "$tmp"
+    fi
+  fi
+  # No sed fallback — phaseCheckpoints is array-typed, too complex for sed
+}
+
+# Legacy fallback: check if old flag files exist
+# Returns: 0 if legacy state found, 1 if not
+# Side effect: sets FEATURE and PHASE variables
+_afc_state_legacy_check() {
+  local dir="${_AFC_STATE_DIR}"
+  if [ -f "$dir/.afc-active" ]; then
+    # shellcheck disable=SC2034
+    FEATURE=$(head -1 "$dir/.afc-active" 2>/dev/null | tr -d '\n\r')
+    # shellcheck disable=SC2034
+    PHASE=""
+    if [ -f "$dir/.afc-phase" ]; then
+      # shellcheck disable=SC2034
+      PHASE=$(head -1 "$dir/.afc-phase" 2>/dev/null | tr -d '\n\r')
+    fi
+    return 0
+  fi
+  return 1
+}

package/scripts/afc-stop-gate.sh

@@ -5,27 +5,25 @@ set -euo pipefail
 #
 # Gap fix: "Prompts are not enforcement" -> Physical enforcement via exit 2
 
+# shellcheck source=afc-state.sh
+. "$(dirname "$0")/afc-state.sh"
+
 # trap: Preserve exit code on abnormal termination + stderr message
 # shellcheck disable=SC2329
 cleanup() {
   local exit_code=$?
   if [ "$exit_code" -ne 0 ] && [ "$exit_code" -ne 2 ]; then
-    echo "AFC GATE: Abnormal exit (exit code: $exit_code)" >&2
+    echo "[afc:gate] Abnormal exit (code: $exit_code)" >&2
   fi
   exit "$exit_code"
 }
 trap cleanup EXIT
 
-PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-PIPELINE_FLAG="${PROJECT_DIR}/.claude/.afc-active"
-CI_FLAG="${PROJECT_DIR}/.claude/.afc-ci-passed"
-PHASE_FLAG="${PROJECT_DIR}/.claude/.afc-phase"
-
 # Consume stdin (required -- pipe breaks if not consumed)
 INPUT=$(cat)
 
 # If pipeline is not active -> pass through
-if [ ! -f "$PIPELINE_FLAG" ]; then
+if ! afc_state_is_active; then
   exit 0
 fi
 
@@ -42,35 +40,45 @@ if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
   exit 0
 fi
 
-FEATURE="$(head -1 "$PIPELINE_FLAG" | tr -d '\n\r')"
+FEATURE="$(afc_state_read feature || echo '')"
 
-# Check current Phase if phase file exists
-CURRENT_PHASE=""
-if [ -f "$PHASE_FLAG" ]; then
-  CURRENT_PHASE="$(head -1 "$PHASE_FLAG" | tr -d '\n\r')"
-fi
+# Check current Phase
+CURRENT_PHASE="$(afc_state_read phase || echo '')"
 
-# Spec/Plan/Tasks Phase (1-3) do not require CI -> pass through
-case "${CURRENT_PHASE:-}" in
-  spec|plan|tasks)
-    exit 0
-    ;;
-esac
+# Preparatory phases do not require CI -> pass through
+if afc_is_ci_exempt "${CURRENT_PHASE:-}"; then
+  exit 0
+fi
 
 # Implement/Review/Clean Phase (4-6) require CI to pass
-if [ ! -f "$CI_FLAG" ]; then
-  echo "AFC GATE: CI has not been run. Pipeline '${FEATURE:-unknown}' Phase '${CURRENT_PHASE:-unknown}' requires passing the CI gate. Run your CI command and record the timestamp in .claude/.afc-ci-passed." >&2
+CI_TIME="$(afc_state_read ciPassedAt 2>/dev/null || echo '')"
+CI_TIME="$(printf '%s' "$CI_TIME" | tr -dc '0-9')"
+CI_TIME="${CI_TIME:-0}"
+
+if [ "$CI_TIME" -eq 0 ]; then
+  # Check last_assistant_message for premature completion claims
+  LAST_MSG=""
+  if command -v jq &>/dev/null; then
+    LAST_MSG=$(printf '%s\n' "$INPUT" | jq -r '.last_assistant_message // empty' 2>/dev/null || true)
+  else
+    LAST_MSG=$(printf '%s\n' "$INPUT" | grep -o '"last_assistant_message"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*:[[:space:]]*"//;s/"$//' 2>/dev/null || true)
+  fi
+  LAST_MSG=$(printf '%s\n' "$LAST_MSG" | head -1 | cut -c1-500)
+
+  if printf '%s\n' "$LAST_MSG" | grep -qiE '(done|complete[^s]|finished|implemented|all tasks)' 2>/dev/null; then
+    printf "[afc:gate] CI has not passed. Pipeline '%s' Phase '%s' requires CI gate.\n  → Run your CI command and verify it passes\n" "${FEATURE:-unknown}" "${CURRENT_PHASE:-unknown}" >&2
+  else
+    printf "[afc:gate] CI has not been run. Pipeline '%s' Phase '%s' requires CI gate.\n  → Run your CI command to pass the gate\n" "${FEATURE:-unknown}" "${CURRENT_PHASE:-unknown}" >&2
+  fi
   exit 2
 fi
 
 # Verify CI passed within the last 10 minutes (prevent stale results)
-CI_TIME="$(cat "$CI_FLAG" 2>/dev/null | head -1 | tr -dc '0-9' || true)"
-CI_TIME="${CI_TIME:-0}"
 NOW="$(date +%s)"
 if [ "$CI_TIME" -gt 0 ]; then
   DIFF=$(( NOW - CI_TIME ))
   if [ "$DIFF" -gt 600 ]; then
-    echo "AFC GATE: CI results are stale (${DIFF} seconds ago). Please run your CI command again." >&2
+    printf "[afc:gate] CI results are stale (%ss ago).\n  → Run your CI command again\n" "$DIFF" >&2
     exit 2
   fi
 fi

package/scripts/afc-subagent-context.sh

@@ -6,6 +6,9 @@ set -euo pipefail
 #
 # Gap fix: Subagents do not inherit parent context, so explicit injection is required
 
+# shellcheck source=afc-state.sh
+. "$(dirname "$0")/afc-state.sh"
+
 # shellcheck disable=SC2329
 cleanup() {
   :
@@ -13,21 +16,20 @@ cleanup() {
 trap cleanup EXIT
 
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-PIPELINE_FLAG="$PROJECT_DIR/.claude/.afc-active"
 
 # Consume stdin (required -- pipe breaks if not consumed)
 cat > /dev/null
 
 # Exit silently if pipeline is inactive
-if [ ! -f "$PIPELINE_FLAG" ]; then
+if ! afc_state_is_active; then
   exit 0
 fi
 
 # 1. Read feature name
-FEATURE=$(head -1 "$PIPELINE_FLAG" 2>/dev/null | tr -d '\n\r' || echo "unknown")
+FEATURE=$(afc_state_read feature || echo "unknown")
 
 # 2. Read current phase
-PHASE=$(head -1 "$PROJECT_DIR/.claude/.afc-phase" 2>/dev/null | tr -d '\n\r' || echo "unknown")
+PHASE=$(afc_state_read phase || echo "unknown")
 
 # 3. Build context string
 CONTEXT="[AFC PIPELINE] Feature: $FEATURE | Phase: $PHASE"
@@ -38,17 +40,24 @@ CONFIG_FILE="$PROJECT_DIR/.claude/afc.config.md"
 if [ -f "$CONFIG_FILE" ]; then
   # Extract Architecture section (## Architecture to next ##)
   # shellcheck disable=SC2001
-  ARCH=$(sed -n '/^## Architecture/,/^## /p' "$CONFIG_FILE" 2>/dev/null | sed '1d;/^## /d;/^$/d' | head -5 | tr '\n' ' ' | sed 's/  */ /g;s/^ *//;s/ *$//')
+  ARCH=$(sed -n '/^## Architecture/,/^## /p' "$CONFIG_FILE" 2>/dev/null | sed '1d;/^## /d;/^$/d' | head -15 | tr '\n' ' ' | sed 's/  */ /g;s/^ *//;s/ *$//')
   if [ -n "$ARCH" ]; then
     CONTEXT="$CONTEXT | Architecture: $ARCH"
   fi
 
   # Extract Code Style section (## Code Style to next ##)
   # shellcheck disable=SC2001
-  STYLE=$(sed -n '/^## Code Style/,/^## /p' "$CONFIG_FILE" 2>/dev/null | sed '1d;/^## /d;/^$/d' | head -5 | tr '\n' ' ' | sed 's/  */ /g;s/^ *//;s/ *$//')
+  STYLE=$(sed -n '/^## Code Style/,/^## /p' "$CONFIG_FILE" 2>/dev/null | sed '1d;/^## /d;/^$/d' | head -15 | tr '\n' ' ' | sed 's/  */ /g;s/^ *//;s/ *$//')
   if [ -n "$STYLE" ]; then
     CONTEXT="$CONTEXT | Code Style: $STYLE"
   fi
+
+  # Extract Project Context section (## Project Context to next ## or EOF)
+  # shellcheck disable=SC2001
+  PROJ_CTX=$(sed -n '/^## Project Context/,/^## /p' "$CONFIG_FILE" 2>/dev/null | sed '1d;/^## /d;/^$/d' | head -15 | tr '\n' ' ' | sed 's/  */ /g;s/^ *//;s/ *$//')
+  if [ -n "$PROJ_CTX" ]; then
+    CONTEXT="$CONTEXT | Project Context: $PROJ_CTX"
+  fi
 fi
 
 # 5. Output as hookSpecificOutput JSON (required for SubagentStart context injection)