@loomhelm/multi-task-flow 0.2.1 → 0.2.7

package/toolkit/skills/node_modules/sharp/src/utilities.cc

@@ -0,0 +1,289 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+#include <cmath>
+#include <cstdio>
+#include <string>
+
+#include <napi.h>
+#include <vips/vips8>
+#include <vips/vector.h>
+
+#include "./common.h"
+#include "./operations.h"
+#include "./utilities.h"
+
+/*
+  Get and set cache limits
+*/
+Napi::Value cache(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // Set memory limit
+  if (info[size_t(0)].IsNumber()) {
+    vips_cache_set_max_mem(static_cast<size_t>(info[size_t(0)].As<Napi::Number>().Uint32Value()) * 1048576);
+  }
+  // Set file limit
+  if (info[size_t(1)].IsNumber()) {
+    vips_cache_set_max_files(info[size_t(1)].As<Napi::Number>().Uint32Value());
+  }
+  // Set items limit
+  if (info[size_t(2)].IsNumber()) {
+    vips_cache_set_max(info[size_t(2)].As<Napi::Number>().Uint32Value());
+  }
+
+  // Get memory stats
+  Napi::Object memory = Napi::Object::New(env);
+  memory.Set("current", round(vips_tracked_get_mem() / 1048576));
+  memory.Set("high", round(vips_tracked_get_mem_highwater() / 1048576));
+  memory.Set("max", round(vips_cache_get_max_mem() / 1048576));
+  // Get file stats
+  Napi::Object files = Napi::Object::New(env);
+  files.Set("current", vips_tracked_get_files());
+  files.Set("max", vips_cache_get_max_files());
+
+  // Get item stats
+  Napi::Object items = Napi::Object::New(env);
+  items.Set("current", vips_cache_get_size());
+  items.Set("max", vips_cache_get_max());
+
+  Napi::Object cache = Napi::Object::New(env);
+  cache.Set("memory", memory);
+  cache.Set("files", files);
+  cache.Set("items", items);
+  return cache;
+}
+
+/*
+  Get and set size of thread pool
+*/
+Napi::Value concurrency(const Napi::CallbackInfo& info) {
+  // Set concurrency
+  if (info[size_t(0)].IsNumber()) {
+    vips_concurrency_set(info[size_t(0)].As<Napi::Number>().Int32Value());
+  }
+  // Get concurrency
+  return Napi::Number::New(info.Env(), vips_concurrency_get());
+}
+
+/*
+  Get internal counters (queued tasks, processing tasks)
+*/
+Napi::Value counters(const Napi::CallbackInfo& info) {
+  Napi::Object counters = Napi::Object::New(info.Env());
+  counters.Set("queue", static_cast<int>(sharp::counterQueue));
+  counters.Set("process", static_cast<int>(sharp::counterProcess));
+  return counters;
+}
+
+/*
+  Get and set use of SIMD vector unit instructions
+*/
+Napi::Value simd(const Napi::CallbackInfo& info) {
+  // Set state
+  if (info[size_t(0)].IsBoolean()) {
+    vips_vector_set_enabled(info[size_t(0)].As<Napi::Boolean>().Value());
+  }
+  // Get state
+  return Napi::Boolean::New(info.Env(), vips_vector_isenabled());
+}
+
+/*
+  Get libvips version
+*/
+Napi::Value libvipsVersion(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object version = Napi::Object::New(env);
+
+  char semver[9];
+  std::snprintf(semver, sizeof(semver), "%d.%d.%d", vips_version(0), vips_version(1), vips_version(2));
+  version.Set("semver", Napi::String::New(env, semver));
+#ifdef SHARP_USE_GLOBAL_LIBVIPS
+  version.Set("isGlobal", Napi::Boolean::New(env, true));
+#else
+  version.Set("isGlobal", Napi::Boolean::New(env, false));
+#endif
+#ifdef __EMSCRIPTEN__
+  version.Set("isWasm", Napi::Boolean::New(env, true));
+#else
+  version.Set("isWasm", Napi::Boolean::New(env, false));
+#endif
+  return version;
+}
+
+/*
+  Get available input/output file/buffer/stream formats
+*/
+Napi::Value format(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object format = Napi::Object::New(env);
+  for (std::string const f : {
+    "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl", "rad", "dcraw"
+  }) {
+    std::string id = f == "jp2k" ? "jp2" : f;
+    // Input
+    const VipsObjectClass *oc = vips_class_find("VipsOperation", (f + "load").c_str());
+    Napi::Boolean hasInputFile = Napi::Boolean::New(env, oc);
+    Napi::Boolean hasInputBuffer =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "load_buffer").c_str()));
+    Napi::Object input = Napi::Object::New(env);
+    input.Set("file", hasInputFile);
+    input.Set("buffer", hasInputBuffer);
+    input.Set("stream", hasInputBuffer);
+    if (oc) {
+      const VipsForeignClass *fc = VIPS_FOREIGN_CLASS(oc);
+      if (fc->suffs) {
+        Napi::Array fileSuffix = Napi::Array::New(env);
+        const char **suffix = fc->suffs;
+        for (int i = 0; *suffix; i++, suffix++) {
+          fileSuffix.Set(i, Napi::String::New(env, *suffix));
+        }
+        input.Set("fileSuffix", fileSuffix);
+      }
+    }
+    // Output
+    Napi::Boolean hasOutputFile =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "save").c_str()));
+    Napi::Boolean hasOutputBuffer =
+      Napi::Boolean::New(env, vips_type_find("VipsOperation", (f + "save_buffer").c_str()));
+    Napi::Object output = Napi::Object::New(env);
+    output.Set("file", hasOutputFile);
+    output.Set("buffer", hasOutputBuffer);
+    output.Set("stream", hasOutputBuffer);
+    // Other attributes
+    Napi::Object container = Napi::Object::New(env);
+    container.Set("id", id);
+    container.Set("input", input);
+    container.Set("output", output);
+    // Add to set of formats
+    format.Set(id, container);
+  }
+
+  // Raw, uncompressed data
+  Napi::Boolean supported = Napi::Boolean::New(env, true);
+  Napi::Boolean unsupported = Napi::Boolean::New(env, false);
+  Napi::Object rawInput = Napi::Object::New(env);
+  rawInput.Set("file", unsupported);
+  rawInput.Set("buffer", supported);
+  rawInput.Set("stream", supported);
+  Napi::Object rawOutput = Napi::Object::New(env);
+  rawOutput.Set("file", unsupported);
+  rawOutput.Set("buffer", supported);
+  rawOutput.Set("stream", supported);
+  Napi::Object raw = Napi::Object::New(env);
+  raw.Set("id", "raw");
+  raw.Set("input", rawInput);
+  raw.Set("output", rawOutput);
+  format.Set("raw", raw);
+
+  return format;
+}
+
+/*
+  (Un)block libvips operations at runtime.
+*/
+void block(const Napi::CallbackInfo& info) {
+  Napi::Array ops = info[size_t(0)].As<Napi::Array>();
+  bool const state = info[size_t(1)].As<Napi::Boolean>().Value();
+  for (unsigned int i = 0; i < ops.Length(); i++) {
+    vips_operation_block_set(ops.Get(i).As<Napi::String>().Utf8Value().c_str(), state);
+  }
+}
+
+/*
+  Synchronous, internal-only method used by some of the functional tests.
+  Calculates the maximum colour distance using the DE2000 algorithm
+  between two images of the same dimensions and number of channels.
+*/
+Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // Open input files
+  VImage image1;
+  sharp::ImageType imageType1 = sharp::DetermineImageType(info[size_t(0)].As<Napi::String>().Utf8Value().data());
+  if (imageType1 != sharp::ImageType::UNKNOWN) {
+    try {
+      image1 = VImage::new_from_file(info[size_t(0)].As<Napi::String>().Utf8Value().c_str());
+    } catch (...) {
+      throw Napi::Error::New(env, "Input file 1 has corrupt header");
+    }
+  } else {
+    throw Napi::Error::New(env, "Input file 1 is of an unsupported image format");
+  }
+  VImage image2;
+  sharp::ImageType imageType2 = sharp::DetermineImageType(info[size_t(1)].As<Napi::String>().Utf8Value().data());
+  if (imageType2 != sharp::ImageType::UNKNOWN) {
+    try {
+      image2 = VImage::new_from_file(info[size_t(1)].As<Napi::String>().Utf8Value().c_str());
+    } catch (...) {
+      throw Napi::Error::New(env, "Input file 2 has corrupt header");
+    }
+  } else {
+    throw Napi::Error::New(env, "Input file 2 is of an unsupported image format");
+  }
+  // Ensure same number of channels
+  if (image1.bands() != image2.bands()) {
+    throw Napi::Error::New(env, "mismatchedBands");
+  }
+  // Ensure same dimensions
+  if (image1.width() != image2.width() || image1.height() != image2.height()) {
+    throw Napi::Error::New(env, "mismatchedDimensions");
+  }
+
+  double maxColourDistance;
+  try {
+    // Premultiply and remove alpha
+    if (image1.has_alpha()) {
+      image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
+    }
+    if (image2.has_alpha()) {
+      image2 = image2.premultiply().extract_band(1, VImage::option()->set("n", image2.bands() - 1));
+    }
+    // Calculate colour distance
+    maxColourDistance = image1.dE00(image2).max();
+  } catch (std::runtime_error const &err) {
+    throw Napi::Error::New(env, err.what());
+  }
+
+  // Clean up libvips' per-request data and threads
+  vips_error_clear();
+  vips_thread_shutdown();
+
+  return Napi::Number::New(env, maxColourDistance);
+}
+
+#if defined(__GNUC__)
+// mallctl will be resolved by the runtime linker when jemalloc is being used
+extern "C" {
+  int mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) __attribute__((weak));
+}
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, mallctl != nullptr);
+}
+#else
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif
+
+#if defined(__GNUC__) && defined(__x86_64__)
+// Are SSE 4.2 intrinsics available at runtime?
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  unsigned int eax, ebx, ecx, edx;
+  __asm__ __volatile__("cpuid"
+    : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
+    : "a"(1));
+  return Napi::Boolean::New(env, (ecx & 1U << 20) != 0);
+}
+#else
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

