@deftai/directive-core 0.95.0 → 0.97.0

package/dist/review-monitor/tier-detection.d.ts

@@ -1,6 +1,6 @@
 import { MONITORING_TIER_1, MONITORING_TIER_2, MONITORING_TIER_3 } from "./constants.js";
-/** Canonical Approach-1 platform primitives for review-monitor register/verify (#2655 / #2876). */
-export type PlatformPrimitive = "start_agent" | "spawn_subagent" | "cursor-task" | "sessions_spawn" | "openclaw-sessions-spawn";
+/** Canonical Approach-1 platform primitives for review-monitor register/verify (#2655 / #2876 / #3134). */
+export type PlatformPrimitive = "start_agent" | "spawn_subagent" | "cursor-task" | "claude-agent" | "sessions_spawn" | "openclaw-sessions-spawn";
 /** Accepted `--platform-primitive` values (register CLI + help text). */
 export declare const PLATFORM_PRIMITIVES: readonly PlatformPrimitive[];
 export declare const PLATFORM_PRIMITIVE_SET: Set<string>;
@@ -11,8 +11,12 @@ export interface MonitoringTierProbe {
 }
 /**
  * Inline Tier-1 detection aligned with the swarm Phase 3 / review-cycle matrix
- * (#1877 / #2655 / #2876). Prefer `task platform:capabilities` when available (#1357);
+ * (#1877 / #2655 / #2876 / #3134). Prefer `task platform:capabilities` when available (#1357);
  * this probe does not block MVP.
+ *
+ * Ordered env probe (must match skill matrix placement; Claude after Cursor so bare
+ * Task / CURSOR_* never misclassify Claude Code as cursor-composer):
+ * start_agent → WARP_* → Cursor → Claude Code → OpenClaw → grok-build → Tier2 → Tier3.
  */
 export declare function probeMonitoringTier(environ?: NodeJS.ProcessEnv): MonitoringTierProbe;
 export declare function isTier1(probe: MonitoringTierProbe): boolean;

package/dist/review-monitor/tier-detection.js

@@ -5,6 +5,7 @@ export const PLATFORM_PRIMITIVES = [
     "start_agent",
     "spawn_subagent",
     "cursor-task",
+    "claude-agent",
     "sessions_spawn",
     "openclaw-sessions-spawn",
 ];
@@ -28,8 +29,12 @@ function probeOverride(environ) {
 }
 /**
  * Inline Tier-1 detection aligned with the swarm Phase 3 / review-cycle matrix
- * (#1877 / #2655 / #2876). Prefer `task platform:capabilities` when available (#1357);
+ * (#1877 / #2655 / #2876 / #3134). Prefer `task platform:capabilities` when available (#1357);
  * this probe does not block MVP.
+ *
+ * Ordered env probe (must match skill matrix placement; Claude after Cursor so bare
+ * Task / CURSOR_* never misclassify Claude Code as cursor-composer):
+ * start_agent → WARP_* → Cursor → Claude Code → OpenClaw → grok-build → Tier2 → Tier3.
  */
 export function probeMonitoringTier(environ = process.env) {
     const override = probeOverride(environ);
@@ -53,6 +58,18 @@ export function probeMonitoringTier(environ = process.env) {
         };
     }
     const runtime = (environ.DEFT_AGENT_RUNTIME ?? "").trim().toLowerCase();
