@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/core/harnesses/shared/hooks/policies/pre-implementation-gate.sh

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+case "${OSTYPE:-}" in msys*|cygwin*|win32*) if command -v jq >/dev/null 2>&1; then jq() { command jq -b "$@"; }; fi ;; esac # native jq.exe ends lines with CRLF unless -b
+_DOFLOW_SRC=${0//\\//}; case $_DOFLOW_SRC in */*) _DOFLOW_POLDIR=${_DOFLOW_SRC%/*} ;; *) _DOFLOW_POLDIR=. ;; esac
 # pre-implementation-gate.sh — Canonical Policy Library: PreToolUse(Edit|Write|...)
 # backstop for the doflow implement gate. The HARD half of the one enforced
 # gate (the other half is the prompt-level do-prereqs.sh inside
@@ -21,28 +23,20 @@
 #   - edit target is under agent-docs/ -> allow (editing the artifacts themselves)
 #   - edit target outside the repo     -> allow
 # It reads files with jq and lists checkouts with one git call; it never runs
-# the DoFlow runtime. Self-contained + fail-open: any uncertainty -> allow (exit 0).
+# the DoFlow runtime. Missing or malformed v1 input is denied as out of step; other faults follow IC-011.
 #
 # Canonical Policy Script Contract (design.md §4):
 #   env    DOFLOW_PROJECT_DIR (repo root, if the front door sets it),
 #          DOFLOW_AGENT (harness id, informational only here),
-#          CLAUDE_CONFIG_DIR / CLAUDE_PROJECT_DIR / GEMINI_CONFIG_DIR / CODEX_HOME
+#          CLAUDE_CONFIG_DIR / CLAUDE_PROJECT_DIR / CODEX_HOME
 #          (each already read by the harness-specific dispatcher this policy
 #          replaces — kept so an unmodified front door still resolves its own
 #          harness's do-paths.sh resolver)
-#   stdin  a PreToolUse-shaped JSON payload for an edit tool. Every harness's
-#          own field names differ (Claude/Gemini: tool_name/tool_input.file_path;
-#          Codex: tool_name=apply_patch with a unified diff in
-#          tool_input.command; Kiro: field names undocumented) — this script
-#          reads the union of known shapes rather than assuming one, since a
-#          native front door (Claude/Codex/Kiro) execs this script directly
-#          with no payload translation of its own.
-#   exit   0 = allow, non-zero = deny with the reason on stderr. A front door
-#          translates this into whatever JSON/exit-code shape its harness
-#          natively expects — this script never speaks a harness-specific
-#          decision shape.
+#   stdin  a native payload encoded as envelope v1 by the lifecycle bridge.
+#   exit   exit 2 + doflow_decide deny = deny; other faults per IC-011. A front
+#          door translates this into its native response shape.
 #
-# Reconciliation note (022-normalize-hooks, Phase A): claude/gemini/codex/kiro
+# Reconciliation note (022-normalize-hooks, Phase A): claude/codex/kiro
 # each shipped a separately-adapted copy of this gate; antigravity's copy
 # additionally never depended on a do-paths.sh resolver at all — it computed
 # feature_dir itself from the current branch name and checked the three
@@ -58,74 +52,71 @@
 
 set -uo pipefail
 
-command -v jq >/dev/null 2>&1 || exit 0          # no jq -> cannot evaluate -> allow
-
 INPUT=$(cat)
-
-# ── Normalized envelope (preferred; review R7) ────────────────────────────────
-# A host adapter that has already decoded its native event sends
-#   {"doflow_event": {"operation": "edit", "paths": [..], "projectRoot": "..", "taskId": ".."}}
-# and this policy consumes it verbatim. The union decoder below remains the
-# fallback for front doors that still forward raw native payloads; per-harness
-# knowledge belongs in those adapters, and each one that starts sending the
-# envelope retires its share of the union.
-ENVELOPE_ROOT=""
-ENVELOPE_TASK=""
-ENVELOPE_OP=$(printf '%s' "$INPUT" | jq -r '.doflow_event.operation // empty' 2>/dev/null)
-if [ -n "$ENVELOPE_OP" ]; then
-  [ "$ENVELOPE_OP" = "edit" ] || exit 0          # only edits are gated
-  FILES=$(printf '%s' "$INPUT" | jq -r '.doflow_event.paths[]? // empty' 2>/dev/null | sed '/^$/d' | sort -u)
-  [ -n "$FILES" ] || exit 0
-  ENVELOPE_ROOT=$(printf '%s' "$INPUT" | jq -r '.doflow_event.projectRoot // empty' 2>/dev/null)
-  ENVELOPE_TASK=$(printf '%s' "$INPUT" | jq -r '.doflow_event.taskId // empty' 2>/dev/null)
+if [ -f "$_DOFLOW_POLDIR/contract.sh" ]; then
+  . "$_DOFLOW_POLDIR/contract.sh"
 else
+  doflow_decision_init() { :; }
+  doflow_decide() { :; }
+  doflow_read_envelope() { DF_ENV_CLASS=missing; DF_ENV_CODE=contract-missing; }
+  ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure pre-implementation-gate contract-missing ) >/dev/null 2>&1 || true
+  if [[ "${DOFLOW_AGENT:-}" =~ ^[a-z]+$ ]]; then
+    printf '[pre-implementation-gate] DoFlow hooks out of step; run: doflow update -t %s\n' "$DOFLOW_AGENT" >&2
+  else
+    printf '[pre-implementation-gate] DoFlow hooks out of step; run: doflow update\n' >&2
+  fi
+  doflow_decide deny contract-missing
+  exit 2
+fi
+doflow_decision_init pre-implementation-gate 1
+command -v jq >/dev/null 2>&1 || {
+  doflow_decide error dependency-missing:jq
+  ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure pre-implementation-gate dependency-missing:jq ) >/dev/null 2>&1 || true
+  exit 0
+}
 