package/toolkit/skills/node_modules/sharp/src/utilities.h

@@ -0,0 +1,22 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef SRC_UTILITIES_H_
+#define SRC_UTILITIES_H_
+
+#include <napi.h>
+
+Napi::Value cache(const Napi::CallbackInfo& info);
+Napi::Value concurrency(const Napi::CallbackInfo& info);
+Napi::Value counters(const Napi::CallbackInfo& info);
+Napi::Value simd(const Napi::CallbackInfo& info);
+Napi::Value libvipsVersion(const Napi::CallbackInfo& info);
+Napi::Value format(const Napi::CallbackInfo& info);
+void block(const Napi::CallbackInfo& info);
+Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info);
+
+#endif  // SRC_UTILITIES_H_

package/toolkit/skills/project-engineering-workflow/SKILL.md

@@ -139,7 +139,7 @@ Draft bootstrap is optional for multi-slice or slow-CI work after one complete t
 
 When the source PR carries an authorized late-review handoff, finish its selected merge-scope obligations first, then run the review-proof contract's Authorized follow-up delivery through an independent `$fast-flow` to Step 5C Ready. Keep the source and follow-up identities, budgets and merge approvals distinct; an unmerged source retains its pending handoff at the existing owner gate.
 
-Only merged direct or parent PRs enter. Once live PR facts confirm the merge and actual merge SHA (the Merge Receipt), start merge-SHA target CI tracking and independently evaluate release applicability and begin any authorized preparation that does not depend on CI terminal success. Follow the target repository's gates before dispatch; do not delay either track for unrelated merge-scope cleanup. The ledger's terminal post-merge receipt is recorded later, after CI and release finality; it is not the launch prerequisite. `release_expected` exists only as this post-merge fact. Expected releases must reach actual publication or a reported failed/incomplete state; CI or release-intent snapshots and pre-merge route evidence are not publication proof. Child PRs return their merge facts to their owning coordinator; the parent PR remains the final owner-facing surface.
+Only merged direct or parent PRs enter. Once live PR facts confirm the merge and actual merge SHA (the Merge Receipt), start merge-SHA target CI tracking and independently evaluate release applicability and begin any authorized preparation that does not depend on CI terminal success. Follow the target repository's gates before dispatch; do not delay either track for unrelated merge-scope cleanup. The shared PR merge procedure must then apply the safe primary-base alignment plan and record its structured result before merge-scope closeout; a successful remote `pr-merge` alone is not a terminal workflow state. The ledger's terminal post-merge receipt is recorded later, after CI and release finality; it is not the launch prerequisite. `release_expected` exists only as this post-merge fact. Expected releases must reach actual publication or a reported failed/incomplete state; CI or release-intent snapshots and pre-merge route evidence are not publication proof. Child PRs return their merge facts to their owning coordinator; the parent PR remains the final owner-facing surface.
 
 For a task that owns an Agent VM, invoke `$agent-vm`'s Finish policy after merge to decide whether VM work remains and verify closure when it does not. Release may precede remote-only CI/release waits; continue those waits under their existing contracts. Keep the VM when post-merge work still needs it.
 

