@brainervirus/workit-core 1.2.1 → 1.3.1

package/src/core/init.ts

@@ -6,7 +6,7 @@ import { PLUGIN_ROOT } from "./scripts";
 import { writeFileExclusive } from "./safe-write";
 import { resolveWorkspace, workspacesPath } from "./workspaces";
 import { applyWorkspaceBranchPolicy } from "./setup";
-import { vcsTokenCreateUrls, vcsVerifyToken } from "./vcs-config";
+import { vcsConfig, vcsVerifyToken } from "./vcs-config";
 import { youTrackTokenCreateUrl, youTrackVerifyToken } from "./youtrack";
 
 const TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
@@ -181,32 +181,28 @@ export function initStatusData(configDirPath = configDir()): Record<string, any>
   items.push(youtrackTokenItem);
 
   let vcsCfg: Record<string, any> | null = null;
-  let tokenCreateUrls: Record<string, any> | null = null;
   const vcsParsed = readJson(vcsJson);
   if (vcsParsed) {
     const rawProvider = vcsParsed.provider;
+    const effective = vcsConfig("resolve", process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd());
     const provider =
-      typeof rawProvider === "string" && rawProvider.trim() ? rawProvider.toLowerCase() : null;
-    const tokenFiles: Record<string, string> = {};
-    for (const k of ["gitlab", "github"]) {
-      tokenFiles[k] = String(vcsParsed[k]?.tokenFile ?? path.join(configDirPath, `${k}.token`));
-    }
+      effective?.ok && typeof effective.provider === "string"
+        ? effective.provider
+        : typeof rawProvider === "string" && rawProvider.trim()
+          ? rawProvider.toLowerCase()
+          : null;
     vcsCfg = {
       config_edit_path: resolvePath(vcsJson),
       provider,
-      defaultTargetBranch: vcsParsed.defaultTargetBranch ?? "develop",
+      defaultTargetBranch: effective.ok
+        ? effective.defaultTargetBranch
+        : (vcsParsed.defaultTargetBranch ?? "develop"),
       pr: vcsParsed.pr ?? {},
-      tokenDefaults: vcsParsed.tokenDefaults,
       gitlab: vcsParsed.gitlab,
       github: vcsParsed.github,
       skill: "/wk-pr",
       switchHint: 'Set "provider" to "gitlab" or "github" in vcs.json',
     };
-    tokenCreateUrls = vcsTokenCreateUrls();
-    if (!("error" in vcsCfg)) {
-      vcsCfg.tokenCreate = tokenCreateUrls.active;
-      vcsCfg.tokenCreateUrls = { gitlab: tokenCreateUrls.gitlab, github: tokenCreateUrls.github };
-    }
   } else if (fs.existsSync(vcsJson)) {
     vcsCfg = { config_edit_path: resolvePath(vcsJson), error: "invalid vcs.json" };
   }
@@ -220,54 +216,6 @@ export function initStatusData(configDirPath = configDir()): Record<string, any>
     fix: "workit_init_apply action=vcs_scaffold",
   });
 