-# ── Tool name (union of every known field name across harnesses; LEGACY decoder) ──
-tool=""
-for field in '.tool_name' '.tool' '.toolName' '.name'; do
-  tool=$(printf '%s' "$INPUT" | jq -r "${field} // empty" 2>/dev/null)
-  [ -n "$tool" ] && break
-done
-
-is_patch_tool=false
-case "$tool" in
-  Edit|Write|MultiEdit|edit_file|write_file|create_file|replace_file|replace) ;;
-  write_to_file|replace_file_content|multi_replace_file_content) ;;
-  apply_patch) is_patch_tool=true ;;
-  *) exit 0 ;;
-esac
-
-# ── Candidate files to gate ────────────────────────────────────────────────────
-# Normal edit tools: one file, from the union of field names harnesses use.
-# apply_patch (Codex): the tool has no file_path field at all — the paths are
-# embedded in a unified diff under tool_input.command.
-FILES=""
-if [ "$is_patch_tool" = true ]; then
-  PATCH=$(printf '%s' "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
-  [ -n "$PATCH" ] || exit 0
-  # "#" (not the original codex script's "|") is the sed delimiter here: BSD
-  # sed (macOS, no GNU coreutils) misparses "s|...(Add|Update|Delete)...|...|"
-  # because it splits on every unescaped "|", including the ones meant as ERE
-  # alternation inside the pattern — a portability bug in the source script
-  # this reconciliation fixes rather than ports, since it silently broke
-  # apply_patch parsing under this exact invocation on any non-GNU-sed host.
-  FILES=$(printf '%s\n' "$PATCH" | sed -nE \
+# Parse v1 apply_patch paths using the shared parser.
+parse_patch_paths() {
+  printf '%s\n' "$1" | sed -nE \
     -e 's#^\*\*\* (Add|Update|Delete) File: (.+)$#\2#p' \
     -e 's#^\+\+\+ (a/|b/)?(.+)$#\2#p' \
-    | sed '/^\/dev\/null$/d' | sort -u)
-  [ -n "$FILES" ] || exit 0
+    | sed '/^\/dev\/null$/d' | sort -u
+}
+
+DF_ENV_CLASS=missing DF_ENV_CODE=envelope-missing
+doflow_read_envelope || true
+
+# ── Envelope v1 ───────────────────────────────────────────────────────────────
+ENVELOPE_ROOT=""
+ENVELOPE_TASK=""
+if [ "$DF_ENV_CLASS" = v1 ]; then
+  ENVELOPE_OP=$DF_ENV_OP
+  [ "$ENVELOPE_OP" = "edit" ] || exit 0          # only edits are gated
+  FILES=$DF_ENV_PATHS
+  ENVELOPE_ROOT=$DF_ENV_ROOT
+  ENVELOPE_TASK=$DF_ENV_TASK
+  if [ -z "$FILES" ] && [ -z "$DF_ENV_PATCH" ]; then
+    doflow_decide unsupported edit-without-target
+    ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure pre-implementation-gate edit-without-target ) >/dev/null 2>&1 || true
+    exit 0
+  fi
+  if [ -z "$FILES" ] && [ -n "$DF_ENV_PATCH" ]; then
+    FILES=$(parse_patch_paths "$DF_ENV_PATCH")
+    [ -n "$FILES" ] || exit 0
+  fi
+elif [ "$DF_ENV_CLASS" = unsupported ]; then
+  doflow_decide unsupported envelope-version
+  ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure pre-implementation-gate unsupported:envelope-version ) >/dev/null 2>&1 || true
+  exit 0
 else