package/toolkit/skills/project-engineering-workflow/references/pr-merge-procedure.md

@@ -34,7 +34,7 @@ For `mode=merge`:
      --expected-base "$LOCKED_BASE" --expected-head "$LOCKED_HEAD"
    ```
 
-   Fail closed if the guard flag is unsupported. A merge-queue enqueue is not a merged terminal state; refresh live facts until the PR is actually merged or a concrete blocker is returned.
+   Fail closed if the guard flag is unsupported. A merge-queue enqueue is not a merged terminal state; refresh live facts until the PR is actually merged or a concrete blocker is returned. `code_hosting.ts pr-merge` proves the remote merge only; it does not update the Git primary worktree.
 
 4. Fetch the resulting PR state and actual merge commit SHA. If the command outcome is ambiguous, inspect live facts before retrying and never issue a blind duplicate merge. These live merged-PR facts and the actual merge SHA constitute the Merge Receipt for Step 6. Launch target CI tracking and authorized independent release preparation immediately; do not wait for the ledger's terminal post-merge receipt or subsequent merge-scope operations.
 5. For a merged UI PR, call `skills/ui-visual-evidence/scripts/pr_body_image_gate.ts` Phase B. It reads only the managed `## Visual Evidence` section, binds URLs to the merge SHA, verifies the selected platform's rendered Markdown HTML, and keeps the existing bounded retry semantics.