-  const provActive = vcsCfg && !("error" in vcsCfg) ? vcsCfg.provider : null;
-  const tokenItem = (tid: string, label: string, rawPath: string, providerKey: string) => {
-    const t = path.isAbsolute(rawPath) ? rawPath : path.resolve(configDirPath, rawPath);
-    const abs = fs.existsSync(t) ? resolvePath(t) : path.resolve(t);
-    const text = fs.existsSync(t) ? fs.readFileSync(t, "utf8").trim() : "";
-    const ph = isPlaceholder(text);
-    const ok = fs.existsSync(t) && modeOk(t) && Boolean(text) && !ph;
-    const item: Record<string, any> = {
-      id: tid,
-      label,
-      ok,
-      path: abs,
-      token_edit_path: abs,
-      placeholder: ph,
-      fix: `Open ${abs} — replace ${TOKEN_PLACEHOLDER}, save, then /wk-status`,
-      required: provActive === providerKey,
-    };
-    if (tokenCreateUrls) {
-      const block = tokenCreateUrls[providerKey] ?? {};
-      if (block.createUrl) item.token_create_url = block.createUrl;
-      if (block.createUrlClassic) item.token_create_url_classic = block.createUrlClassic;
-      if (block.scopes) item.token_scopes = block.scopes;
-      if (block.permissions) item.token_permissions = block.permissions;
-      if (block.name) item.token_name = block.name;
-    }
-    return item;
-  };
-  const vcsTokenFiles: Record<string, string> = {};
-  for (const k of ["gitlab", "github"]) {
-    vcsTokenFiles[k] = String(vcsParsed?.[k]?.tokenFile ?? path.join(configDirPath, `${k}.token`));
-  }
-  items.push(
-    tokenItem(
-      "gitlab_token",
-      "GitLab token (mode 600, not placeholder)",
-      vcsTokenFiles.gitlab,
-      "gitlab",
-    ),
-  );
-  items.push(
-    tokenItem(
-      "github_token",
-      "GitHub token (mode 600, not placeholder)",
-      vcsTokenFiles.github,
-      "github",
-    ),
-  );
-
   return {
     config_dir: configDirPath,
     plugin_root: PLUGIN_ROOT,
@@ -290,11 +238,6 @@ export async function toolkitStatusData(configDirPath = configDir()): Promise<Re
     typeof vcsCfg.provider === "string" && vcsCfg.provider.trim()
       ? vcsCfg.provider.toLowerCase()
       : null;
-  const vcsTokenId =
-    provider === "gitlab" ? "gitlab_token" : provider === "github" ? "github_token" : null;
-  const vcsTokenItem =
-    (vcsTokenId ? status.items.find((i: Record<string, any>) => i.id === vcsTokenId) : null) ?? {};
-  const vcsPlaceholder = vcsTokenId ? (vcsTokenItem.placeholder ?? true) : true;
   const vcsJsonOk = Boolean(status.items.find((i: Record<string, any>) => i.id === "vcs_json")?.ok);
 
   const verify = placeholder
@@ -306,16 +249,13 @@ export async function toolkitStatusData(configDirPath = configDir()): Promise<Re
           ok: false,
           error: "vcs provider unconfigured — set provider to gitlab or github in vcs.json",
         }
-      : vcsPlaceholder
-        ? { ok: false, error: "vcs token still placeholder YOUR_TOKEN_HERE" }
-        : await vcsVerifyToken();
+      : await vcsVerifyToken();
   const youTrackHealth = ("data" in verify ? verify.data : verify) as Record<string, any>;
 
   status.youtrack_verify = verify;
   status.youtrack_ok = placeholder ? false : Boolean(youTrackHealth.ok);
   status.vcs_verify = vcsVerify;
-  status.vcs_ok =
-    vcsJsonOk && !vcsPlaceholder ? Boolean((vcsVerify as Record<string, any>).ok) : false;
+  status.vcs_ok = vcsJsonOk && Boolean((vcsVerify as Record<string, any>).ok);
 
   const fsReady = status.items.every((i: Record<string, any>) => i.required === false || i.ok);
   status.ready = fsReady && Boolean(status.youtrack_ok) && (!vcsJsonOk || Boolean(status.vcs_ok));
@@ -328,13 +268,10 @@ export async function toolkitStatusData(configDirPath = configDir()): Promise<Re
     status.next_step = createUrl
       ? "Open the YouTrack create-token URL, New token (name workit, scope YouTrack), paste into the token file, save, then run /wk-status"
       : "Open the YouTrack token file, replace YOUR_TOKEN_HERE, save, then run /wk-status";
-  } else if (vcsJsonOk && vcsPlaceholder) {
-    status.vcs_token_edit_path = vcsTokenItem.token_edit_path ?? "";
-    status.next_step = `Open ${vcsTokenItem.token_edit_path ?? ""}, paste your ${provider} token, save, then run /wk-status`;
   } else if (!status.youtrack_ok) {
     status.next_step = "Fix YouTrack token or re-run /wk-init";
   } else if (vcsJsonOk && !status.vcs_ok) {
-    status.next_step = `Fix ${provider} token in vcs config or re-run /wk-init`;
+    status.next_step = `Run ${provider === "gitlab" ? "glab" : "gh"} auth login/switch, then /wk-status`;
   } else if (status.ready) {
     status.next_step = "All checks passed";
   }
