@brainervirus/workit-core 2.8.0 → 3.0.0

package/README.md

@@ -30,7 +30,8 @@ Adapters map host-native surfaces to `src/core/`; they never re-implement core l
 ## Exports
 
 - Main entry: `./src/core.ts`.
-- Subpath exports: `./src/*.ts` (e.g. `@brainervirus/workit-core/src/core/doctor`), plus `./package.json`.
+- Subpath exports: `./src/*.ts` (e.g. `@brainervirus/workit-core/src/core/task-store`), plus `./package.json`.
+- Setup, doctor, upgrade, uninstall and host-install code lives in `@brainervirus/workit-cli` (`src/admin/`), not here, so host hooks and plugins never bundle it.
 
 ## Package scripts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "2.8.0",
+  "version": "3.0.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/scripts/bundled-deps.json

@@ -56,13 +56,7 @@
     "yoga-layout",
     "zod"
   ],
-  "workit-opencode": [
-    "@openclaw/fs-safe",
-    "@opencode-ai/plugin",
-    "@opencode-ai/plugin/zod",
-    "@opencode/plugin",
-    "zod"
-  ],
+  "workit-opencode": ["@openclaw/fs-safe", "@opencode/plugin", "zod"],
   "workit-cursor": [
     "@modelcontextprotocol/sdk",
     "@openclaw/fs-safe",

package/scripts/install-codex-plugin.sh

@@ -19,10 +19,9 @@ fi
 mkdir -p "$PLUGIN_DIR"
 rsync -a --delete "$SOURCE/packages/workit-codex/" "$PLUGIN_DIR/"
 
-if ! bun "$ROOT/packages/workit-core/scripts/doctor-check.ts" cli; then
+if ! bun "$ROOT/packages/workit-cli/scripts/doctor-check.ts" cli; then
   echo "FATAL: post-install doctor found problems after Codex plugin sync" >&2
   exit 1
 fi
 
 echo "Codex plugin installed at $PLUGIN_DIR"
-echo "Complete an explicit v1 cutover before treating this as a generation switch."

package/scripts/install-cursor-plugin.sh

@@ -50,7 +50,7 @@ fi
 # The check reads only workit-owned files, so a healthy install is byte-untouched;
 # a registry-unreachable comparison reports registry_unreachable, never stale
 # (CA-04) — no false stale_install and no install failure.
-if bun "$ROOT/packages/workit-core/scripts/doctor-check.ts" cursor --stale; then
+if bun "$ROOT/packages/workit-cli/scripts/doctor-check.ts" cursor --stale; then
   :
 elif [ $? -eq 2 ]; then
   echo "workit: stale Cursor plugin install detected — self-healing (refresh + canonical re-registration)" >&2
@@ -70,7 +70,7 @@ if [ -d "$SKILLS_DIR" ]; then
 fi
 
 PLUGIN_DIR="$HOME/.cursor/plugins/local/workit"
-REGISTRATION_TS="$ROOT/packages/workit-core/src/core/registration.ts"
+REGISTRATION_TS="$ROOT/packages/workit-cli/src/admin/registration.ts"
 CURSOR_SETTINGS="$HOME/.cursor/settings.json" CURSOR_MCP="$HOME/.cursor/mcp.json" PLUGIN_DIR="$PLUGIN_DIR" REGISTRATION_TS="$REGISTRATION_TS" LOCAL_DIST="$LOCAL_DIST" bun -e '
 import fs from "node:fs";
 import path from "node:path";
@@ -120,7 +120,7 @@ if (localDist) {
 '
 
 # DG-09: verify the just-written Cursor registration with the shared offline doctor.
-if ! bun "$ROOT/packages/workit-core/scripts/doctor-check.ts" cursor; then
+if ! bun "$ROOT/packages/workit-cli/scripts/doctor-check.ts" cursor; then
   echo "FATAL: post-install doctor found an unhealthy Cursor registration" >&2
   exit 1
 fi
@@ -140,6 +140,5 @@ if [ -d "$LEGACY_PLUGIN_DIR" ] && [ "$LEGACY_PLUGIN_DIR" != "$PLUGIN_DIR" ]; the
 fi
 
 echo "Cursor plugin installed + auto-sync enabled (sessionStart)."
-echo "Generation switches require an explicit cutover preview/apply — install alone is not a cutover."
 echo "Share: $SHARE"
 ls "$HOME/.cursor/plugins/local/workit/skills" | grep '^wk-' || true

package/scripts/install-opencode-plugin.sh

@@ -38,7 +38,7 @@ mkdir -p "$(dirname "$CONFIG")"
 
 # Merge/dedupe registrations via the shared core helper (RR-06): one dev pin,
 # no legacy/current duplicates, unrelated user settings preserved.
-CONFIG_PATH="$CONFIG" PIN_PATH="$PIN" REGISTRATION_TS="$ROOT/packages/workit-core/src/core/registration.ts" bun -e '
+CONFIG_PATH="$CONFIG" PIN_PATH="$PIN" REGISTRATION_TS="$ROOT/packages/workit-cli/src/admin/registration.ts" bun -e '
 import fs from "node:fs";
 const { mergeOpenCodeConfig } = await import(process.env.REGISTRATION_TS!);
 const path = process.env.CONFIG_PATH!;
@@ -71,10 +71,9 @@ if [ ! -s "$PLUGIN_ENTRY" ]; then
 fi
 
 # DG-09: verify the just-written registration with the shared offline doctor.
-if ! bun "$ROOT/packages/workit-core/scripts/doctor-check.ts" opencode; then
+if ! bun "$ROOT/packages/workit-cli/scripts/doctor-check.ts" opencode; then
   echo "FATAL: post-install doctor found an unhealthy OpenCode registration" >&2
   exit 1
 fi
 
 echo "OpenCode install done. Fully quit all opencode processes, then restart."
-echo "Generation switches require an explicit cutover preview/apply — install alone is not a cutover."

package/scripts/install-pi-package.sh

@@ -19,8 +19,8 @@ fi
 # pi 0.85.1 loads extensions from the settings `packages` list, not from
 # ~/.pi/config.json below. Register the absolute package dir there (honoring
 # PI_CODING_AGENT_DIR) so `pi list` picks it up; the config.json write stays
-# because uninstall/cutover/detection still key pi state off it — migrating
-# those three off config.json is a separate contract change.
+# because uninstall and detection still key pi state off it — migrating
+# those two off config.json is a separate contract change.
 AGENT_DIR="${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}"
 SETTINGS="$AGENT_DIR/settings.json"
 mkdir -p "$AGENT_DIR"
@@ -53,4 +53,3 @@ console.log("Registered Pi extension:", process.env.EXT);
 '
 
 echo "Pi package registered in $SETTINGS (and legacy $PI_CONFIG)"
-echo "Complete an explicit v1 cutover before treating this as a generation switch."

package/scripts/sync-runtime.sh

@@ -153,19 +153,6 @@ fi
 # Remove broken TLA live-loader if present (OpenCode ignored it; /wk-* vanished)
 rm -f "${OPENCODE_PLUGINS}/workflow-toolkit.ts"
 
-# Ensure OpenCode has plugin peer dep
-PKG="${HOME}/.config/opencode/package.json"
-if [ -f "$PKG" ]; then
-  PKG_PATH="$PKG" "$BUN_BIN" -e '
-import fs from "node:fs";
-const path = process.env.PKG_PATH!;
-const data = JSON.parse(fs.readFileSync(path, "utf8"));
-data.dependencies = data.dependencies ?? {};
-data.dependencies["@opencode-ai/plugin"] = data.dependencies["@opencode-ai/plugin"] ?? "1.18.30";
-fs.writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
-' || true
-fi
-
 # Drop bun package cache so old github/file installs cannot shadow file:// plugin.ts
 rm -rf "${HOME}/.cache/opencode/packages/workflow-toolkit-opencode@"* 2>/dev/null || true
 

package/src/core/init.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { configDir, isConfigObject } from "./config";
 import { writeFileExclusive } from "./safe-write";
-import { applyWorkspaceBranchPolicy } from "./setup";
+import { applyWorkspaceBranchPolicy } from "./workspace-branch-policy";
 import { youTrackTokenCreateUrl } from "./youtrack";
 
 const TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";

package/src/core/support-matrix.ts

@@ -7,10 +7,10 @@
 export const SUPPORT_MATRIX = {
   bun: "1.4.1",
   node: { minimum: "24", current: "24.20.0" },
-  // The object-form dual entry (server() + setup()) only loads from
-  // 1.18.29+; the supported floor is 1.18.30 so no host can pass doctor while
-  // being unable to load the entry shape.
-  opencode: { minimum: "1.18.30", current: "1.18.34" },
+  // OpenCode V2 plugin API only: the entry exports `setup()` (Workit 3.0
+  // retired the V1 `server()` adapter), so 1.x hosts cannot load it. 2.0.18 is
+  // the `@opencode/plugin` contract the adapter is built and tested against.
+  opencode: { minimum: "2.0.18", current: "2.0.18" },
   // Codex is a qualification host, not a runtime dependency: the CLI version
   // below is the one live qualification evidence covers. The doctor warns when
   // an installed CLI drifts ahead so a fresh install never silently outruns

package/src/core/workspace-branch-policy.ts

@@ -0,0 +1,123 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { detectBranchPolicy } from "./branch-policy";
+import { configDir } from "./config";
+import {
+  readWorkspacesResult,
+  resolveWorkspaceFrom,
+  validateWorkspaceGlob,
+  validateWorkspacesDocument,
+  workspacesRevision,
+  type WorkspaceConfig,
+} from "./workspaces";
+
+const readFileSafe = (p: string): string | null => {
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+
+// The one proposal→write path for a workspace branch policy, shared by the
+// OpenCode `workit_init_apply` branch_policy action (init.ts) and the CLI
+// wizard, so both produce byte-identical workspaces.json writes.
+export function applyWorkspaceBranchPolicy(opts: {
+  workspace_root: string;
+  env?: NodeJS.ProcessEnv;
+}): Record<string, any> {
+  const { workspace_root, env = process.env } = opts;
+  const dir = path.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const {
+    status,
+    path: wsPath,
+    entries,
+    document,
+    revision,
+    error: workspacesError,
+  } = readWorkspacesResult(dir);
+  if (status === "malformed" || status === "invalid")
+    return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
+  const detection = detectBranchPolicy(workspace_root);
+  const name = String(env.WORKFLOW_BP_NAME ?? path.basename(workspace_root));
+  const integration = (env.WORKFLOW_BP_INTEGRATION ?? detection.integration) as "pr" | "merge";
+  const policy = {
+    preset: detection.preset,
+    developBranch: env.WORKFLOW_BP_DEVELOP ?? detection.developBranch ?? undefined,
+    prefixes: detection.prefixes,
+    allowed: detection.allowed,
+    protected: detection.protected,
+    integration,
+  };
+  const glob = `${workspace_root.replace(/[\\/]+$/, "")}/**`;
+  if (!validateWorkspaceGlob(glob).ok)
+    return { ok: false, error: `invalid workspace glob: ${glob}` };
+  let existing: WorkspaceConfig | null;
+  try {
+    existing = resolveWorkspaceFrom(workspace_root, dir);
+  } catch (error) {
+    const selectedName = env.WORKFLOW_BP_NAME?.trim();
+    if (!selectedName)
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    try {
+      existing = resolveWorkspaceFrom(workspace_root, dir, selectedName);
+    } catch (selectionError) {
+      return {
+        ok: false,
+        error: selectionError instanceof Error ? selectionError.message : String(selectionError),
+      };
+    }
+  }
+  if (existing?.branchPolicy && isDeepStrictEqual(existing.branchPolicy, policy)) {
+    return {
+      ok: true,
+      status: "already-configured",
+      workspace: existing,
+      policy,
+      config_path: wsPath,
+    };
+  }
+  const next = existing
+    ? entries.map((w) => (w.name === existing?.name ? { ...w, branchPolicy: policy } : w))
+    : [...entries, { name, glob, branchPolicy: policy }];
+  if (!existing && entries.some((entry) => entry.name === name))
+    return { ok: false, error: `workspace name ${JSON.stringify(name)} is already configured` };
+  const proposed = validateWorkspacesDocument({ ...document, workspaces: next }, wsPath);
+  if (proposed.status !== "valid") return { ok: false, error: proposed.error };
+  if (workspacesRevision(readFileSafe(wsPath)) !== revision)
+    return {
+      ok: false,
+      error: `workspaces.json changed while applying the branch policy: ${wsPath}`,
+    };
+  mkdirSync(path.dirname(wsPath), { recursive: true });
+  const tmp = `${wsPath}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + "\n", "utf8");
+    if (workspacesRevision(readFileSafe(wsPath)) !== revision) {
+      rmSync(tmp, { force: true });
+      return {
+        ok: false,
+        error: `workspaces.json changed while applying the branch policy: ${wsPath}`,
+      };
+    }
+    renameSync(tmp, wsPath);
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {}
+    return {
+      ok: false,
+      error: `failed to write ${wsPath}: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+  return {
+    ok: true,
+    status: existing ? "updated" : "configured",
+    workspace: existing
+      ? { ...existing, branchPolicy: policy }
+      : { name, glob, branchPolicy: policy },
+    policy,
+    config_path: wsPath,
+  };
+}

package/src/forge/pr-ops.ts

@@ -241,6 +241,11 @@ export type MergeInput = {
   method: MergeMethod;
   deleteBranch: boolean;
   actor: LedgerActor;
+  /**
+   * Stack landing (S12): refuse unless the PR still targets this base and
+   * comes from this branch, re-checked right before the merge call.
+   */
+  expect?: { base: string; branch: string };
 };
 
 export type MergeOutcome = {
@@ -266,7 +271,8 @@ export type MergeRefusal = {
     | "head_mismatch"
     | "already_merged"
     | "closed"
-    | "protected_branch";
+    | "protected_branch"
+    | "base_mismatch";
   next?: string;
   blockers?: string[];
   verdict?: Pick<VerdictCheck, "head" | "accepted" | "authors">;
@@ -340,6 +346,12 @@ export async function mergePullRequest(
       { reason: "not_ready", next: doc.next, blockers: doc.blockers },
     );
 
+  if (input.expect && (doc.base !== input.expect.base || doc.head.branch !== input.expect.branch))
+    return refuse(
+      `base_mismatch: ${label} is ${doc.head.branch} -> ${doc.base}, expected ${input.expect.branch} -> ${input.expect.base}`,
+      "workit stack sync  # retarget it, then land again",
+      { reason: "base_mismatch" },
+    );
   const branch = doc.head.branch;
   const head = doc.head.sha;
   // --delete-branch never deletes a protected branch, the base, or the

package/src/hooks/hosts/opencode.ts

@@ -4,8 +4,8 @@ import type { HostDescriptor } from "../descriptor";
 export const OPENCODE_DESCRIPTOR: HostDescriptor = {
   host: "opencode",
   label: "OpenCode",
-  verifiedAgainst: "@opencode-ai/plugin 1.18.30",
-  docs: ["https://opencode.ai/docs/plugins/"],
+  verifiedAgainst: "@opencode/plugin 2.0.18",
+  docs: ["https://opencode.ai/v2/docs/build/plugins/"],
   transport: "in-process-plugin",
   events: {
     // No separate start event: context is injected on every agent-loop call.

package/src/ledger.ts

@@ -847,6 +847,47 @@ function effectiveOf(rows: readonly ReadRow[], authors: Set<string>): ReadRow |
   return effective;
 }
 
+/**
+ * Stacked branches (S12): a verdict keyed against the trunk cannot carry
+ * through a restack after its parent was squash-merged, because the
+ * trunk-relative diff loses the parent's change. `workit stack sync` observes
+ * each restack itself and records `stack.restacked` with `patchEqual` when
+ * the change relative to the parent is identical (same patch-id AND same
+ * exact diff hash, D18). A verdict carries when such observed rows link its
+ * head to the current head.
+ */
+function restackCarries(
+  rows: readonly ReadRow[],
+  branch: string,
+  from: string | null,
+  to: string | null,
+): boolean {
+  if (!from || !to) return false;
+  const edges = new Map<string, string[]>();
+  for (const row of rows)
+    if (
+      row.type === "stack.restacked" &&
+      row.observer === "workit_cli" &&
+      row.branch === branch &&
+      row.patchEqual === true &&
+      typeof row.fromHead === "string" &&
+      row.head
+    )
+      edges.set(row.fromHead, [...(edges.get(row.fromHead) ?? []), row.head]);
+  const seen = new Set<string>([from]);
+  const queue = [from];
+  while (queue.length) {
+    const next = queue.shift() as string;
+    if (next === to) return true;
+    for (const target of edges.get(next) ?? [])
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
+  }
+  return false;
+}
+
 /** Current and accepted verdicts for `branch`, after carry-over (D18). */
 export function checkVerdicts(cwd: string, branch: string, rows: readonly ReadRow[]): VerdictCheck {
   const head = branchHead(cwd, branch);
@@ -872,7 +913,8 @@ export function checkVerdicts(cwd: string, branch: string, rows: readonly ReadRo
   for (const [kind, list] of byKind) {
     const row = effectiveOf(list, authors);
     if (!row) continue;
-    const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    let basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    if (basis === "stale" && restackCarries(rows, branch, row.head, head)) basis = "carried";
     const current = basis !== "stale";
     const independence = independenceReasons(row, authors);
     const reasons: RejectReason[] = [