loki-mode 9.22.4 → 9.22.6

package/README.md

@@ -70,9 +70,16 @@ Choose an exact shipped starter when the top-ranked match is not the one you
 want:
 
 ```bash
+loki quickstart --list-templates
+loki quickstart --list-templates --json       # schema-v1 automation output
 loki quickstart "an internal reporting workspace" --template dashboard --yes
 ```
 
+Template discovery works without a terminal or provider and lists every shipped
+starter's stable name and purpose in catalog order. It returns before estimation,
+consent, PRD writes, or build execution. Positional input and execution/preview
+flags are intentionally incompatible; `--json` is the only optional modifier.
+
 `--template` accepts an exact template name for idea inputs and works the same
 way with interactive use or `--dry-run` (including JSON preview). Unknown
 templates, duplicate flags, and combinations with a PRD path refuse before
@@ -93,13 +100,20 @@ For scripts and local dashboards, add `--json` to receive one versioned JSON
 object instead of terminal text:
 
 ```bash
-loki quickstart "a todo app with user accounts" --dry-run --json
+loki quickstart "a todo app with user accounts" --dry-run --json > preview.json
+loki quickstart --from-preview preview.json --yes
 ```
 
 The object contains the input kind, deterministic selected template (or `null`
-for an existing PRD), and the exact estimator response under `plan`. `--json`
-requires `--dry-run`; invalid input or estimator failure writes no JSON, and the
-command still exits before provider discovery, file writes, or build execution.
+for an existing PRD), the exact estimator response under `plan`, and a bounded
+continuation containing the exact idea/template or the PRD path and SHA-256.
+`--from-preview` requires explicit argv `--yes`, rejects malformed, conflicting,
+symlinked, or changed inputs before provider and build boundaries, then uses the
+existing no-clobber quickstart path. The saved plan is evidence rather than
+execution authority: Loki recomputes and displays the current estimate before
+starting. `--json` requires `--dry-run`; invalid input or estimator failure
+writes no JSON, and preview still exits before provider discovery, file writes,
+or build execution.
 
 Or go straight at it:
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 8 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v9.22.4
+# Loki Mode v9.22.6
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -470,4 +470,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v9.22.4 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v9.22.6 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-9.22.4
+9.22.6

package/autonomy/issue-parser.sh