-  file=""
-  for field in '.tool_input.file_path' '.tool_input.path' '.tool_input.target' '.file_path' '.path'; do
-    file=$(printf '%s' "$INPUT" | jq -r "${field} // empty" 2>/dev/null)
-    [ -n "$file" ] && break
-  done
-  [ -n "$file" ] || exit 0
-  FILES="$file"
+  if [ "${DF_ENV_CODE:-envelope-missing}" != contract-missing ]; then
+    ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure pre-implementation-gate envelope-missing ) >/dev/null 2>&1 || true
+  fi
+  if [[ "${DOFLOW_AGENT:-}" =~ ^[a-z]+$ ]]; then printf '[pre-implementation-gate] DoFlow hooks out of step; run: doflow update -t %s\n' "$DOFLOW_AGENT" >&2; else printf '[pre-implementation-gate] DoFlow hooks out of step; run: doflow update\n' >&2; fi
+  doflow_decide deny "${DF_ENV_CODE:-envelope-missing}"
+  exit 2
 fi
 
-fi  # end legacy union decoder
-
 # ── Resolve repo root ───────────────────────────────────────────────────────
 # DOFLOW_PROJECT_DIR (explicit) beats the envelope's projectRoot beats git discovery.
 ROOT="${DOFLOW_PROJECT_DIR:-$ENVELOPE_ROOT}"
@@ -149,13 +140,11 @@ RESOLVER_CANDIDATES=(
   "$ROOT/.doflow/scripts/doflow/bash/do-paths.sh"
   "$ROOT/.claude/scripts/doflow/bash/do-paths.sh"
   "$ROOT/.codex/scripts/doflow/bash/do-paths.sh"
-  "$ROOT/.gemini/scripts/doflow/bash/do-paths.sh"
   "$ROOT/.kiro/scripts/doflow/bash/do-paths.sh"
   "$HOME/.doflow/scripts/doflow/bash/do-paths.sh"
   "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/scripts/doflow/bash/do-paths.sh"
   "${CLAUDE_PROJECT_DIR:-}/.claude/scripts/doflow/bash/do-paths.sh"
   "${CODEX_HOME:-$HOME/.codex}/scripts/doflow/bash/do-paths.sh"
-  "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/scripts/doflow/bash/do-paths.sh"
   "$HOME/.kiro/scripts/doflow/bash/do-paths.sh"
 )
 
