loki-mode 11.17.100 → 11.17.102

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v11.17.100
+# Loki Mode v11.17.102
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the previous bash loop. PRD-file starts (`loki start ./prd.md`) and the opencode provider still run on it until FC38-SWEEP ports them; the legacy-engine command and the LOKI_ENGINE switch remain removed. Prefer `loki owner/repo#N` for issues.
 
@@ -483,4 +483,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v11.17.100 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.17.102 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.17.100
+11.17.102

package/autonomy/lib/engine10-push-gitlab.sh

@@ -78,8 +78,32 @@ def="$(_e10_glab api "projects/$enc" 2>/dev/null \
 
 tmp="$(mktemp -d "${TMPDIR:-/tmp}/loki-push-gl.XXXXXX")" || die "mktemp failed" 1
 trap 'rm -rf "$tmp"' EXIT
+# FC-TRUSTED-PUSH-PARTIAL-CLONE: logically equivalent to the seeding in run.sh
+# _loki_trusted_push (this child cannot source run.sh). A partial agent clone
+# cannot serve objects it never downloaded, so seed the temp repo with the
+# pinned origin as a promisor remote and fetch its refs first. The agent pack
+# is thin, so the client lazy-fetches delta bases from the origin during the
+# agent fetch; the agent-dir upload-pack (the process that reads agent config)
+# runs through env -i: no token, no helper config, no HOME, no lazy fetch.
+partial="" up=""
+if [ -n "$(git -C "$dir" config --get extensions.partialclone 2>/dev/null)" ] \
+    || git -C "$dir" config --get-regexp '^remote\..*\.promisor$' 2>/dev/null | grep -Eqi ' (true|yes|on|1)$'; then
+    partial=1
+    up="/usr/bin/env -i PATH=/usr/bin:/bin GIT_NO_LAZY_FETCH=1 $(printf '%q' "$(command -v git)") upload-pack"
+fi
 git init -q --template= "$tmp" >/dev/null 2>&1 \
-    && git -C "$tmp" fetch -q --no-tags --update-shallow "$dir" "+refs/heads/$branch:refs/heads/$branch" >/dev/null 2>&1 \
+    && { [ -z "$partial" ] || {
+        git -C "$tmp" config core.repositoryformatversion 1 \
+        && git -C "$tmp" config extensions.partialclone loki-base \
+        && git -C "$tmp" config remote.loki-base.url "$url" \
+        && git -C "$tmp" config remote.loki-base.promisor true \
+        && git -C "$tmp" config remote.loki-base.partialclonefilter blob:none \
+        && GIT_TERMINAL_PROMPT=0 git -C "$tmp" fetch -q --no-tags --filter=blob:none loki-base "+refs/heads/*:refs/remotes/loki-base/*" >/dev/null 2>&1; }; } \
+    && { if [ -n "$partial" ]; then
+        GIT_TERMINAL_PROMPT=0 git -C "$tmp" fetch -q --no-tags --update-shallow --upload-pack "$up" "$dir" "+refs/heads/$branch:refs/heads/$branch" >/dev/null 2>&1
+    else
+        git -C "$tmp" fetch -q --no-tags --update-shallow "$dir" "+refs/heads/$branch:refs/heads/$branch" >/dev/null 2>&1
+    fi; } \
     && git -C "$tmp" rev-parse -q --verify "refs/heads/$branch" >/dev/null 2>&1 \
     || die "could not stage branch '$branch' in a fresh repo"
 git -C "$tmp" push -q "$url" "refs/heads/$branch:refs/heads/$branch" || die "push failed (rc=$?)"

package/autonomy/run.sh