@@ -247,6 +247,110 @@ extract_type_from_labels() {
 #===============================================================================
 
 # Parse a GitHub issue and output structured data
+#===============================================================================
+# Golden path: issue context + early plan
+#===============================================================================
+
+# Split the extracted acceptance-criteria blob into one normalized item per
+# line. Keeps ONLY genuine list items (checkbox / bullet / numbered) so a
+# section heading or a stray prose line never becomes a fake "criterion".
+# Prints nothing when there is nothing to print -- an empty criteria list is a
+# truthful answer, and inventing one would poison every downstream coverage
+# claim.
+_gp_criteria_lines() {
+    printf '%s\n' "${1:-}" \
+        | sed -E 's/^[[:space:]]*[-*][[:space:]]*\[[ xX]\][[:space:]]*//; s/^[[:space:]]*[-*][[:space:]]+//; s/^[[:space:]]*[0-9]+[.)][[:space:]]+//' \
+        | grep -vE '^[[:space:]]*$' \
+        | grep -vE '^[[:space:]]*-{3,}[[:space:]]*$'
+}
+
+# write_journey_context <owner> <repo> <number> <title> <url> <acceptance>
+#                       <files> <type> <priority>
+#
+# Writes .loki/state/issue-context.json (feature 2: the exact acceptance context)
+# and .loki/state/journey-plan.json (feature 3: the early machine-readable
+# status/plan). Both are written from `gh` output BEFORE the first provider
+# call, so the early artifact is deterministic rather than latency-dependent.
+#
+# Never fails the caller: every write is best-effort and the function always
+# returns 0. Honors LOKI_DIR so a test can point it at a scratch directory.
+write_journey_context() {
+    local owner="$1" repo="$2" number="$3" title="$4" url="$5"
+    local acceptance="$6" files="$7" issue_type="$8" priority="$9"
+
+    local state_dir="${LOKI_DIR:-.loki}/state"
+    mkdir -p "$state_dir" 2>/dev/null || return 0
+
+    local criteria
+    criteria=$(_gp_criteria_lines "$acceptance")
+
+    # jq builds both documents so quoting/escaping is handled once, correctly.
+    command -v jq >/dev/null 2>&1 || return 0
+
+    local ctx_tmp="$state_dir/.issue-context.$$.json"
+    if jq -n \
+        --arg owner "$owner" --arg repo "$repo" --arg number "$number" \
+        --arg title "$title" --arg url "$url" --arg criteria "$criteria" \
+        --arg files "$files" --arg type "$issue_type" --arg priority "$priority" \
+        --arg captured_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{
+            schema_version: "1.0",
+            captured_at: $captured_at,
+            issue: {
+                owner: $owner, repo: $repo,
+                number: (try ($number | tonumber) catch null),
+                ref: ($owner + "/" + $repo + "#" + $number),
+                url: $url, title: $title,
+                type: $type, priority: $priority
+            },
+            acceptance_criteria: (
+                if ($criteria | length) == 0 then []
+                else ($criteria | split("\n") | map(select(length > 0)))
+                end
+            ),
+            file_references: (
+                if ($files | length) == 0 then []
+                else ($files | split("\n") | map(select(length > 0)))
+                end
+            )
+        }' > "$ctx_tmp" 2>/dev/null; then
+        mv -f "$ctx_tmp" "$state_dir/issue-context.json" 2>/dev/null || rm -f "$ctx_tmp"
+    else
+        rm -f "$ctx_tmp" 2>/dev/null || true
+    fi
+
+    # The early plan is a PLAN, not a result: it states what was understood and
+    # what will be attempted. It deliberately carries no outcome fields -- a
+    # status file that guessed at outcomes before any work happened would be the
+    # exact fake-green this repo's trust core forbids.
+    local plan_tmp="$state_dir/.journey-plan.$$.json"
+    if jq -n \
+        --arg ref "$owner/$repo#$number" --arg title "$title" --arg url "$url" \
+        --arg criteria "$criteria" \
+        --arg generated_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{
+            schema_version: "1.0",
+            command: "loki start",
+            mode: "issue",
+            stage: "planned",
+            generated_at: $generated_at,
+            issue: { ref: $ref, title: $title, url: $url },
+            acceptance_criteria: (
+                if ($criteria | length) == 0 then []
+                else ($criteria | split("\n") | map(select(length > 0)))
+                end
+            ),
+            provider_invoked: false,
+            next: "implement, verify, then review-ready result with evidence receipt"
+        }' > "$plan_tmp" 2>/dev/null; then
+        mv -f "$plan_tmp" "$state_dir/journey-plan.json" 2>/dev/null || rm -f "$plan_tmp"
+    else
+        rm -f "$plan_tmp" 2>/dev/null || true
+    fi
+
+    return 0
+}
+
 parse_github_issue() {
     local issue_ref="$1"
     local output_format="${2:-yaml}"  # yaml or json
@@ -303,6 +407,14 @@ parse_github_issue() {
     priority=$(extract_priority_from_labels "$labels_json")
     issue_type=$(extract_type_from_labels "$labels_json")
 
+    # Golden path (feature 2): persist the EXACT criteria we just extracted, plus
+    # the early machine-readable plan (feature 3), before any provider call. Both
+    # are derived from `gh` output only, so the early artifact does not depend on
+    # provider latency at all. Best-effort: a failure here must never break issue
+    # parsing, which is why it is guarded and ignores its own exit status.
+    write_journey_context "$owner" "$repo" "$number" "$title" "$url" \
+        "$acceptance_criteria" "$file_references" "$issue_type" "$priority" || true
+
     # Output based on format
     if [ "$output_format" = "json" ]; then
         output_json "$owner" "$repo" "$number" "$title" "$body" "$problem_statement" \

package/autonomy/lib/proof-generator.py

@@ -990,6 +990,78 @@ def _collect_iterations(loki_dir):
     return {"count": count, "succeeded": n_completed, "failed": n_failed}
 
 
+def _collect_journey(loki_dir):
+    """Issue-to-PR journey facts (golden path features 4 and 10).
+
+    Descriptive record half ONLY. Like `functional` and `healthcheck`, this is
+    NOT read by _compute_headline / _compute_degraded: nothing here can turn a
+    receipt green or make a blocked run look finished.
+
+    Every field is absent-not-zero. A measurement that did not happen renders
+    nothing rather than a fabricated 0, matching run.sh:4258 ("a wrong timing
+    table is worse than silence"). Returns {} when this run was not an
+    issue-mode run, so a PRD/brief run's proof bytes are unchanged.
+    """
+    state = os.path.join(loki_dir, "state")
+    ctx = _read_json(os.path.join(state, "issue-context.json"), default=None)
+    if not isinstance(ctx, dict):
+        return {}
+
+    issue = ctx.get("issue") if isinstance(ctx.get("issue"), dict) else {}
+    stated = ctx.get("acceptance_criteria")
+    stated = [str(c) for c in stated] if isinstance(stated, list) else []
+
+    out = {
+        "issue": {
+            "ref": str(issue.get("ref") or ""),
+            "url": str(issue.get("url") or ""),
+            "title": str(issue.get("title") or ""),
+        },
+        # Coverage is a CORRESPONDENCE, not a verdict. There is no deterministic
+        # checker for free-text criteria, so we report what the issue stated and
+        # decline to claim any of it was satisfied. `addressed` is deliberately
+        # null rather than 0: 0 would read as "none met", which we do not know.
+        "acceptance": {
+            "stated": stated,
+            "stated_count": len(stated),
+            "addressed_count": None,
+            "basis": "criteria imported verbatim from the issue; no "
+                     "deterministic checker exists for free-text criteria, so "
+                     "this receipt reports what was ASKED, never what was met",
+        },
+    }
+
+    # Time to first useful result. Reuses the number run.sh already writes; we
+    # do not add a second writer and we never synthesize the value.
+    fa = _read_json(os.path.join(state, "first-artifact.json"), default=None)
+    if isinstance(fa, dict):
+        v = fa.get("seconds_to_first_artifact")
+        if isinstance(v, (int, float)) and v >= 0:
+            out["time_to_first_result_sec"] = int(v)
+
+    # Human interventions. Fills the socket trust_trajectory.py:145 already
+    # reads and documents as "no per-run counter persisted today". Absent file
+    # means unmeasured, NOT zero -- claiming a confident 0 would overstate
+    # autonomy, which is the one direction this number must never err in.
+    iv = _read_json(os.path.join(state, "interventions.json"), default=None)
+    if isinstance(iv, dict):
+        n = iv.get("count")
+        if isinstance(n, int) and n >= 0:
+            out["interventions"] = n
+
+    # PR state/URL, written by the consent-gated PR step. "prepared" means a PR
+    # body exists locally and GitHub was NOT mutated.
+    pr = _read_json(os.path.join(state, "pr.json"), default=None)
+    if isinstance(pr, dict) and pr.get("state"):
+        out["pull_request"] = {
+            "state": str(pr.get("state")),
+            "url": str(pr.get("url") or ""),
+            "branch": str(pr.get("branch") or ""),
+        }
+
+    return out
+
+
 def _collect_spec(loki_dir, target_dir):
     """Return spec dict {source, brief}. brief truncated to 600 chars."""
     prd_path = os.environ.get("PRD_PATH", "").strip()
@@ -1158,6 +1230,7 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
     healthcheck = _collect_healthcheck(loki_dir)  # Evidence Receipt record-half
     evidence_gate = _collect_evidence_gate(loki_dir)
     functionality = _collect_functionality(loki_dir)  # func axes as HONEST facts
+    journey = _collect_journey(loki_dir)  # issue-to-PR record half; {} when N/A
 
     deployed_url = os.environ.get("LOKI_DEPLOYED_URL") or None
 
@@ -1238,6 +1311,12 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
         },
     }
 
+    # Issue-to-PR journey facts, attached ONLY on an issue-mode run so a PRD or
+    # brief run's proof bytes stay exactly as they were. Record half: descriptive
+    # only, never read by _compute_headline / _compute_degraded.
+    if journey:
+        facts["journey"] = journey
+
     # ASSESSMENTS: LLM opinions. Explicitly labeled as judgment, NOT proof. A
     # green council verdict is an opinion that can be wrong or gamed; it never
     # contributes to the deterministic headline.
@@ -1351,6 +1430,15 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
         "assessments": assessments,
         "honesty": honesty,
     }