@@ -173,11 +162,14 @@ has_plan=""
 if [ -n "$RESOLVER" ]; then
   json=$("$RESOLVER" --json 2>/dev/null) || json=""
   if [ -n "$json" ]; then
-    feature_dir=$(printf '%s' "$json"     | jq -r '.feature_dir // empty' 2>/dev/null)
-    repo_root=$(printf '%s' "$json"       | jq -r '.repo_root // empty' 2>/dev/null)
-    has_requirement=$(printf '%s' "$json" | jq -r '.has_requirement // false' 2>/dev/null)
-    has_design=$(printf '%s' "$json"      | jq -r '.has_design // false' 2>/dev/null)
-    has_plan=$(printf '%s' "$json"        | jq -r '.has_plan // false' 2>/dev/null)
+    # One jq run for all five fields, one per line (none of them can hold a newline).
+    {
+      IFS= read -r feature_dir
+      IFS= read -r repo_root
+      IFS= read -r has_requirement
+      IFS= read -r has_design
+      IFS= read -r has_plan
+    } < <(printf '%s' "$json" | jq -r '(.feature_dir // ""), (.repo_root // ""), (.has_requirement // false), (.has_design // false), (.has_plan // false)' 2>/dev/null) || true
   fi
 fi
 
@@ -257,18 +249,41 @@ real_path() {
 repo_real=$(cd -P "$repo_root" 2>/dev/null && pwd) || repo_real="$repo_root"
 
 # Only source files inside this repo are gated: edits to doflow artifacts are
-# always allowed, and an absolute path elsewhere is not this repo's.
+# always allowed, an absolute path elsewhere is not this repo's, and neither is a
+# path git ignores.
 GATED=false
 while IFS= read -r file; do
   [ -z "$file" ] && continue
-  case "$file" in *"/agent-docs/"*|agent-docs/*) continue ;; esac
+  # A ".." segment can lead out of agent-docs (agent-docs/../src/x), so such a path is judged by
+  # its real path below, never by the text before the "..".
+  case "/$file/" in
+    */../*) ;;
+    *) case "$file" in *"/agent-docs/"*|agent-docs/*) continue ;; esac ;;
+  esac
+  check="$file"
   case "$file" in
     /*)
       real=$(real_path "$file") || real="$file"
-      case "$real" in *"/agent-docs/"*) continue ;; esac
+      case "/$real/" in */../*) ;; *) case "$real" in *"/agent-docs/"*) continue ;; esac ;; esac
       case "$real" in "$repo_real"/*) ;; *) continue ;; esac
+      check="$real"
+      ;;
+    *)
+      real=$(real_path "$repo_root/$file") || real="$repo_root/$file"
+      # real_path folds a ".." only through directories that exist, so one left in it is not folded.
+      case "/$file/" in */../*) case "/$real/" in */../*) ;; *) case "${real#"$repo_real"}/" in */agent-docs/*) continue ;; esac ;; esac ;; esac
       ;;
   esac
+  # A path git ignores (a local config file such as .mcp.json) is not source. check-ignore
+  # without --no-index answers "not ignored" for a tracked file, so tracked source stays gated.
+  # The skip never applies to DoFlow's own state or gate artifacts: .doflow/ is gitignored, and
+  # skipping it would let an edit forge a readiness record. Any `.doflow` or `agent-docs/doflow`
+  # segment of the real path, or of the path as written (a `..` the resolver could not fold), keeps it gated.
+  # The same holds for the do-paths.sh resolver the gate runs (any RESOLVER_CANDIDATES path, whichever
+  # harness directory holds it, ignored or not): rewriting it can make the gate find no feature.
+  case "/$file/" in */.doflow/*|*/agent-docs/doflow/*|*/../*|*/scripts/doflow/bash/do-paths.sh/) GATED=true; break ;; esac
+  case "${real#"$repo_real"}/" in */.doflow/*|*/agent-docs/doflow/*|*/scripts/doflow/bash/do-paths.sh/) GATED=true; break ;; esac
+  git -C "$repo_root" check-ignore -q -- "$check" 2>/dev/null && continue
   GATED=true
   break
 done <<< "$FILES"