@@ -52,14 +52,25 @@ For `mode=merge`:
 
    A verified `404` after DELETE `200/204` records `deleted`; a verified `404` after DELETE `404/422` records `already_absent`. A missing `404` result or any other response is a blocker. Fork, non-owner, protected, or unknown head states are explicit non-deleting terminal dispositions, never permission to guess a remote or ref.
 
-7. Run `skills/project-engineering-workflow/scripts/base_alignment_helper.ts` against the primary worktree and PR base. Apply only its safe tracking-ref or fast-forward plan; dirty, ahead, diverged, and linked-worktree states return an owner decision or blocker.
+7. Run the alignment helper against the primary worktree and PR base, and apply its safe plan in the same merge scope:
+
+   ```bash
+   bun skills/project-engineering-workflow/scripts/base_alignment_helper.ts \
+     apply-auto --repo-root "$CANDIDATE_ROOT" \
+     --base-branch "$LOCKED_BASE" \
+     --base-remote-ref "$BASE_REMOTE/$LOCKED_BASE" \
+     --head-branch "$HEAD_REF" \
+     --refresh-remote --pretty
+   ```
+
+   Exit `0` is the only automatic alignment success and must report `state=aligned` after the safe tracking-ref or fast-forward action. Exit `10` is an owner decision and exit `11` is a blocker for dirty, ahead, diverged, fetch-failed, or linked-worktree states; report the structured result and do not claim merge-scope closeout without the owner's selected disposition.
 8. Record the receipt against the actual merge SHA after terminal CI and release facts are available. The caller continues both tracks and selected-flow closeout.
 
 For `mode=post-merge`, do not run `merge_preflight.ts` or `code_hosting.ts pr-merge`; this branch can never issue a second merge. Refresh the already merged PR and recorded `merge_sha`, then perform only the unfinished merge-scope/post-merge operations from the envelope:
 
 1. Run Phase B image finalization when a merged UI PR still needs it.
 2. Re-resolve `head_repository`, `head_ref`, and `is_cross_repository`. Delete and verify the exact API ref in that repository through the adapter's bound DELETE plus GET that proves HTTP `404`. DELETE `200/204` records `deleted`; DELETE `404/422` followed by `404` records `already_absent`; any other DELETE response or a non-`404` GET is a blocker. Report a fork, non-owner, protected, or unknown head as an explicit non-deleting disposition. Do not treat deletion as a merge operation.