+
+    # Top-level mirror for the intervention axis. trust_trajectory.py:145 already
+    # reads proof["interventions"] and documents that no writer exists yet; this
+    # is that writer. Mirrored (not moved) for the same back-compat reason the
+    # other flat keys are mirrored. Only ever set when actually measured, so the
+    # axis stays honestly "unavailable" rather than showing a fabricated zero.
+    if isinstance(journey, dict) and isinstance(journey.get("interventions"), int):
+        proof["interventions"] = journey["interventions"]
+
     return proof, run_id
 
 

package/autonomy/lib/proof-pr.sh

@@ -206,6 +206,58 @@ def main():
         _line("| Gates disabled | " + ", ".join(sorted(_off)) + " |")
     _line("| Base sha | `" + (base_sha or "(none)") + "` |")
     _line("| Head sha | `" + (head_sha or "(none)") + "` |")
+
+    # Issue-to-PR journey rows. Emitted ONLY on an issue-mode run, and each row
+    # ONLY when that fact was actually measured -- an unmeasured number renders
+    # no row rather than a zero, the same rule the rest of this receipt follows.
+    journey = facts.get("journey") if isinstance(facts.get("journey"), dict) else {}
+    if journey:
+        jissue = journey.get("issue") if isinstance(journey.get("issue"), dict) else {}
+        jref = str(jissue.get("ref") or "").strip()
+        jurl = str(jissue.get("url") or "").strip()
+        if jref:
+            _line("| Issue | " + (("[" + jref + "](" + jurl + ")") if jurl else jref) + " |")
+
+        ttfr = journey.get("time_to_first_result_sec")
+        if isinstance(ttfr, int):
+            _line("| Time to first result | " + str(ttfr) + "s |")
+
+        ivs = journey.get("interventions")
+        if isinstance(ivs, int):
+            _line("| Human interventions | " + str(ivs) + " |")
+
+        acc = journey.get("acceptance") if isinstance(journey.get("acceptance"), dict) else {}
+        n_stated = acc.get("stated_count")
+        if isinstance(n_stated, int):
+            # Reported as ASKED, never as met. addressed_count is null by design
+            # (no deterministic checker for free-text criteria), so this row must
+            # never be phrased as coverage or a pass -- that would be the exact
+            # fake-green the headline rules forbid.
+            _line("| Acceptance criteria | " + str(n_stated)
+                  + " stated in the issue (not machine-verified) |")
+
+        pr = journey.get("pull_request") if isinstance(journey.get("pull_request"), dict) else {}
+        pr_state = str(pr.get("state") or "").strip()
+        if pr_state:
+            pr_url = str(pr.get("url") or "").strip()
+            _line("| Pull request | " + pr_state + ((" -- " + pr_url) if pr_url else "") + " |")
+
+        # Rollback: derived from the base sha this run started at, so the reader
+        # gets a runnable command rather than a promise. Only emitted when the
+        # base is actually known.
+        if base_sha:
+            _line("| Rollback | `git reset --hard " + base_sha + "` |")
+
+        # Uncertainty: the honest count of checks that did NOT conclusively pass,
+        # read from the SAME honesty.degraded[] the headline is computed from, so
+        # it can never disagree with the verdict above it.
+        _degraded = honesty.get("degraded")
+        _degraded = _degraded if isinstance(_degraded, list) else []
+        if effective_headline == "VERIFIED" and not _degraded:
+            _line("| Uncertainty | none recorded; every check that ran concluded |")
+        elif _degraded:
+            _line("| Uncertainty | " + str(len(_degraded))
+                  + " check(s) not conclusive -- see the list below |")
     _line()
 
     # Gaps: when headline != VERIFIED, list honesty.degraded[] verbatim. By