@@ -314,25 +329,71 @@ checkouts() {
   return 0
 }
 
-# A state file under this checkout, else under exactly one other checkout, at
-# the first of the given paths that exists in each; held in two or more others,
-# it cannot be told which is meant -> allow.
+# Whether two files hold the same bytes.
+same_bytes() {
+  if command -v cmp >/dev/null 2>&1; then cmp -s "$1" "$2"; else [ "$(cat "$1")" = "$(cat "$2")" ]; fi
+}
+
+# Whether the flat record $1 of a namespaced task may be read as feature $2's
+# (115 D-3): it names that feature (featureSlug on a run, slug on a readiness
+# record) or none. A file that does not parse names nobody.
+flat_is_ours() {
+  local named
+  named=$(jq -r '[.featureSlug, .slug] | map(select(type == "string" and . != "")) | first // empty' "$1" 2>/dev/null) || return 1
+  [ -z "$named" ] || [ "$named" = "$2" ]
+}
+
+# The task's record of store $2 (readiness | orchestration) under checkout $1,
+# keyed by feature $3 as the runtime keys it (115 C-1): <store>/<feature>/<id>.json
+# for a task id other than the feature's slug, else the flat file; the flat file
+# of a namespaced task only when it is this feature's or names none. Sets HIT.
+HIT=""
+record_in() {
+  local store="$1/.doflow/state/$2"
+  HIT=""
+  if [ -n "$3" ] && [ "$3" != "$task_id" ]; then
+    if [ -f "$store/$3/$task_id.json" ]; then HIT="$store/$3/$task_id.json"; return 0; fi
+    [ -f "$store/$task_id.json" ] && flat_is_ours "$store/$task_id.json" "$3" && HIT="$store/$task_id.json"
+    return 0
+  fi
+  [ -f "$store/$task_id.json" ] && HIT="$store/$task_id.json"
+  return 0
+}
+
+# The task's readiness record, keyed by feature $1. From a linked worktree the
+# main checkout's comes first, since every record lives there (115 IC-004), and
+# a copy at the same path here with other bytes refuses (C-3). Else this
+# checkout's, else exactly one other checkout's; held in two or more others it
+# cannot be told which is meant -> allow.
 FOUND=""
 find_state() {
-  local rel root count=0 hit
+  local root count=0 copy
   FOUND=""
-  for rel in "$@"; do
-    if [ -f "$repo_root/$rel" ]; then FOUND="$repo_root/$rel"; return 0; fi
-  done
+  if [ -f "$repo_root/.git" ]; then
+    checkouts
+    if [ -n "$MAIN" ]; then
+      record_in "$MAIN" readiness "$1"
+      if [ -n "$HIT" ]; then
+        copy="$repo_root${HIT#"$MAIN"}"
+        if [ -f "$copy" ] && ! same_bytes "$copy" "$HIT"; then
+          printf "doflow gate readiness-before-implementation: task '%s' has a readiness record in this worktree (%s) that differs from the main checkout's (%s). Next: keep one of the two and remove the other, then re-run. Nothing was changed.\n" "$task_id" "$copy" "$HIT" >&2
+          doflow_decide deny readiness-store-conflict
+          exit 2
+        fi
+        FOUND="$HIT"
+        return 0
+      fi
+    fi
+  fi
+  record_in "$repo_root" readiness "$1"
+  if [ -n "$HIT" ]; then FOUND="$HIT"; return 0; fi
   checkouts
   for root in ${OTHERS[@]+"${OTHERS[@]}"}; do
-    hit=""
-    for rel in "$@"; do
-      [ -f "$root/$rel" ] && { hit="$root/$rel"; break; }
-    done
-    [ -n "$hit" ] || continue
+    [ "$root" = "$MAIN" ] && continue
+    record_in "$root" readiness "$1"
+    [ -n "$HIT" ] || continue
     count=$((count + 1))
-    FOUND="$hit"
+    FOUND="$HIT"
   done
   [ "$count" -le 1 ] || exit 0
 }