-3. Run `base_alignment_helper.ts` and apply only its safe plan, returning the existing owner-decision/blocker states for dirty, ahead, diverged, or linked worktrees.
+3. Run the same `base_alignment_helper.ts apply-auto` command and apply only its safe plan, returning the existing owner-decision/blocker states for dirty, ahead, diverged, or linked worktrees. A resumed post-merge path must not stop after observing `MERGED`; it needs a structured base-alignment result before receipt closeout.
 4. Record or refresh the receipt against the exact `merge_sha`, then return the target/integration CI and release facts still required by the caller.
 
 ## Stop Conditions

package/toolkit/skills/project-engineering-workflow/scripts/base_alignment_helper.ts

@@ -1,4 +1,10 @@
-import { runCompatibilityCli } from "../../bin/compatibility_cli";
+import { main } from "./base_alignment";
 
-if (import.meta.main)
-  process.exitCode = await runCompatibilityCli("base_alignment_helper");
+if (import.meta.main) {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      "Usage: bun skills/project-engineering-workflow/scripts/base_alignment_helper.ts [inspect|apply-auto|safe-align] [options]",
+    );
+  } else process.exitCode = await main(argv);
+}

package/toolkit/skills/project-engineering-workflow/scripts/test_base_alignment_helper.ts

@@ -1 +1 @@
-import "../../bin/tests/workspace/workspace.test.ts";
+import "../tests/base_alignment.test.ts";

package/toolkit/skills/{bin/tests/workspace → project-engineering-workflow/tests}/base_alignment.test.ts

