@brainervirus/workit-core 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "private": false,
   "description": "Workit — workflow rails for agentic coding: specs, plans, YouTrack, CI-gated commits (shared core)",
   "keywords": [

package/src/core/flow-state.ts

@@ -13,7 +13,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
 import { docsValidate, parseTasksFromPlan, qualitySpec, stripFences } from "./docs-validate";
 import { resolveCanonicalLayout } from "./docs-layout";
@@ -64,6 +64,27 @@ export type FlowExecutionState = {
    * every non-subagent-driven path and for legacy states without the field.
    */
   coordinator_session_id: string | null;
+  /**
+   * Cursor delegation capability state (cursor-subagent-inline CA-01..CA-05):
+   * only SHA-256 hashes are persisted — never a raw lease or token. Cursor has
+   * no host-visible parentID, so an accepted Cursor `subagent-driven` menu
+   * choice stores a coordinator-lease hash and returns the raw lease ONCE;
+   * `mintDelegateToken` stores one task-scoped token hash and returns the raw
+   * token once. Optional and absent (never serialized) for OpenCode/CLI flows
+   * and legacy states so pre-delegation flow.json bytes stay stable.
+   */
+  delegation?: FlowDelegationState | null;
+};
+
+export type FlowDelegationState = {
+  coordinator_lease_hash: string | null;
+  /** The task id the active token is bound to (one active token per flow). */
+  active_task_id: number | null;
+  token_hash: string | null;
+  /** Workspace root + slug the token hash is bound to (binding check). */
+  token_workspace: string | null;
+  token_slug: string | null;
+  status: "active" | "revoked";
 };
 
 /**
@@ -94,16 +115,6 @@ export const COORDINATOR_RECOVERY_TEXT =
   "Delegate product mutations to an authenticated delegated worker via `task` / `wk-implement` instead of " +
   "editing in the coordinator session.";
 
-/**
- * Cursor recovery guidance for the unsupported subagent-driven mutation path
- * (CA-42): the Cursor MCP has no child sessions, so it cannot run a
- * subagent-driven plan and must not enter that flow state.
- */
-export const CURSOR_SUBAGENT_UNSUPPORTED_TEXT =
-  "Cursor cannot execute subagent-driven plans: the MCP has no child-session " +
-  "support. Choose Inline, Handoff, or a review option in this session, or " +
-  "run the plan in OpenCode with `wk-implement`.";
-
 /**
  * The only acceptable approval / execution-menu evidence (FG-04, CA-19, AR-12).
  * Trust comes from HOST CAPABILITIES, never from caller-supplied fields:
@@ -278,19 +289,53 @@ const normalizeState = (parsed: unknown, slug: string): FlowState => {
       mode: (execution.mode ?? null) as ExecutionMode | null,
       evidence: (execution.evidence ?? null) as LifecycleEvidence | null,
       coordinator_session_id: execution.coordinator_session_id ?? null,
+      // Optional field: legacy flow.json without the key stays byte-stable
+      // (no serialized `delegation` appears unless delegation state exists).
+      ...(execution.delegation !== undefined
+        ? { delegation: normalizeDelegation(execution.delegation) }
+        : {}),
     },
     handoff_destination: p.handoff_destination ?? false,
     updated_at: p.updated_at ?? Date.now(),
   };
 };
 
+const normalizeDelegation = (v: unknown): FlowDelegationState | null => {
+  if (v === null || v === undefined) return null;
+  if (!isRecord(v)) return null;
+  const hash = (x: unknown): string | null =>
+    typeof x === "string" && HEX64_RE.test(x) ? x : null;
+  return {
+    coordinator_lease_hash: hash(v.coordinator_lease_hash),
+    active_task_id:
+      typeof v.active_task_id === "number" && Number.isSafeInteger(v.active_task_id)
+        ? v.active_task_id
+        : null,
+    token_hash: hash(v.token_hash),
+    token_workspace: typeof v.token_workspace === "string" ? v.token_workspace : null,
+    token_slug: typeof v.token_slug === "string" ? v.token_slug : null,
+    status: v.status === "active" ? "active" : "revoked",
+  };
+};
+
+// Cursor delegation persistence helper: raw lease/token values are hashed ONCE
+// here and only the hex digest is ever placed on FlowState (CA-01 spec). The
+// raw values are returned to the coordinator in tool results, never written.
+const delegationHash = (raw: string): string => createHash("sha256").update(raw).digest("hex");
+
 const emptyState = (slug: string): FlowState => ({
   slug,
   activated: false,
   spec: { path: "", status: "draft", evidence: null, approved_digest: null },
   plan: { path: "", status: "draft", evidence: null, approved_digest: null },
   menu: { presented: false, chosen: "", evidence: null },
-  execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
+  execution: {
+    status: "pending",
+    mode: null,
+    evidence: null,
+    coordinator_session_id: null,
+    delegation: null,
+  },
   handoff_destination: false,
   updated_at: Date.now(),
 });
@@ -478,6 +523,11 @@ const validateState = (
         evidence: (execRaw?.evidence as LifecycleEvidence | null | undefined) ?? null,
         coordinator_session_id:
           (execRaw?.coordinator_session_id as string | null | undefined) ?? null,
+        // Optional field: legacy flow.json without the key stays byte-stable
+        // (no serialized `delegation` appears unless delegation state exists).
+        ...(execRaw?.delegation !== undefined
+          ? { delegation: normalizeDelegation(execRaw.delegation) }
+          : {}),
       },
       handoff_destination: parsed.handoff_destination ?? false,
       updated_at: parsed.updated_at ?? Date.now(),
@@ -731,7 +781,13 @@ const resetForSpecDrift = (state: FlowState): FlowState => ({
   spec: { ...state.spec, status: "draft", evidence: null, approved_digest: null },
   plan: { ...state.plan, status: "draft", evidence: null, approved_digest: null },
   menu: { presented: false, chosen: "", evidence: null },
-  execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
+  execution: {
+    status: "pending",
+    mode: null,
+    evidence: null,
+    coordinator_session_id: null,
+    ...(state.execution.delegation !== undefined ? { delegation: null } : {}),
+  },
   handoff_destination: false,
   updated_at: Date.now(),
 });
@@ -821,7 +877,12 @@ const deriveLegacyExecution = (
       coordinator_session_id: null,
     };
   }
-  return { status: "pending", mode: null, evidence: null, coordinator_session_id: null };
+  return {
+    status: "pending",
+    mode: null,
+    evidence: null,
+    coordinator_session_id: null,
+  };
 };
 
 type CompatibilityResult = { state: FlowState; changed: boolean };
@@ -1605,7 +1666,12 @@ export const prepareFlowState = (
         spec: { path: specPath, status: "draft", evidence: null, approved_digest: null },
         plan: { path: planPath, status: "draft", evidence: null, approved_digest: null },
         menu: { presented: false, chosen: "", evidence: null },
-        execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
+        execution: {
+          status: "pending",
+          mode: null,
+          evidence: null,
+          coordinator_session_id: null,
+        },
         handoff_destination: false,
         updated_at: Date.now(),
       });
@@ -1753,6 +1819,8 @@ export const transitionPlan = (
   });
 };
 
+export type MenuChoiceResult = { ok: true; coordinator_lease?: string } | FlowError;
+
 export const recordMenuChoice = (
   root: string,
   slug: string,
@@ -1760,7 +1828,7 @@ export const recordMenuChoice = (
   choice: unknown,
   evidence: unknown,
   ctx?: MutationContext,
-): FlowGateResult => {
+): MenuChoiceResult => {
   const bound = assertMutationWorkspace(root, ctx);
   if (!bound.ok) return bound;
   const recorded = assertEvidenceShape(evidence);
@@ -1768,11 +1836,6 @@ export const recordMenuChoice = (
   if (typeof choice !== "string" || !MENU_CHOICES.includes(choice as MenuChoice)) {
     return err("menu_choice_invalid", `invalid menu choice: ${JSON.stringify(choice)}`);
   }
-  // Cursor cannot run subagent-driven plans (no child sessions): entering that
-  // flow state on Cursor is rejected with recovery guidance (CA-42).
-  if (recorded.evidence.host === "cursor" && choice === "subagent-driven") {
-    return err("unsupported_mode", CURSOR_SUBAGENT_UNSUPPORTED_TEXT);
-  }
   // The execution-menu evidence must be the label the user selected on the
   // native question; a mismatched choice is fabricated (FG-04). Comparison is
   // case-insensitive: the host presents "Inline", the enum stores "inline"
@@ -1789,7 +1852,13 @@ export const recordMenuChoice = (
   }
   const doc = resolveDoc(root, slug, planPath, "plan");
   if (!doc.ok) return err("path_invalid", doc.error);
-  return readModifyWrite(root, slug, (state) => {
+  // The Cursor coordinator lease is generated BEFORE the critical section so
+  // the raw value is returned exactly once and only the hash crosses the
+  // persisted-state boundary.
+  const cursorSubagent = recorded.evidence.host === "cursor" && choice === "subagent-driven";
+  const lease = cursorSubagent ? randomBytes(32).toString("hex") : null;
+  const leaseHash = lease === null ? null : delegationHash(lease);
+  const result = readModifyWrite(root, slug, (state) => {
     if (state.spec.status !== "approved")
       return err("spec_not_approved", "spec must be approved before the execution menu");
     if (state.plan.status !== "approved")
@@ -1808,13 +1877,24 @@ export const recordMenuChoice = (
     // pending. The menu evidence IS the lifecycle evidence — the choice the
     // user selected on the native question. The activating OpenCode
     // coordinator session (CA-12) is persisted ONLY for an accepted
-    // subagent-driven activation; inline/handoff/review choices and Cursor's
-    // rejected subagent path keep it null.
+    // subagent-driven activation; inline/handoff/review choices keep it null.
+    // Cursor's accepted subagent-driven path keeps it null too (no session
+    // identity): delegation authority comes from the coordinator lease instead.
     const executing = choice === "subagent-driven" || choice === "inline";
     const coordinatorSessionId =
       choice === "subagent-driven" && recorded.evidence.host === "opencode"
         ? (ctx?.sessionId ?? null)
         : null;
+    const delegation = cursorSubagent
+      ? {
+          coordinator_lease_hash: leaseHash,
+          active_task_id: null,
+          token_hash: null,
+          token_workspace: null,
+          token_slug: null,
+          status: "active" as const,
+        }
+      : state.execution.delegation;
     return {
       ok: true,
       next: {
@@ -1830,17 +1910,197 @@ export const recordMenuChoice = (
               mode: choice as ExecutionMode,
               evidence: recorded.evidence,
               coordinator_session_id: coordinatorSessionId,
+              delegation,
             }
           : {
               status: "pending",
               mode: null,
               evidence: recorded.evidence,
               coordinator_session_id: null,
+              delegation,
             },
         updated_at: Date.now(),
       },
     };
   });
+  if (!result.ok) return result;
+  return cursorSubagent && lease !== null ? { ok: true, coordinator_lease: lease } : { ok: true };
+};
+
+/**
+ * Cursor delegation capability model (cursor-subagent-inline CA-01..CA-05):
+ * the coordinator lease authorizes token minting; the task-scoped token
+ * authorizes delegated mutations. Only hashes persist — raw values cross the
+ * API boundary exactly once. Token lifecycle: one active token per flow,
+ * reusable within its task, revoked by `revokeDelegateToken` when the task
+ * progress line is recorded, replaced when the next task token mints.
+ */
+export type DelegateTokenResult = { ok: true; token: string } | FlowError;
+
+export const mintDelegateToken = (
+  root: string,
+  slug: string,
+  planPath: string,
+  taskId: number,
+  coordinatorLease: string,
+): DelegateTokenResult => {
+  if (typeof taskId !== "number" || !Number.isSafeInteger(taskId) || taskId <= 0) {
+    return err(
+      "task_invalid",
+      `task id must be a positive safe integer: ${JSON.stringify(taskId)}`,
+    );
+  }
+  if (typeof coordinatorLease !== "string" || coordinatorLease === "") {
+    return err(
+      "coordinator_lease_invalid",
+      "a coordinator lease is required to mint a delegation token",
+    );
+  }
+  const doc = resolveDoc(root, slug, planPath, "plan");
+  if (!doc.ok) return err("path_invalid", doc.error);
+  const token = randomBytes(32).toString("hex");
+  const tokenHash = delegationHash(token);
+  const result = readModifyWrite(root, slug, (state) => {
+    const exec = state.execution;
+    if (exec.status !== "active" || exec.mode !== "subagent-driven") {
+      return err(
+        "flow_not_active",
+        "a delegation token requires an active subagent-driven execution",
+      );
+    }
+    const delegation = exec.delegation;
+    if (!delegation || delegation.status !== "active" || !delegation.coordinator_lease_hash) {
+      return err(
+        "coordinator_lease_invalid",
+        "this flow has no active coordinator lease — record the execution menu with Cursor subagent-driven first",
+      );
+    }
+    if (delegation.coordinator_lease_hash !== delegationHash(coordinatorLease)) {
+      return err(
+        "coordinator_lease_invalid",
+        "the supplied coordinator lease does not match the flow's recorded lease",
+      );
+    }
+    if (state.plan.status !== "approved") {
+      return err("plan_not_approved", "plan must be approved before delegating a task");
+    }
+    let planText: string;
+    try {
+      planText = readFileSync(doc.path, "utf8");
+    } catch {
+      return err("plan_missing", `plan not found: ${planPath}`);
+    }
+    if (!parseTasksFromPlan(planText).some((t) => t.id === taskId)) {
+      return err("task_invalid", `task ${taskId} does not exist in the approved plan`);
+    }
+    if (ledgerCompletion(root, slug).completed.includes(taskId)) {
+      return err("task_completed", `task ${taskId} is already completed in the SDD ledger`);
+    }
+    return {
+      ok: true,
+      next: {
+        ...state,
+        execution: {
+          ...exec,
+          delegation: {
+            ...delegation,
+            active_task_id: taskId,
+            token_hash: tokenHash,
+            token_workspace: root,
+            token_slug: slug,
+            status: "active",
+          },
+        },
+        updated_at: Date.now(),
+      },
+    };
+  });
+  if (!result.ok) return result;
+  return { ok: true, token };
+};
+
+export type DelegateTokenContext = {
+  slug: string;
+  taskId: number;
+  hostWorkspace: string;
+};
+export type DelegateTokenValidation = { ok: true; context: DelegateTokenContext } | FlowError;
+
+export const validateDelegateToken = (root: string, token: string): DelegateTokenValidation => {
+  if (typeof token !== "string" || token === "") {
+    return err("delegation_token_invalid", "a delegation token is required");
+  }
+  const hash = delegationHash(token);
+  let entries: string[] = [];
+  try {
+    entries = readdirSync(path.join(root, "docs"), { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    return err("delegation_token_invalid", `no flows exist under ${JSON.stringify(root)}`);
+  }
+  for (const slug of entries) {
+    try {
+      const state = readFlowState(root, slug);
+      const delegation = state.execution.delegation;
+      if (!delegation || !delegation.token_hash) continue;
+      if (delegation.token_hash !== hash) continue;
+      if (delegation.token_workspace !== root || delegation.token_slug !== slug) continue;
+      if (
+        delegation.status !== "active" ||
+        state.execution.status !== "active" ||
+        state.execution.mode !== "subagent-driven" ||
+        delegation.active_task_id === null
+      ) {
+        return err(
+          "delegation_token_revoked",
+          "the delegation token is no longer active for this flow",
+        );
+      }
+      return {
+        ok: true,
+        context: { slug, taskId: delegation.active_task_id, hostWorkspace: root },
+      };
+    } catch {
+      // unreadable flow state: skip, never throw from validation
+    }
+  }
+  return err(
+    "delegation_token_invalid",
+    "the delegation token does not match any active flow token in this workspace",
+  );
+};
+
+export const revokeDelegateToken = (root: string, slug: string, taskId: number): FlowGateResult => {
+  if (typeof taskId !== "number" || !Number.isSafeInteger(taskId) || taskId <= 0) {
+    return err(
+      "task_invalid",
+      `task id must be a positive safe integer: ${JSON.stringify(taskId)}`,
+    );
+  }
+  return readModifyWrite(root, slug, (state) => {
+    const exec = state.execution;
+    const delegation = exec.delegation;
+    if (
+      !delegation ||
+      delegation.status !== "active" ||
+      delegation.active_task_id !== taskId ||
+      !delegation.token_hash
+    ) {
+      return err(
+        "delegation_token_not_active",
+        `no active delegation token for task ${taskId} in ${slug}`,
+      );
+    }
+    return {
+      ok: true,
+      next: {
+        ...state,
+        execution: { ...exec, delegation: { ...delegation, status: "revoked" } },
+        updated_at: Date.now(),
+      },
+    };
+  });
 };
 
 /**

package/templates/execution-contract.md

@@ -24,10 +24,10 @@ This session is a handoff destination for a continued plan. The originating sess
 - Working state, briefs, ledgers, and review diffs live only under gitignored `<SDD_DIR>` in `docs/<slug>/sdd/` and use `workit_sdd_*` tools.
 - Use native `todowrite` for visible task state as well as the gitignored ledger.
 - Use native `question` for branch/stash choices and guarded external mutations; call mutation tools only after approval with `confirmed: true` (grounded in the recorded NativeChoiceEvidence).
-- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workit_spec_approve` / `workit_plan_approve` / `workit_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`) and subagent-driven execution is rejected as unsupported.
+- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workit_spec_approve` / `workit_plan_approve` / `workit_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`), Subagent-driven execution is supported through the one-time `coordinator_lease` and per-task `delegation_token` minted by `workit_delegate` (fail-closed validation; no `parentID` identity exists on Cursor), and Inline runs single-agent in the current session.
 - Delegated authority is direct-child-only: a worker is the session whose host `parentID` exactly equals the activating coordinator's recorded `coordinator_session_id`; missing, mismatched, or multi-owner lineage fails closed with `delegation_lineage_denied`, and nested `opencode` launches are denied during active delegated work. An authorized child receives only the compact worker contract (execute the supplied brief, follow TDD, land one contiguous non-empty commit range, report results) — never coordinator guidance, `wk-implement`, or ledger management; coordinator bookkeeping via `workit_sdd_*` stays with the coordinator session.
 - On Cursor, for every repository-scoped `workit_*` call, pass the active Cursor workspace as `workspace_root`; never rely on the MCP process default.
-- Use native `task` with only the built-in `explore` and `general` agents.
+- Use native `task` with only the built-in `explore` and `general` agents (OpenCode); on Cursor, Subagent-driven dispatches Cursor-native subagents with a task `delegation_token`, Inline runs single-agent in the current session.
 
 ## Flow gates (HARD)
 
@@ -51,7 +51,7 @@ For each top-level task absent from `completed_task_ids`:
 
 1. Mark it `in_progress` with `todowrite`.
 2. Create a working-state brief with `workit_sdd_task_brief` and `confirmed: true`.
-3. Delegate read-only discovery, when needed, to an `explore` agent. Delegate implementation to a fresh `general` agent. Product changes follow TDD.
+3. Route by the approved execution mode: **Subagent-driven** delegates read-only discovery to an `explore` (OpenCode) agent, delegates implementation to a fresh `general` (OpenCode) agent (on Cursor, the coordinator mints a `delegation_token` with `workit_delegate` and the subagent prompt carries the raw token — the worker passes it as `delegation_token` on its mutation calls, and appending progress revokes it), and the coordinator never edits product code; **Inline** executes every task in the current agent with no dispatch and no token minting. Product changes follow TDD.
 4. Create a working-state diff with `workit_sdd_review_package` and `confirmed: true`.
 5. Delegate spec-compliance review and code-quality review to separate `general` agents.
 6. **Blocking** findings (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them with `workit_sdd_append_advisory` (`--task <id> --text <text>`, `confirmed: true`) instead of an unrestricted file edit.

package/templates/plan-template.md

@@ -1,6 +1,6 @@
 # <Feature> Implementation Plan
 
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. On Cursor the two paths are: **Subagent-driven** — Cursor-native subagents dispatched by the coordinator, each carrying a task-scoped `delegation_token` minted with `workit_delegate` from the one-time `coordinator_lease`; **Inline** — `executing-plans` in the current session, single-agent, no dispatch, no token minting. Steps use checkbox (`- [ ]`) syntax for tracking.
 
 **Spec:** `docs/<slug>/spec.md`
 **Branch:** `feature/<slug>`

package/templates/superpowers-doc-contract.md

@@ -1,6 +1,6 @@
 # Superpowers document contract
 
-Use OpenCode's native `question` for every bounded user choice. Give concise choices and allow a custom answer; if the tool is unavailable, ask one concise plain-text question. Use `skill` to load workflow and Superpowers skills, `todowrite` for task state, and `task` for delegated work.
+Use OpenCode's native `question` for every bounded user choice. Give concise choices and allow a custom answer; if the tool is unavailable, ask one concise plain-text question. Use `skill` to load workflow and Superpowers skills, `todowrite` for task state, and `task` for delegated work (OpenCode) or the host-native equivalent — on Cursor, Subagent-driven dispatches Cursor-native subagents with a task `delegation_token`, Inline runs single-agent in the current session.
 
 ## Tracked document layout
 
@@ -35,7 +35,7 @@ Before writing **Branch:** into a new spec or plan, call `workit_docs_branch` an
 - Commits use `wk-commit` after its native `question` confirmation.
 - Continuation uses `wk-handoff`, whose `workit_handoff_session` creates and seeds the OpenCode session automatically.
 - Never use worktrees. Resolve the declared branch with `workit_resolve_branch`, preview dirty-tree stash choices with `question`, and apply an approved in-place checkout through `workit_branch_setup` with `confirmed: true` (grounded in the recorded NativeChoiceEvidence).
-- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workit_spec_approve` / `workit_plan_approve` / `workit_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`) and subagent-driven execution is rejected as unsupported.
+- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workit_spec_approve` / `workit_plan_approve` / `workit_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`), Subagent-driven execution is supported through the one-time `coordinator_lease` and per-task `delegation_token` minted by `workit_delegate` (fail-closed validation; no `parentID` identity exists on Cursor), and Inline runs single-agent in the current session.
 - Keep all SDD state under the gitignored `docs/<slug>/sdd/`; use `workit_sdd_context` and the registered `workit_sdd_*` tools.
 - After implementation, use `question` before an approved stash reapply through `workit_branch_setup` with `confirmed: true`.
 

package/vendor/superpowers/skills/executing-plans/SKILL.md

@@ -7,11 +7,11 @@ description: Use when you have a written implementation plan to execute in a sep
 
 ## Overview
 
-Load plan, review critically, execute all tasks, report when complete.
+Load plan, review critically, execute all tasks in the current session, report when complete. This is the single-agent Inline execution path.
 
 **Announce at start:** "I'm using the executing-plans skill to implement this plan."
 
-**Note:** Tell your human partner that Superpowers works much better with access to subagents. The quality of its work will be significantly higher if run on a platform with subagent support (Claude Code, Codex CLI, Codex App, and Copilot CLI all qualify; see the per-platform tool refs in `../using-superpowers/references/`). If subagents are available, use superpowers:subagent-driven-development instead of this skill.
+**Note:** This skill is the single-agent Inline execution path: every task runs in the current session — no token minting, no subagent dispatching. Tell your human partner that Superpowers works much better with access to subagents. The quality of its work will be significantly higher if run on a platform with subagent support (Claude Code, Codex CLI, Codex App, and Copilot CLI all qualify; see the per-platform tool refs in `../using-superpowers/references/`). If subagents are available and the plan's approved execution mode is Subagent-driven, use superpowers:subagent-driven-development instead of this skill.
 
 ## The Process
 

package/vendor/superpowers/skills/subagent-driven-development/SKILL.md

@@ -11,6 +11,8 @@ Execute plan by dispatching a fresh implementer subagent per task, a task review
 
 **Core principle:** Fresh subagent per task + task review (spec + quality) + broad final review = high quality, fast iteration
 
+On Cursor, the coordinator mints a task-scoped delegation token via `workit_delegate` (from the `workit_plan_menu` coordinator lease) and the subagent prompt must carry it as `delegation_token` for mutation calls.
+
 **Narration:** between tool calls, narrate at most one short line — the
 ledger and the tool results carry the record.