@@ -348,18 +409,26 @@ run_feature() {
   return 0
 }
 
+# The feature the task's records are keyed by, as the runtime keys them
+# (featureSlugFor): a task id that names a feature folder in this checkout is
+# its own feature, else the branch's.
+run_key="$slug"
+[ -d "$repo_root/agent-docs/doflow/$task_id" ] && run_key="$task_id"
+
 # The task's run: this checkout's, else the one other checkout's run of the same
 # feature. A run with the same id for another feature is a different task.
 find_run() {
-  local rel=".doflow/state/orchestration/$task_id.json" root count=0
+  local root count=0
   FOUND=""
-  if [ -f "$repo_root/$rel" ]; then FOUND="$repo_root/$rel"; return 0; fi
+  record_in "$repo_root" orchestration "$run_key"
+  if [ -n "$HIT" ]; then FOUND="$HIT"; return 0; fi
   checkouts
   for root in ${OTHERS[@]+"${OTHERS[@]}"}; do
-    [ -f "$root/$rel" ] || continue
-    [ "$(run_feature "$root/$rel")" = "$slug" ] || continue
+    record_in "$root" orchestration "$run_key"
+    [ -n "$HIT" ] || continue
+    [ "$(run_feature "$HIT")" = "$run_key" ] || continue
     count=$((count + 1))
-    FOUND="$root/$rel"
+    FOUND="$HIT"
   done
   [ "$count" -le 1 ] || exit 0
 }
@@ -384,13 +453,14 @@ PLANNED=false
 # plan.md all exist. Classes that cannot be a feature skip this check.
 if [ "$exempt" = false ] && [ -n "$FEATURE_ROOT" ] && [ "$PLANNED" = false ]; then
   echo "[pre-implementation-gate] doflow gate: feature $feature_dir is missing requirement.md, design.md, or plan.md — run /do-brainstorm, /do-design, then /do-plan before editing source. (Edits under agent-docs/ are always allowed; skip the flow by removing the feature dir.)" >&2
+  doflow_decide deny missing-artifacts
   exit 2
 fi
 
 # ── Readiness ────────────────────────────────────────────────────────────────
 # The workflow registry the installed runtime reads: beside this policy in an
 # install, the source tree's own, the project's install, the global install.