@@ -1,13 +1,13 @@
 import { expect, test } from "bun:test";
 import { execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   planAlignment,
   type AlignmentFacts,
-} from "../../modules/workspace/base_alignment";
-import { applyAuto } from "../../modules/workspace/base_alignment_actions";
+} from "../scripts/base_alignment";
+import { applyAuto } from "../scripts/base_alignment_actions";
 
 function git(root: string, ...args: string[]): string {
   return execFileSync("git", ["-C", root, ...args], {
@@ -42,6 +42,29 @@ function facts(overrides: Partial<AlignmentFacts> = {}): AlignmentFacts {
   };
 }
 
+test("base alignment implementation stays inside its owning Skill", () => {
+  const manifest = JSON.parse(
+    readFileSync(join(import.meta.dir, "../../source-manifest.json"), "utf8"),
+  ) as { files: Array<{ path: string }> };
+  const paths = manifest.files.map((file) => file.path);
+  expect(paths).toContain(
+    "skills/project-engineering-workflow/scripts/base_alignment.ts",
+  );
+  expect(paths).toContain(
+    "skills/project-engineering-workflow/scripts/base_alignment_actions.ts",
+  );
+  expect(paths).toContain(
+    "skills/project-engineering-workflow/scripts/base_alignment_helper.ts",
+  );
+  expect(paths).not.toContain("skills/bin/modules/workspace/base_alignment.ts");
+  expect(
+    readFileSync(
+      join(import.meta.dir, "../scripts/base_alignment_helper.ts"),
+      "utf8",
+    ),
+  ).not.toContain("../../bin");
+});
+
 test("base alignment blocks a linked worktree owner", () => {
   const result = planAlignment(
     facts({

package/toolkit/skills/project-engineering-workflow/tests/pr_replay_policy.test.ts

@@ -0,0 +1,172 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { analyzePrReplay } from "../../bin/modules/checks";
+
+function writeReplay(records: Record<string, unknown>[]): string {
+  const directory = mkdtempSync(join(tmpdir(), "checks-pr-policy-"));
+  const path = join(directory, "replay.jsonl");
+  writeFileSync(
+    path,
+    records.map((record) => JSON.stringify(record)).join("\n") + "\n",
+  );
+  return path;
+}
+
+function cleanup(path: string): void {
+  rmSync(resolve(path, ".."), { recursive: true, force: true });
+}
+
+test("requires a post-merge primary-base outcome", () => {
+  const mergeRecords: Record<string, unknown>[] = [
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call_output",
+        call_id: "route-none",
+        output: {
+          pre_merge_release_route: "no-managed-route",
+          route_source: "none",
+          target_repo: "example/repo",
+          target_pr: 42,
+          current_repository_facts: "no release policy or managed release labels",
+          current_pr_facts: "PR #42; head=abc1234; base=main",
+          managed_release_labels: [],
+        },
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: "merge" }],
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: "headRefName=topic" }],
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call",
+        name: "exec_command",
+        arguments: JSON.stringify({
+          cmd:
+            "bun skills/bin/code_hosting.ts --repo-root /repo --remote origin pr-merge --number 42 --method merge --expected-base " +
+            "a".repeat(40) +
+            " --expected-head " +
+            "b".repeat(40),
+          workdir: "/repo",
+        }),
+        call_id: "merge",
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call_output",
+        call_id: "merge",
+        output: "✓ Merged pull request #42",
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call",
+        name: "exec_command",
+        arguments: JSON.stringify({
+          cmd: "git push origin --delete topic",
+          workdir: "/repo",
+        }),
+        call_id: "delete",
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call_output",
+        call_id: "delete",
+        output: " - [deleted]         topic",
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call_output",
+        call_id: "legacy-release-contract",
+        output: {
+          release_expected: false,
+          release_epoch: "merge-abc1234",
+          target_repo: "example/repo",
+          target_branch: "main",
+          target_sha: "abc1234",
+          reason:
+            "release_expected=false; release workflow skipped for this merge SHA",
+        },
+      },
+    },
+  ];
+  const missingPath = writeReplay([
+    ...mergeRecords,
+    {
+      type: "event_msg",
+      payload: {
+        type: "task_complete",
+        turn_id: "missing-base-outcome",
+        last_agent_message:
+          "PR 已合并；远端分支=不存在；发布状态=未触发；依据=legacy fixture 无仓库发布面；发布版本=none；发布tag=none；发布channel=none；发布绑定sha=none；发布workflow=none；发布URL=none；发布时间=none；发布产物=none；发布处置=report-only。",
+      },
+    },
+  ]);
+  const alignedPath = writeReplay([
+    ...mergeRecords,
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call",
+        name: "exec_command",
+        arguments: JSON.stringify({
+          cmd: "bun skills/project-engineering-workflow/scripts/base_alignment_helper.ts apply-auto --repo-root /repo --base-branch main --base-remote-ref origin/main --head-branch topic --refresh-remote",
+          workdir: "/repo",
+        }),
+        call_id: "base-align",
+      },
+    },
+    {
+      type: "response_item",
+      payload: {
+        type: "function_call_output",
+        call_id: "base-align",
+        output: JSON.stringify({
+          state: "aligned",
+          merge_scope_status: "已更新",
+        }),
+      },
+    },
+    {
+      type: "event_msg",
+      payload: {
+        type: "task_complete",
+        turn_id: "aligned-base-outcome",
+        last_agent_message:
+          "PR 已合并；远端分支=不存在；发布状态=未触发；依据=legacy fixture 无仓库发布面；发布版本=none；发布tag=none；发布channel=none；发布绑定sha=none；发布workflow=none；发布URL=none；发布时间=none；发布产物=none；发布处置=report-only。",
+      },
+    },
+  ]);
+  try {
+    expect(
+      analyzePrReplay(missingPath).findings.map((item) => item.code),
+    ).toContain("BASE_UPDATE_RESULT_MISSING");
+    expect(analyzePrReplay(alignedPath).findings).toEqual([]);
+  } finally {
+    cleanup(missingPath);
+    cleanup(alignedPath);
+  }
+});