@@ -376,31 +313,22 @@ const youtrackJsonContent = (dir: string): Record<string, any> => ({
   },
 });
 
-const vcsJsonContent = (dir: string, cwd?: string): Record<string, any> => {
+const vcsJsonContent = (): Record<string, any> => {
   // Explicit provider at init: env wins, else the checkout's origin remote
   // (same RL-03b rule as vcs-config). Unresolvable means the field is
   // omitted — never a silent assumption downstream.
-  const provider = resolveInitProvider(cwd);
+  const provider = resolveInitProvider();
   return {
     ...(provider ? { provider } : {}),
     defaultTargetBranch: process.env.WORKFLOW_VCS_TARGET_BRANCH ?? "develop",
     gitlab: {
       host: process.env.WORKFLOW_GITLAB_HOST ?? "gitlab.com",
       apiUrl: process.env.WORKFLOW_GITLAB_API_URL ?? "https://gitlab.com/api/v4",
-      tokenFile: path.join(dir, "gitlab.token"),
     },
     github: {
       host: process.env.WORKFLOW_GITHUB_HOST ?? "github.com",
-      tokenFile: path.join(dir, "github.token"),
     },
     pr: { squashOnMerge: true, removeSourceBranch: true, pushBranch: true, confirmSkip: true },
-    tokenDefaults: {
-      name: "workit",
-      description: "OpenCode workit — /wk-pr and glab/gh",
-      gitlabScopes: ["api"],
-      githubPermissions: { pull_requests: "write", contents: "write", metadata: "read" },
-      githubClassicScopes: ["repo"],
-    },
   };
 };
 
@@ -494,15 +422,7 @@ export function initApplyData(
     }
     case "vcs_scaffold": {
       const jsonOut = path.join(dir, "vcs.json");
-      fs.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(dir), null, 2) + "\n", "utf8");
-      const glPath = path.join(dir, "gitlab.token");
-      const ghPath = path.join(dir, "github.token");
-      const preservedTokens: string[] = [];
-      for (const p of [glPath, ghPath]) {
-        if (writeFileExclusive(p, TOKEN_PLACEHOLDER + "\n", 0o600) === "preserved") {
-          preservedTokens.push(path.resolve(p));
-        }
-      }
+      fs.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + "\n", "utf8");
       const configPath = path.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