-POLICY_DIR=$(cd -P "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd) || POLICY_DIR=""
+POLICY_DIR=$_DOFLOW_POLDIR
 REGISTRY=""
 for candidate in \
   "${POLICY_DIR:+$POLICY_DIR/../../../runtime/core/registry/workflows.json}" \
@@ -452,13 +522,10 @@ if [ -n "$RUN" ]; then
 fi
 
 # The record, where the runtime looks: under the feature's namespace (the run's
-# own feature when it recorded one), then flat; this checkout first.
-record_slug="${run_slug:-$slug}"
-if [ -n "$record_slug" ] && [ "$record_slug" != "$task_id" ]; then
-  find_state ".doflow/state/readiness/$record_slug/$task_id.json" ".doflow/state/readiness/$task_id.json"
-else
-  find_state ".doflow/state/readiness/$task_id.json"
-fi
+# own feature when it recorded one), then flat; the main checkout first from a
+# linked worktree, else this checkout first.
+record_slug="${run_slug:-$run_key}"
+find_state "$record_slug"
 record_state=""; record_class=""; record_at=""
 if [ -n "$FOUND" ]; then
   record_info=$(jq -r '(.state // ""), (.taskClass // ""), (.evaluatedAt // "")' "$FOUND" 2>/dev/null) || exit 0
@@ -480,16 +547,19 @@ gate="doflow gate readiness-before-implementation: task '$task_id'"
 rest="Next: $next, then gather what it lists until it reports READY. Nothing was changed."
 if [ -z "$FOUND" ]; then
   printf "%s has no readiness record for the '%s' template. %s\n" "$gate" "$STAGE_TEMPLATE" "$rest" >&2
+  doflow_decide deny readiness-missing
   exit 2
 fi
 if [ "$record_state" != READY ]; then
   printf "%s was last evaluated %s at %s against the '%s' template, not READY. %s\n" \
     "$gate" "$record_state" "$record_at" "$STAGE_TEMPLATE" "$rest" >&2
+  doflow_decide deny readiness-not-ready
   exit 2
 fi
 if [ "$record_class" != "$STAGE_TEMPLATE" ]; then
   printf "%s has a READY record for the '%s' template, and this stage needs '%s'. %s\n" \
     "$gate" "$record_class" "$STAGE_TEMPLATE" "$rest" >&2
+  doflow_decide deny readiness-wrong-template
   exit 2
 fi
 

package/core/harnesses/shared/hooks/policies/session-context.sh

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+case "${OSTYPE:-}" in msys*|cygwin*|win32*) if command -v jq >/dev/null 2>&1; then jq() { command jq -b "$@"; }; fi ;; esac # native jq.exe ends lines with CRLF unless -b
+_DOFLOW_SRC=${0//\\//}; case $_DOFLOW_SRC in */*) _DOFLOW_POLDIR=${_DOFLOW_SRC%/*} ;; *) _DOFLOW_POLDIR=. ;; esac
 # session-context.sh — Canonical Policy Library: SessionStart guard policy
 #
 # Fires when a harness starts a new session. Captures git state into a
@@ -11,29 +13,85 @@
 # Canonical Policy Script Contract (design.md §4):
 #   env    DOFLOW_PROJECT_DIR, DOFLOW_AGENT (both optional here; DOFLOW_AGENT
 #          only affects the "last_agent" field recorded in meta.json)
-#   stdin  the harness's native SessionStart JSON payload — must expose at
-#          least ".session_id" and ".cwd"
+#   stdin  envelope v1 from the native SessionStart payload, including
+#          the session_id and cwd fields used by this policy.
 #   exit   this policy never denies — it always exits 0 (side-effect only)
 #
 # Depends on lib.sh (require_jq, json_field, ensure_session_dir,
 # ensure_project_dir, cwd_hash, run_with_timeout, $SESSIONS_LOG) being
 # discoverable next to this script when it runs — a front door invoking this
 # canonical script is responsible for making lib.sh resolvable via
-# "$(dirname "$0")/lib.sh", exactly as every harness's own SessionStart script
+# the sibling lib.sh, exactly as every harness's own SessionStart script
 # already required before this policy moved to a shared location.
 
 set -euo pipefail
 # shellcheck source=lib.sh
-source "$(dirname "$0")/lib.sh"
-require_jq
-
+source "$_DOFLOW_POLDIR/lib.sh"
 INPUT=$(cat)
-SESSION_ID=$(json_field "$INPUT" ".session_id")
+POLICY_DIR=$_DOFLOW_POLDIR
+if [ -f "$POLICY_DIR/contract.sh" ]; then
+  # shellcheck source=contract.sh
+  source "$POLICY_DIR/contract.sh"
+  doflow_decision_init session-context 1
+else
+  doflow_decision_init() { :; }
+  doflow_decide() { :; }
+  ( . "$POLICY_DIR/capture-failure.sh"; doflow_capture_failure session-context contract-missing ) >/dev/null 2>&1 || true
+  exit 0
+fi
+if ! command -v jq >/dev/null 2>&1; then
+  doflow_decide error dependency-missing:jq
+  ( . "$POLICY_DIR/capture-failure.sh"; doflow_capture_failure session-context dependency-missing:jq ) >/dev/null 2>&1 || true
+fi
+require_jq
+SESSION_ID="" ENVELOPE_CLASS=missing
+{ IFS= read -r -d '' ENVELOPE_CLASS; IFS= read -r -d '' SESSION_ID; } < <(
+  printf '%s' "$INPUT" | jq -j 'if ((. | type) != "object") or ((.doflow_event | type) != "object") or ((.doflow_event | has("version")) | not) then "missing" elif ((.doflow_event.version | type) == "number") and .doflow_event.version == 1 then "v1" else "unsupported" end, "\u0000", (.session_id // "" | if type == "string" then rtrimstr("\n") else tojson end), "\u0000"' 2>/dev/null
+) || true
+ENVELOPE_CLASS=${ENVELOPE_CLASS:-missing}
+if [ ! -f "$POLICY_DIR/contract.sh" ]; then ENVELOPE_CLASS=missing; fi
+if [ "$ENVELOPE_CLASS" = unsupported ] || [ "$ENVELOPE_CLASS" = missing ]; then
+  code=envelope-version
+  [ "$ENVELOPE_CLASS" = missing ] && code=envelope-missing
+  [ -f "$POLICY_DIR/contract.sh" ] || code=contract-missing
+  doflow_decide unsupported "$code"
+  if [ -f "$POLICY_DIR/contract.sh" ]; then
+    ( . "$_DOFLOW_POLDIR/capture-failure.sh"; doflow_capture_failure session-context "$code" ) >/dev/null 2>&1 || true
+  fi
+  exit 0
+fi
 CWD=$(json_field "$INPUT" ".cwd")
 
+package_verify_async() {
+  local home="${HOME:-}" lock run config_dir detach=""
+  [ -n "$home" ] || return 0
+  lock="$home/.doflow/doflow.lock"
+  [ -f "$lock" ] || return 0
+  jq -e '(.packages // []) | length > 0' "$lock" >/dev/null 2>&1 || return 0
+  config_dir="${CLAUDE_CONFIG_DIR:-$home/.claude}"
+  command -v setsid >/dev/null 2>&1 && detach="setsid"
+  for run in \
+    "$home/.doflow/scripts/doflow/bin/doflow-run" \
+    "$config_dir/scripts/doflow/bin/doflow-run"
+  do
+    [ -x "$run" ] || continue
+    ( cd "$home/.doflow" 2>/dev/null && nohup $detach "$run" package --action verify </dev/null >/dev/null 2>&1 ) >/dev/null 2>&1 3>&- 5>&- &
+    return 0
+  done
+  return 0
+}
+
 # Guard: if we can't determine the session, nothing to do
 [[ -z "$SESSION_ID" ]] && exit 0
 
+# No config home (lib.sh leaves the state paths empty): no session store to write, but the
+# storage upkeep still starts (086 IC-010).
+if [[ -z "$SESSION_DIR" ]]; then
+  package_verify_async
+  storage_upkeep_async "$CWD"
+  exit 0
+fi
+
 SESSION_PATH=$(ensure_session_dir "$SESSION_ID")
 
 # Clean up stale injected flag from a prior crashed session
@@ -137,5 +195,6 @@ fi
 mkdir -p "$(dirname "$SESSIONS_LOG")"
 echo "$TIMESTAMP START $SESSION_ID ${CWD:-unknown}" >> "$SESSIONS_LOG"
 
+package_verify_async
 storage_upkeep_async "$CWD"
 exit 0