@@ -6071,6 +6071,7 @@ _loki_trusted_push() {
             return 2 ;;
     esac
     _repo="$(_loki_github_repo_from_url "$_url")"
+    local _origin_url="$_url"
     if [ -n "$_dest" ]; then
         if ! _loki_github_repo_from_url "https://github.com/${_dest}.git" >/dev/null; then
             log_warn "Not pushing branch '$_branch': fork destination '$_dest' is not a plain OWNER/REPO."
@@ -6088,11 +6089,41 @@ _loki_trusted_push() {
         return 2
     fi
     _tmp="$(mktemp -d "${TMPDIR:-/tmp}/loki-push.XXXXXX")" || return 1
+    # FC-TRUSTED-PUSH-PARTIAL-CLONE: a partial agent clone (extensions.partialclone,
+    # or a remote.<n>.promisor true/yes/on/1 on newer git; both read as data)
+    # holds objects it never downloaded, and upload-pack does not lazy-fetch
+    # them, so the branch fetch below dies. Seed the temp repo with the
+    # validated origin (_origin_url, captured before a fork _dest overwrites
+    # _url) as a promisor remote and fetch its refs first. The agent pack is
+    # thin (deltas against blobs the temp repo only knows by id), so the client
+    # lazy-fetches those delta bases from loki-base during the agent fetch: that
+    # fetch therefore runs under "$_runner" too. The credentials stay on the
+    # client side only: the agent-dir upload-pack, the one process that reads
+    # agent config, is started through `env -i` with no credentials, no helper
+    # config, no HOME and no lazy fetch. GIT_TERMINAL_PROMPT=0 so a refused
+    # token never waits on a username. Non-partial repos skip all of this.
+    local _partial="" _up=""
+    if [ -n "$(git -C "$_dir" config --get extensions.partialclone 2>/dev/null)" ] \
+        || git -C "$_dir" config --get-regexp '^remote\..*\.promisor$' 2>/dev/null | grep -Eqi ' (true|yes|on|1)$'; then
+        _partial=1
+        _up="/usr/bin/env -i PATH=/usr/bin:/bin GIT_NO_LAZY_FETCH=1 $(printf '%q' "$(command -v git)") upload-pack"
+    fi
     # --update-shallow: a shallow agent repo's history ends in shallow roots,
     # which a plain fetch rejects while still exiting 0. The rev-parse makes a
     # silently empty fetch fail here instead of at the push.
     if git init -q --template= "$_tmp" >/dev/null 2>&1 \
-        && git -C "$_tmp" fetch -q --no-tags --update-shallow "$_dir" "+refs/heads/$_branch:refs/heads/$_branch" >/dev/null 2>&1 \
+        && { [ -z "$_partial" ] || {
+            git -C "$_tmp" config core.repositoryformatversion 1 \
+            && git -C "$_tmp" config extensions.partialclone loki-base \
+            && git -C "$_tmp" config remote.loki-base.url "$_origin_url" \
+            && git -C "$_tmp" config remote.loki-base.promisor true \
+            && git -C "$_tmp" config remote.loki-base.partialclonefilter blob:none \
+            && GIT_TERMINAL_PROMPT=0 "$_runner" git -C "$_tmp" fetch -q --no-tags --filter=blob:none loki-base "+refs/heads/*:refs/remotes/loki-base/*" >/dev/null 2>&1; }; } \
+        && { if [ -n "$_partial" ]; then
+            GIT_TERMINAL_PROMPT=0 "$_runner" git -C "$_tmp" fetch -q --no-tags --update-shallow --upload-pack "$_up" "$_dir" "+refs/heads/$_branch:refs/heads/$_branch" >/dev/null 2>&1
+        else
+            git -C "$_tmp" fetch -q --no-tags --update-shallow "$_dir" "+refs/heads/$_branch:refs/heads/$_branch" >/dev/null 2>&1
+        fi; } \
         && git -C "$_tmp" rev-parse -q --verify "refs/heads/$_branch" >/dev/null 2>&1; then
         _rc=0
         # `-C "$_tmp"`: git starts repository discovery in the fresh repo, so

package/dashboard/__init__.py

@@ -7,6 +7,6 @@ Modules:
     control: Session control helpers (status, atomic writes, origin check)
 """
 
-__version__ = "11.17.100"
+__version__ = "11.17.102"
 
 __all__ = ["__version__"]

package/docs/CLI-REFERENCE.md

@@ -1,6 +1,6 @@
 # CLI reference
 
-Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.17.100. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.17.102. Do not edit by hand.
 Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for the full inventory.
 
 | Command | Description |

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Loki Mode, by [Autonomi](https://www.autonomi.dev/), turns a spec or an issue into a verified pull request with a receipt you can check. This page covers installing it, a first run, and the options around it.
 
-**Version:** v11.17.100
+**Version:** v11.17.102
 
 **Engine note:** `loki start` is the primary command. `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` all run the Loki 10 engine, whatever the flag order or input form (PRD file, issue ref, task or one-word brief). The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present. See the [user guide](v10/GUIDE.md) and the [5-minute quickstart](QUICKSTART.md).
 

package/docs/dev/architecture-reference.md

@@ -113,3 +113,4 @@ extract_learnings_from_session (autonomy/run.sh) mirrors learnings and decisions
 - Parallel units: `route.ts` maybeRunGroup defaults to `features/speed/run_group.ts`, which freezes per-unit acceptance (`features/contract.ts`), runs units, merges with `engine10/integrate.ts` and seals once via sealGroup.
 - Lessons: every sealed run appends a receipt fact (`LOKI_AUTO_LEARN_PR`, default on) outside the receipt body; `implement.ts` injects lessons and relevant learnings inside the untrusted-data fence; `loki memory brief --task T` prints the same block.
 
+- Wall publish (FC-VERIFIED-PR-WITHOUT-ITS-TEST): on a VERIFIED seal only, `publishWall` (`util/check_result.ts`, called from `stages/seal.ts`) makes ONE child commit (trailer `Loki-Wall-Publish: <runId>`) of the SEALED Wall bytes (`runDir/wall`, hash-checked against `wall.files[].sha256`) that verify ran and passed (`publishableWall`). Before writing, the realpath of each Wall file's parent directory must be inside the repo, and an existing file or symlink is removed first. The child commit runs with hooks and signing OFF (the default `git()` call, no `userHooks`), so a pre-commit hook cannot add files or rewrite the Wall bytes. Afterwards the commit must touch exactly the published paths and each committed blob must equal the blob hash of the sealed bytes (computed in process, never read from the worktree); on any mismatch the child is rolled back (`update-ref` HEAD to the product head plus `read-tree`), nothing is published and a NOT PROVEN note is added. The receipt binds the PRODUCT head (head_sha, tree, diff_sha256 are computed before the child commit). A re-seal binds `HEAD^` only when HEAD's message has the exact trailer line for this run, HEAD touches only paths of this run's `wall.files`, and every blob sha256 matches (`wallChild`); a forged trailer is not enough. `util/seal_drift.ts` accepts a moved HEAD after head_sha as benign only when every commit after it is such a Wall publish commit (linear, trailer line for the receipt's run_id, only `wall.files` paths, blob sha256 equal to the sealed one); any commit after head_sha that carries this run's trailer but fails that check is head drift (UNCHECKED). Later commits without the trailer stay under the TEN-GATES-16 sealed-path overlap rule. The PR body gains an "Acceptance tests" section. Commit stage and `backstopCommit` still drop Wall files. `LOKI_COMMIT_WALL=0` restores the old behavior (nothing published).

package/docs/v10/FAILURE-CLASSES.md

@@ -1277,6 +1277,14 @@ L0 review rule (ENGINE-LAWS.md L0): a fix that adds an `if` or a regex about the
 - Mechanism: one `product` list in runPackageSuites, the changed files minus this run's passing Wall files (the same set execProves excludes). Unknown diff or a Wall-only diff stays owned (fail-safe). A failed Wall has no proofFiles, so nothing is excluded.
 - Fixture: loki-ts/tests/engine10/monorepo_cwd.test.ts test "FC-WALL-FILE-OWNS-EVERY-PACKAGE" (N/A with a passing root Wall and an untouched test-less package; NOT PROVEN when the Wall failed or an unowned product path is present). Red on HEAD 2739c8e26 (1 fail), green after (38/0).
 
+## FC-VERIFIED-PR-WITHOUT-ITS-TEST A VERIFIED run's pushed branch never contained the acceptance test that made it VERIFIED
+- User-visible vs raw: user-visible. anthropics/claude-code#81826, run e10-20261019T171807Z-7698, sealed VERIFIED; its commit changed 2 product files and tests/loki_wall_ralph_max_iterations.test.ts stayed untracked, so the PR reviewer saw "Missing tests: the diff has no test changes" for the very test that ran green.
+- Law: a proof a reviewer is asked to trust must be reproducible from the pushed branch (evidence or it did not happen). Not product, but publishable once the verdict is sealed.
+- Cause (measured): commit_filter.ts dropSet drops every WALL_FILE (loki_wall_*) in the commit stage and in backstopCommit, and nothing publishes the Wall afterwards, even on VERIFIED.
+- Siblings swept: backstopCommit (killed or crashed worker: stays dropped), discardIfSatisfied, runPackageSuites proofFiles (FC-WALL-FILE-OWNS-EVERY-PACKAGE), flagOutsideScope, formatChanged, receipt diff_sha256 and head_sha, seal_drift head check, reviewer_body changed-files list: none sees a Wall file as product, because the Wall is published in a SEPARATE child commit made at seal after the verdict.
+- Mechanism: publishableWall (util/check_result.ts) selects the Wall files verify ran and passed (target_checks + executed proof), reads the SEALED copy under runDir/wall and requires it to hash to wall.files[].sha256 (mismatch: not published, NOT PROVEN note). The seal stage, only when the verdict is VERIFIED, writes the sealed bytes and makes one child commit (trailer Loki-Wall-Publish). The receipt binds the PRODUCT head (head_sha, tree, diff_sha256 computed before the child commit); the pushed head is its child whose only change is Wall files, so sealDrift reads it as benign head movement (no overlap with the sealed diff). The PR body gains an "Acceptance tests" section (paths and the exact verify command). Opt-out LOKI_COMMIT_WALL=0.
+- Fixture: loki-ts/tests/engine10/seal.test.ts describe "FC-VERIFIED-PR-WITHOUT-ITS-TEST" and loki-ts/tests/engine10/pr_body_golden.test.ts (publish on VERIFIED, sealed bytes not agent bytes, failed/not-run/PARTIAL/opt-out/backstop keep dropping, receipt head and diff unchanged, PR body section). Red on base 4ade2c9a6, green after.
+
 ## FC-CHANGED-PATH-QUOTED A non-ASCII changed path came back from git as a quoted octal escape, so no consumer of changedFiles could match it to a package, Wall file or test
 - User-visible vs raw: user-visible. A diff in `frontend/src/café.ts` made the test-less frontend package read as not owned by the diff, its note became N/A, not_proven was empty and the run could seal VERIFIED with the frontend edit unproven (HIGH re-review of FC-SEAL-NA-AS-UNPROVEN r2).
 - Law broken: a git path must be the real path; an unresolvable path must fail safe, never read as "not in the package".
@@ -1364,3 +1372,19 @@ L0 review rule (ENGINE-LAWS.md L0): a fix that adds an `if` or a regex about the
 - Fixture: loki-ts/tests/util/safe_git_extdiff.test.ts describe "FC-REVIEWER-GIT-CONFIG-EXEC reviewerGitEnv" (control: plain git fires fsmonitor, diff.external and the driver command; with the real builder none fire and status, diff, show -p and log -p still return real patches; wiring check on both TS spawns). Mutation-checked: dropping the driver-key enumeration, the fsmonitor entry or the GIT_EXTERNAL_DIFF override each turns the fixture red.
 - Round 2 (HIGH review block): the same mechanism now also covers gpg exec (log.showSignature=false and gpg.program, gpg.openpgp.program, gpg.ssh.program, gpg.x509.program set to false), partial-clone lazy fetch firing core.sshCommand (GIT_NO_LAZY_FETCH=1 plus repo network command keys enumerated with NET_CMD_KEY_RE and blanked), a shim that ends options with `--` so a file named `-n` is a path, textconv blanked to `cat` (a blank one dies on log -p), and GIT_PAGER=cat. reviewerGitEnv takes a required base, and the two TS reviewer spawns pass tokenFreeEnv(process.env); full_env_spawn_guard.test.ts flags a reviewerGitEnv call with no base or a non-token-free base in the spawning reviewers. Fixtures in safe_git_extdiff.test.ts (gpg, lazy fetch, `-n`, textconv) and the guard test; each mutation (drop gpg entries, drop GIT_NO_LAZY_FETCH, drop `--`, textconv to blank, non-token-free base) turns its fixture red.
 - Round 3: remote.<n>.uploadpack/receivepack are first-value-wins, so a repo-local value beats an env blank. reviewerGitEnv therefore throws when the repo sets either key, and throws on a partial clone (extensions.partialClone) when git is older than 2.44 (GIT_NO_LAZY_FETCH is ignored there); both fixtures are mutation-checked. The spawn guard now requires tokenFreeEnv( on every reviewerGitEnv call (per call, not per file); the only raw process.env base is the cli.ts reviewer-git-env print, an explicit file-and-line row that fails the guard when stale.
+
+## FC-TRUSTED-PUSH-PARTIAL-CLONE The trusted push fetches the run branch out of a partial (--filter=blob:none) agent clone into a temp repo, and upload-pack dies serving objects the clone never downloaded, so a VERIFIED run ends with no PR
+- User-visible vs raw: user-visible. A VERIFIED loki 11.17.100 run on anthropics/claude-code#81826 (clone made with --filter=blob:none) ended `engine10-push: push to fork asklokesh/claude-code refused or failed (rc=1)` and opened no PR.
+- Law broken: a verified result must reach the user on every supported checkout shape (full, shallow, partial); a push helper must not depend on the agent repo being able to serve every reachable object.
+- Cause (measured): `_loki_trusted_push` fetches from the agent repo path into a fresh template-less repo. On a partial clone upload-pack runs pack-objects over history whose blobs were never downloaded and modern git sets no lazy fetch there: `git-pack-objects died with error ... possible repository corruption on the remote side`.
+- Siblings swept: autonomy/lib/engine10-push.sh `_e10_local_push` (same fetch-from-path into a temp repo, left unchanged on purpose: its pinned origin is a local path, so a lazy blob fetch would read the operator's own local repo, which holds every object, and there is no remote network credential to seed; the partial-clone failure is a remote-origin shape); autonomy/lib/engine10-push-gitlab.sh (same fetch from "$dir"; fixed with the same seeding, kept logically equivalent in the child because it is a standalone script that cannot source run.sh, and tests/test-engine10-push-gitlab.sh runs it that way); loki-ts/src/runner/attempts.ts only calls the shell push and holds no copy. No other fetch or clone from the agent repo path exists in autonomy/ or loki-ts/src.
+- Mechanism: in `_loki_trusted_push`, when the agent repo is partial (extensions.partialclone non-empty, or any remote.<n>.promisor true/yes/on/1, both read as data), the temp repo is seeded with the validated origin URL (captured before a fork destination overwrites it) as promisor remote `loki-base`, and its refs are fetched with --filter=blob:none under the credential runner. The agent pack is thin (deltas against blobs the temp repo knows only by id), so the client lazy-fetches those delta bases from loki-base during the agent fetch; that fetch therefore also runs under the runner, with the agent-dir upload-pack (the only process that reads agent config) started through `--upload-pack '/usr/bin/env -i PATH=/usr/bin:/bin GIT_NO_LAZY_FETCH=1 git upload-pack'`, so no token, helper config, HOME or lazy fetch reaches it. Option chosen over prefetching delta-base blobs (git may pick any blob in the edge trees as a base, so an enumeration is a heuristic that fails closed only on private origins and costs a tree walk on large repos) and over an unfiltered seed (downloads full history). GIT_TERMINAL_PROMPT=0 on both fetches. Non-partial repos take the old path with no extra network or runner. A failed seeding or agent fetch fails closed.
+- Fixture: tests/test-engine10-push-gitlab.sh (partial-clone block, red before with "could not stage branch", green after) and tests/test-trusted-push-agent-config.sh "FC-TRUSTED-PUSH-PARTIAL-CLONE" block (a real blob:none clone of a local origin with a history-only blob; pushes the agent branch; asserts the non-partial path never writes remote.loki-base config). Red before (rc=1, no push), green after. Review round 1 (HIGH, reproduced): the agent fetch ran token-less, so a private origin refused the lazy delta-base fetch; both fixtures now add a 20000-line file edited by the agent, an origin that refuses token-less reads through a packObjectsHook in the test global config, and a spy on the agent-dir upload-pack environment. Red on 95bf13b9a for the GitHub path (rc=1, nothing pushed); the GitLab child holds its token process-wide, so only its env-scrub assertion was red there.
+
+## FC-FULL-SUITE-EXIT-CODED-SCRIPT A project-model full-suite command that is a plain CI checker script (not a test framework) prints no runner summary, so verify recorded it not_run UNMEASURED and a proven change sealed PARTIAL
+- User-visible vs raw: user-visible. claude-code#81826 on v11.17.101 sealed PARTIAL although the Wall passed with n=7; Not-proven listed "one reviewer", "not run: full suite: repo-root" and "executed count unmeasured".
+- Law broken: a run seals VERIFIED unless it genuinely cannot be proven; a harness-side parse gap on a command that has no summary to parse must not hold back a proven change.
+- Cause (measured): the model gave package repo-root the test command `python3 .github/scripts/check_workflow_hardening.py`; it printed "OK: checked 3 job(s) ..." and exited 0; classifyCheck (kind test) needs a parsed count, ran() returned null, result not_run. crossReview returns null for any verdict other than VERIFIED or ALREADY_SATISFIED, so "one reviewer" stayed uncredited only because the run was already PARTIAL.
+- Siblings swept: runFullSuite legacy per-runner path (commands come from FULL_SUITE_CMD, always frameworks, unchanged); base_guard and wall use real runners (unchanged).
+- Mechanism: check_result.ts isExitCodedScript (every segment a plain interpreter-plus-script run, nothing naming a test framework or containing "test"; anything ambiguous is a framework) feeds classifyCheck exitCoded: pass on rc 0, fail on rc != 0, count "n/a (exit-coded check, not a test runner)", never an n, so it is never executed proof. A framework with no summary stays UNMEASURED. FC-16 on the target is unchanged.
+- Fixture: tests/util/check_result.test.ts and tests/engine10/monorepo_cwd.test.ts (red before: missing export), tests/engine10/seal.test.ts (Wall n>0 plus exit-coded full suite is VERIFIED with one reviewer credited by a real review).

package/docs/v10/PROGRESS.md

@@ -2674,3 +2674,9 @@ v11.17.21 published (Release success on 462fbc40a; npm latest 11.17.21, next 11.
 
 ## 2026-10-19T17:09Z (CoS) v11.17.100
 - 11.17.100: FC-WALL-FILE-OWNS-EVERY-PACKAGE (opus HIGH review). claude-code#81826 on 11.17.99 sealed PARTIAL on untouched package `scripts` because the root Wall file read as owned by every test-less package. monorepo_cwd 38/0 (red on HEAD 2739c8e26: 1 fail), tsc clean.
+
+## 2026-10-19T18:37Z (CoS) v11.17.101
+- 11.17.101: FC-TRUSTED-PUSH-PARTIAL-CLONE (opus HIGH APPROVE; trusted-push-agent-config 62/0, engine10-push-gitlab 25/0). claude-code#81826 on 11.17.100 sealed VERIFIED but the fork push failed rc=1 in a partial clone.
+
+## 2026-10-19T19:00Z (CoS) v11.17.102
+- 11.17.102: FC-VERIFIED-PR-WITHOUT-ITS-TEST (opus HIGH APPROVE after hook BLOCK; seal 121/0, pr_body_golden 17/0, log_seal 19/0) and FC-FULL-SUITE-EXIT-CODED-SCRIPT (opus HIGH APPROVE; check_result 31/0, monorepo_cwd 39/0). claude-code#81826 draft rerun on 11.17.101 sealed PARTIAL on an exit-coded checker script.