@@ -510,39 +430,23 @@ export function initApplyData(
         const cfg = readJson(configPath) ?? {};
         const rawProvider = cfg.provider;
         const provider = typeof rawProvider === "string" && rawProvider.trim() ? rawProvider : null;
-        const tokenUrls = vcsTokenCreateUrls();
-        const active = tokenUrls.active ?? {};
-        const activePath =
-          provider === "gitlab"
-            ? path.resolve(glPath)
-            : provider === "github"
-              ? path.resolve(ghPath)
-              : null;
         return {
           action,
           ok: true,
           vcs_json: configPath,
           config_edit_path: configPath,
-          gitlab_token: path.resolve(glPath),
-          github_token: path.resolve(ghPath),
-          token_edit_path: activePath,
-          token_create_url: active.createUrl,
-          token_create_urls: tokenUrls,
-          preserved_tokens: preservedTokens,
           vcs_config: {
             config_edit_path: configPath,
             provider,
             defaultTargetBranch: cfg.defaultTargetBranch,
             pr: cfg.pr,
-            tokenCreate: active,
-            tokenCreateUrls: { gitlab: tokenUrls.gitlab, github: tokenUrls.github },
-            switchHint: 'Change "provider" to "github" when you migrate — token files are separate',
+            switchHint: 'Change "provider" to "github" when you migrate; authenticate with gh/glab',
             skill: "/wk-pr",
           },
           instruction:
             provider === null
               ? `No provider resolved — set provider to gitlab or github in ${configPath}, then /wk-status.`
-              : `Open the create-token URL for ${provider}, click Create, paste into ${activePath}, then /wk-status.`,
+              : `Run ${provider === "gitlab" ? "glab" : "gh"} auth login, then /wk-status.`,
         };
       } finally {
         if (prev === undefined) delete process.env.WORKFLOW_VCS_CONFIG;
@@ -565,9 +469,15 @@ export function initApplyData(
 
 export function initStatus(): Record<string, any> {
   const data = initStatusData();
+  const workspaces: Record<string, any> = { path: workspacesPath(), resolved: null };
+  try {
+    workspaces.resolved = resolveWorkspace(process.cwd());
+  } catch (error) {
+    workspaces.error = error instanceof Error ? error.message : String(error);
+  }
   return {
     ...data,
-    workspaces: { resolved: resolveWorkspace(process.cwd()), path: workspacesPath() },
+    workspaces,
   };
 }
 

package/src/core/legacy-ownership.ts

@@ -0,0 +1,47 @@
+// SHA-256 of generated Cursor assets in the published 1.2.1 package. These
+// hashes prove ownership for a narrow, known upgrade source; filenames alone
+// never authorize replacing an installed file.
+export const LEGACY_CURSOR_ASSET_DIGESTS: Readonly<Record<string, string>> = {
+  "commands/wk-babysit.md": "002b00bba340ace6bf64a605f7e26c56b6224010529dbf5fd8966102f0065553",
+  "commands/wk-blast-radius.md": "474030101d592fe61931baffd50158bf58987eb65902a594df26e53bd62e1d57",
+  "commands/wk-challenge.md": "65f3e3bf5ce2d2ec0b77d2fe061894a53c3de98ee5d00cba8cf6a8259b4c6f46",
+  "commands/wk-debug.md": "8a67a77da27df3e6416ec685f360c79537feac10c324baf4a2d6f3a0329d7623",
+  "commands/wk-deslop.md": "8d31b708225fcc8b6de12a8ce8b3e42c74a20821f1b86d347d969e0906bc1397",
+  "commands/wk-diagram.md": "d83a8b4b08f2e9ae30e7ee372b89ed400193ca6cc5fc918087b47283efe2b4a6",
+  "commands/wk-green-run.md": "0de645228cedb650ef24ade84d1800891a83ce39a568bc5f04f036542e1c0a4a",
+  "commands/wk-handoff.md": "525e3ea4717593826d6a2daf72bfdd35602b33dd77c6d03166e865ad29c65592",
+  "commands/wk-implement.md": "9e74766ba1829dbf04cc95e0c4d96fbeaafef57708ce6ff0d027a9ffad6de4c5",
+  "commands/wk-mockup.md": "9c441ada81c2b90510dd57804d25fc6b9ccc4f28870d98d1a3f2327e2b6564a4",
+  "commands/wk-plan.md": "8b3014450cdb1099f13628e983ce3b3d1566d8594c4bde8b31d74e8587b918ea",
+  "commands/wk-review.md": "4260e80e556a1b3042a3990cf1a53a4cb8ea74078667e5c24269f10c58f25f0e",
+  "commands/wk-steer.md": "251795b24df1395a4786d1565a2ab32a1f1d5321d33fbc3175bbf917a9c4ea1a",
+  "commands/wk-tdd.md": "b3e00a37d9ea1c0c133fc86aaf3c56b8d38bb443aded2ad05a06a9cc762c86f5",
+  "rules/workit-contract.mdc": "a7425e888f19c8984f784cc6395800f33ac094525863a894e5fba516ff7ff450",
+  "skills/workit-babysit/SKILL.md":
+    "a8958f7042be13048756a0c6ad7415feaf356132431b1d8b6e0f6617e34281a3",
+  "skills/workit-behavioral-tdd/SKILL.md":
+    "78207d684f9f50fa9c6d3ab68e425f71aa12975414c874975ce2daf427b9cf9d",
+  "skills/workit-blast-radius/SKILL.md":
+    "e829d3106a2b65c3f8aeceb53a1dbd3fadacbf1b1e1380a432e5e5f997e8a5a5",
+  "skills/workit-challenge/SKILL.md":
+    "60273fc7bdf7920e88e19c9d448f8d74a3e881dcce5f726f6aa947e4fc3881cf",
+  "skills/workit-debug/SKILL.md":
+    "e2776294e5ed3dc3c5c9d6c0d6321e53204cc4f0a7206424d32dca862d47d748",
+  "skills/workit-deslop/SKILL.md":
+    "e917dabad0fade7ee29bb4de36fd0bfeb9235d063951c3adad2f501c2d880f15",
+  "skills/workit-diagram/SKILL.md":
+    "d4a46c95d38b77e05f2246a3ab20b6ce8a5c5a2125df7c4ed5d4b79398307f9e",
+  "skills/workit-green-run/SKILL.md":
+    "f1bf1af81acd33c72f23a3f803a40c737bdd9e1a1889fb2c2b41ab9336679c4f",
+  "skills/workit-handoff/SKILL.md":
+    "855fc35166bb8886a1adca17f638ddb85508f36671bb034e00e1e0e2b403614a",
+  "skills/workit-implement/SKILL.md":
+    "7ba5adb7d6cf2acc34d25b10164e2af6b9f99d3bc5ef20ff5409b75e03e98bd4",
+  "skills/workit-mockup/SKILL.md":
+    "56fc4046599150874b498b269873d1522e671e72b17257fe312a4786205e15c3",
+  "skills/workit-plan/SKILL.md": "6283fdcc6c11c0267e679ce4eefbdd67e7fb5b819521dd86d9908a93bf78482e",
+  "skills/workit-review/SKILL.md":
+    "0f7c662abedd167589d3974013ff805df650dfc881d9709dfcfa4124c0dbe58d",
+  "skills/workit-steer/SKILL.md":
+    "5e7142010675d55c21ef84fc2b077f06163c27f95ff4d9ae22a7fda13c7ca543",
+};

package/src/core/methods.ts

@@ -87,56 +87,69 @@ export function selectMethods(policy: Policy, capabilities: Capability[]): Selec
 
 export const invariantBootstrap = (): string =>
   `
-Workit keeps one accountable lead and one shared task state. Inspect current task
-state before acting. An empty task.list means no session yet, not permission to
-skip Workit; for user-requested product, debug, or behavior work with no active
-or paused task, run task.start then policy.assess before other product mutations.
-Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
-to the current records; explicit values are still concurrency-checked, so never
-copy revisions between calls. Happy path: task.list, task.start {intent} with no
-revisions, policy.assess {assessment: {facts, signals, consequences,
-verification}} where facts are inferred or observed with file refs,
-writer.acquire {taskId} before product writes, evidence.record {evidence} where
-check and review kinds auto-bind the current tree and need no digests. Record
-self-review requirements with kind review and reviewContext matching your own
-host session; the lead may also record checks. Fresh-context review requires a
-session distinct from the task creator and every other evidence recorder. Record
-verification evidence last: later evidence or commits can reopen fixed findings
-for re-verification, so verify, resolve, then close with nothing in between.
-decision.record {binding with taskId/workspaceId from inspect plus presented and
-approvedContent} only through a native approval question asked receipt-shaped:
-header Workit decision: <purpose>, the same label repeated in the question
-text (some host UIs do not render headers), exactly two options approved and
-rejected; ask once, never re-ask to mint a receipt. Before asking, present the
-item in the conversation (durable artifacts: complete digest plus exact path;
-inline plans: the content) and keep the question to one short scoped sentence;
-never ask to approve something unseen. An answer with custom text is steering,
-not approval: adjust, re-present, then ask a new scoped question. After the user
-approves a spec or plan, execute the remaining tasks continuously with one
-atomic commit per task and do not ask whether to continue; stop only for a new
-product decision, a failed safety or verification gate, a conflicting edit, or
-missing authority. Record the plan's commit list once through the plan-scoped
-action approval (git.commit with plan_steps and plan_branch) so each listed
-commit executes without a new question; an unlisted message needs a fresh
-approval. task.close {outcome,
-summary, decisionIds}. A completed native subagent run stops its bound worker
-by itself; if a worker strands in cancelling with its run verifiably over,
-repeat worker.cancel {reason} to confirm the stop. Check and review evidence
-without a bound candidate goes stale; findings close only as fixed with passing
-verification, dismissed with supporting evidence, or deferred under an approved
-limitation. Use only the
-shared operations for task, policy, evidence, finding, decision, worker, writer,
-and state changes. Authority is bounded by the requested scope, current
-revision, caller/session provenance, and observed capabilities. Never claim host
-enforcement or evidence that the host cannot provide. Shell-executed writes are
-unattested agent-guided work even when a writer is held. Preserve unresolved
-requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
-always load on demand. Model-invoked: new instructions, interruptions, or
-forgotten items mid-task → load workit-steer before responding; about to open
-a PR or fresh from implementing → load workit-deslop; CI red → load
-workit-green-run; small-looking change before close or merge → load
-workit-blast-radius; ambiguous, consequential, or disputed proposal before
-recommending → load workit-challenge; spec or plan needs a flow diagram →
-load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
-act from memory of it.
+Workit is optional coordination and repository-policy tooling around the host,
+not a permission system or a mandatory workflow. Native host allow/ask/deny,
+sandbox, plan/read-only mode, and organization rules remain authoritative.
+Ordinary investigation, questions, non-Git work, and routine reversible edits
+need zero Workit task, assessment, or writer calls. Use one compact tracked
+record only when handoff, dependent steps, concurrent actors, or meaningful
+decisions make continuity useful; similar titles alone never merge tasks.
+
+For a routine user-authorized branch or commit, prefer native host Git/shell
+tools from the outset when managed coordination or outcome reconciliation is
+not needed. Inspect the actual target checkout and its configured conventions;
+use Workit's read-only context/policy tools when needed. Do not start a task,
+acquire a writer, or mint a decision receipt solely for a native Git action.
+Native permissions still apply. Never switch execution paths to evade a denial
+or repeat an uncertain managed effect. A local-commit endpoint does not imply
+PR readiness, a fresh review, or post-commit assessment/closure paperwork.
+
+For tracked work, inspect its current state and use the shared operations for
+task, policy, evidence, finding, decision, worker, writer, and state changes.
+Start a record once for an explicit tracked objective; assess or reassess only
+when policy selection or changed evidence/constraints requires it. Omitted
+expectedRevision and expectedWorkspaceRevision use current values; explicit
+values are still concurrency-checked, so never copy revisions between calls.
+A solo edit does not need writer acquisition; use it when concurrent checkout
+writers need coordination. Record only observed facts and checks. Evidence can
+become stale when its bound candidate changes; reconcile findings against the
+current candidate before recording completion.
+
+Workit validates domain policy against the actual action target, configured
+account, branch and commit conventions, protected refs, and current repository
+state. The task directory is coordination state, not a boundary on which
+repository may be changed. Use an action-time cwd target where a managed
+Git/hosting action supports it; a non-Git directory remains valid for OS work.
+GitHub/GitLab use the active gh/glab CLI identity; YouTrack uses its own token.
+Preserve uncertain external outcomes and reconcile repository/provider state
+before retrying. Internal reservations prevent duplicate or ambiguous effects;
+they are not permission tickets for every edit.
+
+Use host-native authorization through the host's supported path. A native
+question receipt records an actual question interaction; it is not automatic
+host permission. Record a meaningful user choice once with provenance when
+future retrieval helps. Never fabricate a receipt, re-ask only to mint one, or
+let imported decisions grant authority. Never turn a host deny into allow or
+claim enforcement/evidence a host cannot provide. A precise request with settled
+constraints does not need an interview. Present genuine unresolved options with
+evidence and a recommendation, then continue toward the requested delivery
+endpoint: investigation, implementation, PR/MR-ready, merge, or release. Run
+applicable checks and safe repairs without repeated continuation questions;
+stop for missing host authority, a new consequential choice, a conflicting edit,
+or an unresolved blocker. A tracked record may close when actual evidence
+supports its outcome; no final human closure ceremony is required.
+
+A completed native subagent run stops its bound worker by itself; if a worker
+strands in cancelling with its run verifiably over, repeat worker.cancel to
+confirm the stop. Preserve unresolved requirements, gaps, and uncertain workers.
+When context changes, distinguish a quick question, same-task adjustment, and
+separate request. Answer a quick question without pausing/resuming task state;
+park a concise checkpoint only when substantial work needs to continue later.
+
+Skill routing: slash aliases /wk-* load on demand. Use workit-steer for a
+substantial interruption or change of direction, workit-deslop when relevant
+to a PR-ready endpoint, workit-green-run for failing CI, workit-blast-radius
+when impact is uncertain, and workit-challenge for genuinely open consequential
+choices. Load workit-plan when dependencies or handoff need durable next actions.
+Load the skill; never act from memory of it.
 `.trim();

package/src/core/policy-resolver.ts

@@ -326,6 +326,11 @@ function resolveRequirements(input: NormalizedResolverInput): Requirement[] {
       }),
     );
 