package/autonomy/loki

@@ -2583,6 +2583,14 @@ cmd_start() {
                 issue_mode_args+=("--pr")
                 shift
                 ;;
+            --prepare-pr)
+                # Feature 1: the SAME `loki start <issue>` entrypoint carries the
+                # prepare-only flag through to cmd_run. Does not set
+                # issue_create_pr -- preparing is not publishing.
+                issue_use_worktree=true
+                issue_mode_args+=("--prepare-pr")
+                shift
+                ;;
             --ship)
                 issue_use_worktree=true
                 issue_create_pr=true
@@ -9734,6 +9742,7 @@ cmd_run() {
     local provider_override=""
     local use_worktree=false
     local create_pr=false
+    local prepare_pr=false
     local auto_merge=false
     local run_detached=false
 
@@ -9772,6 +9781,8 @@ cmd_run() {
                 echo "Progressive Isolation:"
                 echo "  --worktree, -w     Git worktree isolation (separate branch)"
                 echo "  --pr               Worktree + auto-create PR (implies --worktree)"
+                echo "  --prepare-pr       Worktree + write a review-ready PR title/body"
+                echo "                     locally; never contacts GitHub (implies --worktree)"
                 echo "  --ship             Worktree + PR + auto-merge (implies --pr)"
                 echo "  --detach, -d       Run in background (implies --worktree)"
                 echo ""
@@ -9888,6 +9899,15 @@ cmd_run() {
                 create_pr=true
                 shift
                 ;;
+            --prepare-pr)
+                # Golden path (feature 9): produce a review-ready PR WITHOUT any
+                # GitHub mutation. Writes the title/body to .loki/state/ and
+                # records state="prepared" for the receipt. Deliberately does not
+                # set create_pr: consent to prepare is not consent to publish.
+                use_worktree=true
+                prepare_pr=true
+                shift
+                ;;
             --ship)
                 use_worktree=true
                 create_pr=true
@@ -9971,6 +9991,21 @@ cmd_run() {
     fi
     source "$issue_providers_script"
 
+    # Golden path: also source issue-parser.sh for write_journey_context and
+    # extract_acceptance_criteria. Optional -- a missing file must never break a
+    # run, so this is guarded rather than fatal like the block above.
+    #
+    # issue-parser.sh sets `set -euo pipefail` at the top, which would otherwise
+    # LEAK into cmd_run and abort the CLI on the first benign non-zero. We
+    # snapshot the current options and restore them immediately after sourcing.
+    local _gp_parser_script="$SKILL_DIR/autonomy/issue-parser.sh"
+    if [[ -f "$_gp_parser_script" ]]; then
+        local _gp_saved_opts
+        _gp_saved_opts=$(set +o)
+        source "$_gp_parser_script" 2>/dev/null || true
+        eval "$_gp_saved_opts" 2>/dev/null || true
+    fi
+
     # Detect provider
     local issue_provider
     issue_provider=$(detect_issue_provider "$issue_ref")
@@ -9996,6 +10031,38 @@ cmd_run() {
     fi
     echo ""
 
+    # Golden path (features 2 + 3): capture the EXACT acceptance context and the
+    # early machine-readable plan here, at the real `loki start <issue>`
+    # chokepoint, BEFORE any provider call.
+    #
+    # This is deliberately hooked to fetch_issue rather than to
+    # issue-parser.sh's parse_github_issue: `loki start` routes through
+    # fetch_issue (issue-providers.sh:333), while parse_github_issue serves only
+    # the DEPRECATED `loki issue parse|view` commands. Hooking the parser alone
+    # would leave the required path with no context written at all. fetch_issue
+    # is also provider-agnostic, so gitlab/jira/azure get the same artifacts.
+    #
+    # Best-effort: never allowed to break the run.
+    if declare -f write_journey_context >/dev/null 2>&1; then
+        # owner/repo come from the NORMALIZED json's `repo` field ("owner/name"),
+        # not from ISSUE_OWNER/ISSUE_REPO: those globals are re-cleared by any
+        # later parse_issue_reference call, which yielded a "/#42" ref here.
+        # Every provider populates `repo`, so this stays provider-agnostic.
+        local _gp_owner="" _gp_repo="" _gp_acc="" _gp_body="" _gp_repo_ref=""
+        _gp_repo_ref=$(printf '%s' "$issue_json" | python3 -c \
+            "import json,sys; print(json.loads(sys.stdin.read()).get('repo','') or '')" 2>/dev/null || true)
+        _gp_owner="${_gp_repo_ref%%/*}"
+        _gp_repo="${_gp_repo_ref#*/}"
+        [ "$_gp_owner" = "$_gp_repo_ref" ] && _gp_repo=""
+        _gp_body=$(printf '%s' "$issue_json" | python3 -c \
+            "import json,sys; print(json.loads(sys.stdin.read()).get('body','') or '')" 2>/dev/null || true)
+        if declare -f extract_acceptance_criteria >/dev/null 2>&1; then
+            _gp_acc=$(extract_acceptance_criteria "$_gp_body" 2>/dev/null || true)
+        fi
+        write_journey_context "$_gp_owner" "$_gp_repo" "${number:-}" "$title" \
+            "$url" "$_gp_acc" "" "${issue_provider:-github}" "" 2>/dev/null || true
+    fi
+
     # Per-session locking (v6.4.0): export session ID so run.sh uses
     # per-session PID/lock files instead of the global lock. This allows
     # multiple concurrent `loki run` sessions (e.g., loki run 52 -d && loki run 54 -d).
@@ -10190,7 +10257,71 @@ INNER_SCRIPT_EOF
     else
         echo ""
         echo -e "${GREEN}Starting Loki Mode with generated PRD...${NC}"
-        cmd_start "$output_file" ${start_args[@]+"${start_args[@]}"}
+        # cmd_start EXEC-replaces this process (loki:3490
+        # _loki_new_session_exec), so ANY code after a bare call is unreachable
+        # -- which is why the --pr block below has never run on this path and
+        # why the detached route at ~:10088 reimplements PR creation instead of
+        # sharing it. Verified empirically, not inferred.
+        #
+        # Only --prepare-pr subshells the runner, so the exec replaces the CHILD
+        # and control returns here. The default path keeps the bare call
+        # untouched: subshelling everything would change signal delivery and
+        # Ctrl+C semantics for every existing user, which this slice must not do.
+        if $prepare_pr && ! $create_pr; then
+            ( cmd_start "$output_file" ${start_args[@]+"${start_args[@]}"} )
+        else
+            cmd_start "$output_file" ${start_args[@]+"${start_args[@]}"}
+        fi
+
+        # Golden path (feature 9): prepare-only. Builds the SAME review-ready
+        # title/body the --pr path would publish, writes it to .loki/state/, and
+        # records state="prepared" for the receipt -- without ever invoking gh.
+        # Consent to prepare is not consent to publish, so this branch is
+        # deliberately separate from create_pr and never falls through to it.
+        if $prepare_pr && ! $create_pr; then
+            echo ""
+            echo -e "${GREEN}Preparing pull request (no GitHub changes)...${NC}"
+            local _pp_title="${title:-Implementation for issue ${issue_ref}}"
+            local _pp_branch
+            _pp_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+            local _pp_body="Implemented by Loki Mode (autonomous agent)
+
+Issue: ${issue_ref}
+Provider: ${issue_provider}
+
+## Changes
+$(git log --oneline "main..HEAD" 2>/dev/null || echo "See diff")"
+
+            # Same receipt the published path appends, so a prepared PR body is
+            # byte-for-byte what would be posted. Print-only and honesty-gated.
+            if [ "${LOKI_PROVEN_PR:-1}" != "0" ] && declare -f render_evidence_receipt_md >/dev/null 2>&1; then
+                local _pp_idfile=".loki/state/last-proof-id.txt"
+                if [ -s "$_pp_idfile" ]; then
+                    local _pp_rid=""
+                    _pp_rid="$(cat "$_pp_idfile" 2>/dev/null || true)"
+                    if [ -n "$_pp_rid" ] && [ -f ".loki/proofs/$_pp_rid/proof.json" ]; then
+                        local _pp_receipt=""
+                        _pp_receipt="$(render_evidence_receipt_md ".loki/proofs/$_pp_rid/proof.json" "" "" 2>/dev/null || true)"
+                        [ -n "$_pp_receipt" ] && _pp_body="${_pp_body}
+
+${_pp_receipt}"
+                    fi
+                fi
+            fi
+
+            mkdir -p .loki/state 2>/dev/null || true
+            printf '%s\n' "$_pp_title" > .loki/state/pr-title.txt 2>/dev/null || true
+            printf '%s\n' "$_pp_body" > .loki/state/pr-body.md 2>/dev/null || true
+            if command -v jq >/dev/null 2>&1; then
+                jq -n --arg branch "$_pp_branch" --arg title "$_pp_title" \
+                    '{state:"prepared", url:"", branch:$branch, title:$title,
+                      body_path:".loki/state/pr-body.md",
+                      note:"written locally; GitHub was not contacted"}' \
+                    > .loki/state/pr.json 2>/dev/null || true
+            fi
+            echo -e "${GREEN}PR prepared${NC} -- review .loki/state/pr-body.md"
+            echo -e "${DIM}Publish it yourself: gh pr create --title \"\$(cat .loki/state/pr-title.txt)\" --body-file .loki/state/pr-body.md${NC}"
+        fi
 
         # Progressive isolation: create PR
         if $create_pr; then
@@ -10234,9 +10365,22 @@ ${_gh_receipt}"
                         branch_current=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
                         if [[ -n "$branch_current" && "$branch_current" != "main" && "$branch_current" != "master" ]]; then
                             git push origin "$branch_current" 2>/dev/null || true
-                            gh pr create --title "$pr_title" --body "$pr_body" --head "$branch_current" 2>/dev/null && \
-                                echo -e "${GREEN}PR created${NC}" || \
+                            local _pr_out=""
+                            if _pr_out=$(gh pr create --title "$pr_title" --body "$pr_body" --head "$branch_current" 2>/dev/null); then
+                                echo -e "${GREEN}PR created${NC}"
+                                # Record the real outcome for the receipt. Only
+                                # written on ACTUAL success, so a failed create
+                                # can never leave a "created" claim behind.
+                                mkdir -p .loki/state 2>/dev/null || true
+                                if command -v jq >/dev/null 2>&1; then
+                                    jq -n --arg url "$(printf '%s' "$_pr_out" | grep -Eo 'https://[^[:space:]]+' | head -1)" \
+                                          --arg branch "$branch_current" \
+                                        '{state:"created", url:$url, branch:$branch}' \
+                                        > .loki/state/pr.json 2>/dev/null || true
+                                fi
+                            else
                                 echo -e "${YELLOW}PR creation failed${NC}"
+                            fi
                         fi
                     fi
                     ;;