+    // Claude Code: Claude-unique env signals only — never bare "Task" (#3134).
+    // CLAUDECODE is set in Claude Code tool/hook subprocesses (Anthropic docs).
+    // DEFT_PROBE_CLAUDE_CODE / DEFT_AGENT_RUNTIME=claude-code are explicit overrides.
+    // Cursor already short-circuited above, so CURSOR_* never falls into this branch.
+    if (envTruthy(environ, "DEFT_PROBE_CLAUDE_CODE") ||
+        envTruthy(environ, "DEFT_HAS_CLAUDE_AGENT") ||
+        envTruthy(environ, "CLAUDECODE") ||
+        envTruthy(environ, "CLAUDE_CODE") ||
+        runtime === "claude-code" ||
+        runtime === "claude") {
+        return { tier: MONITORING_TIER_1, primitive: "claude-agent", descriptor: "claude-code" };
+    }
     // OpenClaw: sessions_spawn is the Tier-1 Approach 1 primitive (#2876).
     // Alias openclaw-sessions-spawn accepted on register for explicit naming.
     if (envTruthy(environ, "DEFT_PROBE_SESSIONS_SPAWN") ||

package/dist/review-monitor/verify.js

@@ -7,6 +7,24 @@ import { defaultSubagentStatusDir, fetchActiveMonitorFromGithub, readReviewMonit
 import { isTier1, probeMonitoringTier } from "./tier-detection.js";
 function spawnRedirect(probe) {
     const primitive = probe.primitive ?? "sub-agent";
+    // Claude Code / Cursor nested-leaf boundary (#2797 / #3134): lead with leaf-safe
+    // ownership so implementation leaves never treat nested Task/Agent spawn as the
+    // default instruction. Top-level parents that own the primitive still get the
+    // Approach 1 background path second.
+    if (primitive === "claude-agent" || primitive === "cursor-task") {
+        return (`Ownership path for ${primitive} (#2797 / #3134):\n` +
+            "  1. Implementation leaf (drive-to: merge-ready): keep ownership in THIS process " +
+            "via blocking dual-invoke `pr:watch` (`deft pr:watch <N>` then `task deft:pr:watch -- <N>`). " +
+            `Do NOT nested-spawn another ${primitive} review-monitor.\n` +
+            "  2. Or scope leaf `stop-at: pr-open` so the parent/orchestrator that owns " +
+            `${primitive} spawns a sibling monitor and registers it.\n` +
+            "  3. Top-level parent/orchestrator only: spawn Approach 1 via " +
+            `${primitive} (background), include templates/agent-prompt-preamble.md and ` +
+            "templates/swarm-greptile-poller-prompt.md, then:\n" +
+            "       task review-monitor:register -- --pr <N> --monitor-agent-id <id> " +
+            `--platform-primitive ${primitive}\n` +
+            "Re-run: task verify:review-monitor -- --pr <N>");
+    }
     return (`Spawn an Approach 1 review-monitor via ${primitive} (background), include ` +
         "`templates/agent-prompt-preamble.md` and `templates/swarm-greptile-poller-prompt.md`, " +
         "then register:\n" +

package/dist/scope/index.d.ts

@@ -7,6 +7,8 @@ export * from "./demote.js";
 export * from "./main.js";
 export * from "./open-umbrella-warning.js";
 export * from "./project-context.js";
+export * from "./promote-from-issue.js";
+export * from "./promote-path.js";
 export * from "./transition.js";
 export * from "./undo.js";
 export * from "./vbrief-json.js";

package/dist/scope/index.js

@@ -7,6 +7,8 @@ export * from "./demote.js";
 export * from "./main.js";
 export * from "./open-umbrella-warning.js";
 export * from "./project-context.js";
+export * from "./promote-from-issue.js";
+export * from "./promote-path.js";
 export * from "./transition.js";
 export * from "./undo.js";
 export * from "./vbrief-json.js";

package/dist/scope/main.d.ts

@@ -6,6 +6,16 @@ export interface LifecycleArgs {
     force?: boolean;
     batch?: boolean;
     batchFiles?: string[];
+    /** Promote from triage-cache issue number (#1136). */
+    fromIssue?: number;
+    /** Repo slug for --from-issue (#1136). */
+    repo?: string;
+    /** Missing decision hard-fails (#1136). */
+    strict?: boolean;
+    /** Skip triage reciprocity gate (#1136). */
+    forceNoCache?: boolean;
+    /** Disambiguate multiple proposed artifacts for --from-issue (#1136). */
+    pathFlag?: string;
     /** Explicit non-delivery disposition for code-bearing complete (#3041). */
     nonDeliveryDisposition?: NonDeliveryDisposition;
     /** Optional delivery evidence flags for complete (#3041). */

package/dist/scope/main.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { maybeRunStalenessTickler } from "../staleness-tickler/run.js";
 import { reconcileUmbrellas, renderUmbrellasReport } from "../vbrief-reconcile/umbrellas.js";
 import { canonicalLogPath, readAll } from "./audit-log.js";
@@ -9,14 +9,18 @@ import { isNonDeliveryDisposition, } from "./delivery-evidence.js";
 import { batchDemote, DEFAULT_OLDER_THAN_DAYS, demoteOne, resolveDemoteFilePath, resolveFilePath, resolveProjectRootStrict, } from "./demote.js";
 import { completedPathForScopeMove, findOpenUmbrellaReferences, renderOpenUmbrellaWarning, } from "./open-umbrella-warning.js";
 import { resolveProjectRoot } from "./project-context.js";
-import { recordWipCapOverride, runTransition } from "./transition.js";
+import { promoteFromIssue } from "./promote-from-issue.js";
+import { promotePath } from "./promote-path.js";
+import { runTransition } from "./transition.js";
 import { findByDecisionId, isAlreadyUndone, REVERSIBLE_ACTIONS, undoBatch, undoOne, } from "./undo.js";
-import { checkWipCap, formatWipCapRefusal } from "./wip-cap-check.js";
 const LIFECYCLE_USAGE_STDERR = "usage: scope_lifecycle.py [-h] [--project-root PROJECT_ROOT] [--force] [--batch]\n" +
+    "                          [--from-issue N] [--repo OWNER/NAME] [--strict] [--force-no-cache]\n" +
+    "                          [--path PATH]\n" +
     "                          {activate,block,cancel,complete,fail,promote,restore,unblock}\n" +
     "                          [file ...]\n" +
     "scope_lifecycle.py: error: the following arguments are required: action, file\n" +
-    "(promote --batch may omit file and promotes all proposed/ scopes; #3011)\n";
+    "(promote --batch may omit file and promotes all proposed/ scopes; #3011)\n" +
+    "(promote --from-issue=N may omit file; #1136)\n";
 function parseLifecycleArgv(argv) {
     if (argv.length < 1) {
         return { args: null, error: "usage" };
@@ -30,6 +34,10 @@ function parseLifecycleArgv(argv) {
     let force = false;
     let batch = false;
     const batchFiles = [];
+    let fromIssue;
+    let strict = false;
+    let forceNoCache = false;
+    let pathFlag;
     let nonDeliveryDisposition;
     let prNumber;
     let mergeCommit;
@@ -48,6 +56,37 @@ function parseLifecycleArgv(argv) {
         else if (arg === "--batch") {
             batch = true;
         }
+        else if (arg === "--strict") {
+            strict = true;
+        }
+        else if (arg === "--force-no-cache") {
+            forceNoCache = true;
+        }
+        else if (arg === "--from-issue") {
+            const raw = argv[i + 1];
+            i += 1;
+            if (raw === undefined || !/^[1-9]\d*$/.test(raw)) {
+                return { args: null, error: "usage" };
+            }
+            fromIssue = Number.parseInt(raw, 10);
+        }
+        else if (arg?.startsWith("--from-issue=")) {
+            const raw = arg.slice("--from-issue=".length);
+            if (!/^[1-9]\d*$/.test(raw)) {
+                return { args: null, error: "usage" };
+            }
+            fromIssue = Number.parseInt(raw, 10);
+        }
+        else if (arg === "--path") {
+            pathFlag = argv[i + 1];
+            i += 1;
+            if (pathFlag === undefined) {
+                return { args: null, error: "usage" };
+            }
+        }
+        else if (arg?.startsWith("--path=")) {
+            pathFlag = arg.slice("--path=".length);
+        }
         else if (arg === "--project-root") {
             projectRoot = argv[i + 1];
             i += 1;
@@ -127,18 +166,20 @@ function parseLifecycleArgv(argv) {
             return { args: null, error: "usage" };
         }
     }
+    // Delivery evidence uses --repo as repository; --from-issue also uses --repo as triage slug.
+    // Prefer treating --repo as triage slug when --from-issue is set (#1136).
     const deliveryEvidence = prNumber !== undefined ||
         mergeCommit !== undefined ||
         prBase !== undefined ||
         deliveryBranch !== undefined ||
-        repo !== undefined ||
+        (repo !== undefined && fromIssue === undefined) ||
         mergedAt !== undefined
         ? {
             prNumber: prNumber !== undefined && Number.isFinite(prNumber) ? prNumber : null,
             mergeCommit: mergeCommit ?? null,
             prBase: prBase ?? null,
             deliveryBranch: deliveryBranch ?? null,
-            repository: repo ?? null,
+            repository: fromIssue === undefined ? (repo ?? null) : null,
             mergedAt: mergedAt ?? (mergeCommit !== undefined ? "supplied" : null),
             verifier: "scope:complete",
         }
@@ -158,6 +199,27 @@ function parseLifecycleArgv(argv) {
             },
         };
     }
+    if (fromIssue !== undefined) {
+        if (action !== "promote") {
+            return { args: null, error: "usage" };
+        }
+        if (Number.isNaN(fromIssue) || fromIssue < 1) {
+            return { args: null, error: "usage" };
+        }
+        return {
+            args: {
+                action,
+                file: file.length > 0 ? file : (pathFlag ?? ""),
+                projectRoot,
+                force,
+                fromIssue,
+                repo,
+                strict,
+                forceNoCache,
+                pathFlag: pathFlag ?? (file.length > 0 ? file : undefined),
+            },
+        };
+    }
     if (file.length === 0) {
         return { args: null, error: "usage" };
     }
@@ -181,7 +243,7 @@ export function lifecycleMain(argv) {
         }
         return 2;
     }
-    const { action, file, projectRoot, force, batch, batchFiles, nonDeliveryDisposition, deliveryEvidence, } = parsed.args;
+    const { action, file, projectRoot, force, batch, batchFiles, fromIssue, repo, strict, forceNoCache, pathFlag, nonDeliveryDisposition, deliveryEvidence, } = parsed.args;
     if (batch === true && action === "promote") {
         const result = batchPromote({
             files: batchFiles && batchFiles.length > 0 ? batchFiles : undefined,
@@ -203,21 +265,54 @@ export function lifecycleMain(argv) {
         }
         return result.exitCode;
     }
+    if (fromIssue !== undefined && action === "promote") {
+        const result = promoteFromIssue({
+            issueNumber: fromIssue,
+            repo: repo ?? null,
+            projectRoot,
+            force: force === true,
+            forceNoCache: forceNoCache === true,
+            strict: strict === true,
+            explicitPath: pathFlag,
+        });
+        for (const line of result.warnings) {
+            process.stderr.write(`${line}\n`);
+        }
+        if (result.ok) {
+            process.stdout.write(`${result.message}\n`);
+            if (result.wipCapOverride) {
+                process.stderr.write("\u26a0  WIP cap exceeded; promote allowed via --force. " +
+                    "audit: scope-lifecycle.jsonl entry tagged wip_cap_override (#1124).\n");
+            }
+            return 0;
+        }
+        process.stderr.write(`Error: ${result.message}\n`);
+        return result.exitCode;
+    }
     const [filePath, error] = resolveFilePath(file, projectRoot);
     if (error !== null || filePath === null) {
         process.stderr.write(`Error: ${error}\n`);
         return 2;
     }
-    let capCheck = null;
+    // Path-based promote uses shared promotePath for WIP + optional audit consistency (#1136).
     if (action === "promote") {
-        const rootForCap = resolveProjectRoot(projectRoot);
-        if (rootForCap !== null) {
-            capCheck = checkWipCap(rootForCap, force === true);
-            if (!capCheck.allowed) {
-                process.stderr.write(`${formatWipCapRefusal(capCheck)}\n`);
-                return 1;
+        const promoteResult = promotePath(filePath, {
+            projectRoot,
+            force: force === true,
+        });
+        if (promoteResult.ok) {
+            process.stdout.write(`${promoteResult.message}\n`);
+            if (promoteResult.wipCapOverride) {
+                process.stderr.write("\u26a0  WIP cap exceeded " +
+                    `(promote allowed via --force). ` +
+                    "audit: scope-lifecycle.jsonl entry tagged wip_cap_override (#1124).\n");
             }
+            return 0;
         }
+        process.stderr.write(promoteResult.exitCode === 1 && promoteResult.message.includes("WIP")
+            ? `${promoteResult.message}\n`
+            : `Error: ${promoteResult.message}\n`);
+        return promoteResult.exitCode;
     }
     const transitionOptions = {
         nonDeliveryDisposition,
@@ -226,16 +321,6 @@ export function lifecycleMain(argv) {
     };
     const result = runTransition(action, filePath, new Date(), transitionOptions);
     if (result.ok) {
-        if (action === "promote" && capCheck !== null && capCheck.forceOverride) {
-            const rootForAudit = resolveProjectRoot(projectRoot);
-            if (rootForAudit !== null) {
-                const newPath = join(rootForAudit, "vbrief", "pending", filePath.split(/[/\\]/).pop() ?? "");
-                recordWipCapOverride(newPath, rootForAudit, capCheck);
-            }
-            process.stderr.write("\u26a0  WIP cap exceeded " +
-                `(count=${capCheck.count}, cap=${capCheck.cap}); promote allowed via --force. ` +
-                "audit: vbrief/.eval/scope-lifecycle.jsonl entry tagged wip_cap_override (#1124).\n");
-        }
         process.stdout.write(`${result.message}\n`);
         if (action === "complete") {
             try {

package/dist/scope/promote-from-issue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * scope:promote --from-issue reciprocity gate (#1136 / D18).
+ *
+ * Gates promote of a proposed scope on the latest triage-cache decision for
+ * the issue, locates the proposed artifact via provenance scan, and runs the
+ * shared promotePath path (WIP rules unchanged).
+ */
+import type { AuditEntry } from "../triage/actions/types.js";
+import { type PromotePathResult } from "./promote-path.js";
+export interface PromoteFromIssueOptions {
+    readonly issueNumber: number;
+    readonly repo?: string | null;
+    readonly projectRoot?: string;
+    /** WIP-cap override. */
+    readonly force?: boolean;
+    /** Skip reciprocity gate; still audit that force was used. */
+    readonly forceNoCache?: boolean;
+    /** Missing decision becomes hard fail (default: soft warn + proceed). */
+    readonly strict?: boolean;
+    readonly actor?: string;
+    /** Explicit path when multiple proposed artifacts match the issue. */
+    readonly explicitPath?: string;
+    readonly now?: Date;
+    /** Optional candidates-log path override (tests). */
+    readonly candidatesLogPath?: string;
+    /** Inject latest decision (tests). */
+    readonly latestDecision?: AuditEntry | null;
+}
+export interface PromoteFromIssueResult extends PromotePathResult {
+    readonly warnings: string[];
+    readonly repo: string | null;
+    readonly matchedPaths: string[];
+    readonly cacheStateAtPromote: string | null;
+    readonly cacheDecisionId: string | null;
+}
+/**
+ * Locate lifecycle artifacts whose provenance owns ``issueNumber`` (optionally repo-scoped).
+ */
+export declare function findLifecycleArtifactsForIssue(projectRoot: string, issueNumber: number, options?: {
+    folder?: "proposed" | "pending";
+    repo?: string | null;
+}): string[];
+/** Locate proposed/ artifacts for issue N (repo-scoped when provided). */
+export declare function findProposedArtifactsForIssue(projectRoot: string, issueNumber: number, repo?: string | null): string[];
+/**
+ * Promote the proposed scope for an issue, gated on triage-cache latestDecision.
+ */
+export declare function promoteFromIssue(options: PromoteFromIssueOptions): PromoteFromIssueResult;
+//# sourceMappingURL=promote-from-issue.d.ts.map