+  const independentBehaviorReview =
+    input.preferences?.thorough === true ||
+    input.assessment.consequences.some((consequence) =>
+      ["security", "data", "public_contract", "operations"].includes(consequence.area),
+    );
   if (signals.behaviorChange.value === true)
     requirements.push(
       requirement({
@@ -340,15 +345,18 @@ function resolveRequirements(input: NormalizedResolverInput): Requirement[] {
         acceptanceAllowed: false,
       }),
       requirement({
-        ruleId: "fresh-context-review",
+        ruleId: independentBehaviorReview ? "fresh-context-review" : "self-review",
         dimension: "review",
         scope,
-        reason: "A non-mechanical behavior change requires fresh-context review.",
-        satisfaction:
-          "A separate review context examines the current candidate and records its result.",
+        reason: independentBehaviorReview
+          ? "Consequential behavior or the thorough preference requires fresh-context review."
+          : "Bounded behavior changes use self-review unless consequential risks or trusted rules require more.",
+        satisfaction: independentBehaviorReview
+          ? "A separate review context examines the current candidate and records its result."
+          : "The lead reviews the resulting diff and records the relevant scope and checks.",
         before: "close",
         dependentAction: null,
-        acceptanceAllowed: false,
+        acceptanceAllowed: !independentBehaviorReview,
       }),
     );
   else if (signals.mechanicalLowRisk.value === true)

package/src/core/ports/pr-create.ts

@@ -1,22 +1,30 @@
 // CLI port of scripts/pr-create.sh — create | --build-body.
-import { prBuildBody, prCreate } from "../pr-create";
+//
+// Decision ae03c569 re-enabled hosted PR/MR creation with pre/post provider SHA
+// verification and accepted the residual non-atomic source-SHA race. The legacy
+// create mode still cannot mint the native action receipt, the one-time action
+// reservation, or the target writer lease the shared contract requires, so it
+// never performs a hosted create itself. It returns the same needs_input shape
+// as the headless `workit action` route and points at the reserved,
+// TTY-confirmed shared path.
+import { prBuildBody } from "../pr-create";
 
 const mode = process.argv[2] ?? "create";
 if (mode === "--build-body") {
   console.log(JSON.stringify({ body: prBuildBody(process.env, process.cwd()) }));
   process.exit(0);
 }
-if (process.env.WF_PR_CONFIRMED !== "true") {
-  console.error("ERROR: confirmed=true required");
-  process.exit(1);
-}
-if (!process.env.WF_PR_TITLE) {
-  console.error("ERROR: title required");
-  process.exit(1);
-}
-const out = prCreate(process.env, process.cwd());
-if (out.error || out.ok === false) {
-  console.log(JSON.stringify(out));
-  process.exit(1);
-}
-console.log(JSON.stringify(out));
+console.log(
+  JSON.stringify({
+    ok: false,
+    schemaVersion: 1,
+    code: "needs_input",
+    error: "hosted PR/MR creation requires the reserved shared action path with TTY confirmation",
+    details: {
+      operation: "hosting.pull_request",
+      guidance:
+        "Run `workit action hosting.pull_request --payload <file> --confirm` from the target checkout: it records the one-time action reservation behind the terminal confirmation and verifies the provider PR head against the approved source SHA before reporting success.",
+    },
+  }),
+);
+process.exit(1);