agent-dealer 0.2.0 → 1.0.0

package/bundle/shared/dist/agents.js

@@ -1,33 +1,79 @@
 import { z } from "zod";
-import { PhaseBudget } from "./budget.js";
+import { PhaseBudget, parsePhaseBudget, serializePhaseBudget } from "./budget.js";
 import { Runtime } from "./runtime.js";
+import { PermissionPolicyOverride, ReasoningEffort } from "./profile-snapshot.js";
 /** Built-in agent IDs — stable across installs. */
 export const BUILTIN_AGENT_CLAUDE_ID = "00000000-0000-4000-a000-000000000001";
 export const BUILTIN_AGENT_CURSOR_ID = "00000000-0000-4000-a000-000000000002";
+export const BUILTIN_AGENT_CODEX_ID = "00000000-0000-4000-a000-000000000003";
 /** Cursor CLI model id for Auto + Composer subscription pool (not IDE default). */
 export const CURSOR_DEFAULT_MODEL = "auto";
 /** Cursor models that draw from the Auto + Composer pool on individual Pro plans. */
 export const CURSOR_SUBSCRIPTION_MODEL_IDS = ["auto", "composer-2.5", "composer-2.5-fast"];
 export const AgentHealthIssue = z.object({
-    code: z.enum(["cli_missing", "runtime_auth", "deck_offline", "workspace_missing", "mcp_not_registered"]),
+    code: z.enum([
+        "cli_missing",
+        "runtime_auth",
+        /**
+         * Cursor macOS keychain stuck (errSecDuplicateItem / exit 45) — sessions die mid-run
+         * even when status briefly looked logged-in (NOT-114 / NOT-103).
+         */
+        "cursor_keychain",
+        "usage_capped",
+        "deck_offline",
+        "deck_unauthorized",
+        /** @deprecated NOT-149 — no longer emitted; workspace is not an Agent concept. */
+        "workspace_missing",
+        /** Agent has no Deck — Dealer workers are fail-closed without one (NOT-149). */
+        "deck_missing",
+        "mcp_not_registered",
+        /** GitHub CLI missing — issue workflows need `gh` to open/update draft PRs. */
+        "github_cli_missing",
+        /** `gh auth status` failed / token invalid — PR create will burn a developer round. */
+        "github_auth",
+    ]),
     message: z.string(),
 });
 export const AgentProfile = z.object({
     id: z.string().uuid(),
     name: z.string(),
     runtime: Runtime,
+    /**
+     * Dead legacy storage (NOT-149). Retained so existing rows migrate safely; never shown
+     * in UI, never required by health/admission, and never copied into new profile snapshots.
+     */
     workspaceRoot: z.string().nullable(),
+    /** Required for any Agent used for execution — Dealer never starts without a Deck. */
     deckId: z.string().uuid().nullable(),
     deckName: z.string().nullable(),
+    /** Dead legacy storage (NOT-149) — playbooks are chosen dynamically inside the Deck. */
     playbookId: z.string().nullable(),
-    /** CLI model id for planning; null = runtime default */
+    /**
+     * Legacy phase defaults, read-only since NOT-71: nothing writes these any more, but
+     * profile-snapshot.ts still falls back to them so profiles saved before `defaultModel` /
+     * `defaultBudgetJson` existed keep their configured model and caps.
+     */
     defaultPlanModel: z.string().nullable(),
-    /** CLI model id for execution; null = runtime default */
     defaultExecuteModel: z.string().nullable(),
-    /** Serialized PhaseBudget; null = runtime default (no CLI caps) */
     defaultPlanBudgetJson: z.string().nullable(),
-    /** Serialized PhaseBudget; null = runtime default (no CLI caps) */
     defaultExecuteBudgetJson: z.string().nullable(),
+    /** Role-neutral CLI model id for issue-centric developer/reviewer sessions; null = runtime default. */
+    defaultModel: z.string().nullable(),
+    /**
+     * Default reasoning effort (NOT-81). Null = runtime default. Applied only for runtimes
+     * that expose a CLI-level effort control (Codex / Claude Code); Cursor ignores it.
+     */
+    defaultEffort: ReasoningEffort.nullable(),
+    /** Serialized PhaseBudget for issue-centric sessions; null = runtime default. */
+    defaultBudgetJson: z.string().nullable(),
+    /** Free-text description of what this profile is for (shown in the picker, snapshotted). */
+    purpose: z.string().nullable(),
+    /** Dead legacy storage (NOT-149). */
+    playbookIdsJson: z.string().nullable(),
+    /** Dead legacy storage (NOT-149). */
+    externalMemoryRefsJson: z.string().nullable(),
+    /** Serialized PermissionPolicyOverride — may only tighten the role's capabilities. */
+    permissionPolicyJson: z.string().nullable(),
     isBuiltin: z.boolean(),
     createdAt: z.string(),
     updatedAt: z.string(),
@@ -39,26 +85,46 @@ export const AgentWithHealth = AgentProfile.extend({
 export const CreateAgentInput = z.object({
     name: z.string().min(1),
     runtime: Runtime,
-    workspaceRoot: z.string().min(1),
-    deckId: z.string().uuid().optional(),
-    playbookId: z.string().optional(),
-    defaultPlanModel: z.string().nullable().optional(),
-    defaultExecuteModel: z.string().nullable().optional(),
-    defaultPlanBudget: PhaseBudget.nullable().optional(),
-    defaultExecuteBudget: PhaseBudget.nullable().optional(),
+    /** Exactly one Agent Deck — required; workers never start in no-Deck/degraded mode. */
+    deckId: z.string().uuid(),
+    defaultModel: z.string().nullable().optional(),
+    defaultEffort: ReasoningEffort.nullable().optional(),
+    defaultBudget: PhaseBudget.nullable().optional(),
+    purpose: z.string().nullable().optional(),
+    permissionPolicy: PermissionPolicyOverride.nullable().optional(),
 });
 export const UpdateAgentInput = z.object({
     name: z.string().min(1).optional(),
     runtime: Runtime.optional(),
-    workspaceRoot: z.string().nullable().optional(),
+    /** Null clears the deck (unhealthy until set again); omit leaves unchanged. */
     deckId: z.string().uuid().nullable().optional(),
-    playbookId: z.string().nullable().optional(),
-    defaultPlanModel: z.string().nullable().optional(),
-    defaultExecuteModel: z.string().nullable().optional(),
-    defaultPlanBudget: PhaseBudget.nullable().optional(),
-    defaultExecuteBudget: PhaseBudget.nullable().optional(),
+    defaultModel: z.string().nullable().optional(),
+    defaultEffort: ReasoningEffort.nullable().optional(),
+    defaultBudget: PhaseBudget.nullable().optional(),
+    purpose: z.string().nullable().optional(),
+    permissionPolicy: PermissionPolicyOverride.nullable().optional(),
 });
 export const AgentsSnapshot = z.object({
     agents: z.array(AgentWithHealth),
     issueCount: z.number(),
 });
+// The effective execution defaults for a profile.
+//
+// NOT-71 collapsed the plan/execute pair into one role-neutral column, but profiles
+// persisted before that still carry values only in the legacy columns. This is the
+// narrow read-compatibility path for those rows: it is the single definition of
+// "what this profile actually runs with", shared by the snapshot builder and the
+// agent edit form so the UI can never show blank while a hidden legacy value is in
+// force. updateAgent() normalizes the legacy columns away on the next write, so a
+// profile only takes this fallback until it is next edited.
+/** Role-neutral model, falling back through the legacy phase columns (execute → plan). */
+export function resolveProfileModel(agent) {
+    return agent.defaultModel ?? agent.defaultExecuteModel ?? agent.defaultPlanModel ?? null;
+}
+/** Role-neutral budget JSON, same fallback order as the model. */
+export function resolveProfileBudgetJson(agent) {
+    const budget = parsePhaseBudget(agent.defaultBudgetJson) ??
+        parsePhaseBudget(agent.defaultExecuteBudgetJson) ??
+        parsePhaseBudget(agent.defaultPlanBudgetJson);
+    return serializePhaseBudget(budget);
+}

package/bundle/shared/dist/cursor-auth-health.d.ts

@@ -0,0 +1,12 @@
+import type { AgentHealthIssue } from "./agents.js";
+/** Shared remediation for Cursor macOS keychain stuck-auth (NOT-114 / NOT-103). */
+export declare const CURSOR_KEYCHAIN_REMEDIATION: string;
+export declare const CURSOR_KEYCHAIN_HEALTH_ISSUE: AgentHealthIssue;
+/** True when Cursor status/login/stderr indicates a stuck macOS keychain item. */
+export declare function isCursorKeychainStuckOutput(output: string): boolean;
+/**
+ * Classify Cursor auth health from status/login/stderr text.
+ * Keychain stuck wins over generic "not logged in" (same remediations differ).
+ * Also usable by session failure classifiers (NOT-113) for the same remediation string.
+ */
+export declare function cursorAuthIssueFromOutput(output: string): AgentHealthIssue | null;

package/bundle/shared/dist/cursor-auth-health.js

@@ -0,0 +1,36 @@
+/** Shared remediation for Cursor macOS keychain stuck-auth (NOT-114 / NOT-103). */
+export const CURSOR_KEYCHAIN_REMEDIATION = "Cursor macOS keychain auth is stuck (errSecDuplicateItem). Delete the item and sign in again: " +
+    "`security delete-generic-password -s cursor-access-token -a cursor-user` then `agent login` " +
+    "(or `cursor-agent login`). See docs/TROUBLESHOOTING.md#cursor-macos-keychain-auth.";
+export const CURSOR_KEYCHAIN_HEALTH_ISSUE = {
+    code: "cursor_keychain",
+    message: CURSOR_KEYCHAIN_REMEDIATION,
+};
+const KEYCHAIN_STUCK_PATTERNS = [
+    /errsecduplicateitem/i,
+    /security exit code 45/i,
+    /keychain item is stuck/i,
+    /couldn't save your login to the macOS keychain/i,
+    /could not save your login to the macOS keychain/i,
+];
+/** True when Cursor status/login/stderr indicates a stuck macOS keychain item. */
+export function isCursorKeychainStuckOutput(output) {
+    return KEYCHAIN_STUCK_PATTERNS.some((re) => re.test(output));
+}
+/**
+ * Classify Cursor auth health from status/login/stderr text.
+ * Keychain stuck wins over generic "not logged in" (same remediations differ).
+ * Also usable by session failure classifiers (NOT-113) for the same remediation string.
+ */
+export function cursorAuthIssueFromOutput(output) {
+    if (isCursorKeychainStuckOutput(output)) {
+        return { ...CURSOR_KEYCHAIN_HEALTH_ISSUE };
+    }
+    const out = output.toLowerCase();
+    if (out.includes("not logged in") ||
+        out.includes("login required") ||
+        out.includes("not authenticated")) {
+        return { code: "runtime_auth", message: "Run cursor-agent login" };
+    }
+    return null;
+}

package/bundle/shared/dist/cursor-auth-health.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bundle/shared/dist/cursor-auth-health.test.js

@@ -0,0 +1,40 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { CURSOR_KEYCHAIN_HEALTH_ISSUE, cursorAuthIssueFromOutput, isCursorKeychainStuckOutput, } from "./cursor-auth-health.js";
+const STUCK_STDERR = `Cursor couldn't save your login to the macOS keychain (errSecDuplicateItem, security exit code 45).
+The keychain item is stuck. Delete it and sign in again:
+  security delete-generic-password -s cursor-access-token -a cursor-user
+  agent login
+`;
+test("isCursorKeychainStuckOutput detects errSecDuplicateItem", () => {
+    assert.equal(isCursorKeychainStuckOutput(STUCK_STDERR), true);
+});
+test("isCursorKeychainStuckOutput detects security exit code 45", () => {
+    assert.equal(isCursorKeychainStuckOutput("security exit code 45 while saving token"), true);
+});
+test("isCursorKeychainStuckOutput detects keychain item is stuck prose", () => {
+    assert.equal(isCursorKeychainStuckOutput("The keychain item is stuck."), true);
+});
+test("isCursorKeychainStuckOutput ignores healthy status", () => {
+    assert.equal(isCursorKeychainStuckOutput("Logged in as user@example.com\n"), false);
+    assert.equal(isCursorKeychainStuckOutput("not logged in"), false);
+});
+test("cursorAuthIssueFromOutput maps stuck stderr to cursor_keychain issue code", () => {
+    const issue = cursorAuthIssueFromOutput(STUCK_STDERR);
+    assert.ok(issue);
+    assert.equal(issue?.code, "cursor_keychain");
+    assert.equal(issue?.message, CURSOR_KEYCHAIN_HEALTH_ISSUE.message);
+    assert.match(issue.message, /security delete-generic-password/);
+    assert.match(issue.message, /cursor-access-token/);
+    assert.match(issue.message, /agent login|cursor-agent login/);
+});
+test("cursorAuthIssueFromOutput maps not-logged-in to runtime_auth", () => {
+    const issue = cursorAuthIssueFromOutput("Error: not logged in — run agent login");
+    assert.deepEqual(issue, {
+        code: "runtime_auth",
+        message: "Run cursor-agent login",
+    });
+});
+test("cursorAuthIssueFromOutput returns null for clean output", () => {
+    assert.equal(cursorAuthIssueFromOutput("✓ Logged in\n"), null);
+});

package/bundle/shared/dist/findings.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const FindingSeverity: z.ZodEnum<["blocking", "non_blocking"]>;
+export type FindingSeverity = z.infer<typeof FindingSeverity>;
+export declare const FindingStatus: z.ZodEnum<["open", "resolved", "recurring", "superseded"]>;
+export type FindingStatus = z.infer<typeof FindingStatus>;
+export declare const Finding: z.ZodObject<{
+    id: z.ZodString;
+    issueId: z.ZodString;
+    fingerprint: z.ZodString;
+    severity: z.ZodEnum<["blocking", "non_blocking"]>;
+    title: z.ZodString;
+    rationale: z.ZodString;
+    evidenceRef: z.ZodNullable<z.ZodString>;
+    file: z.ZodNullable<z.ZodString>;
+    line: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<["open", "resolved", "recurring", "superseded"]>;
+    firstRound: z.ZodNumber;
+    lastRound: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "resolved" | "recurring" | "superseded";
+    id: string;
+    issueId: string;
+    fingerprint: string;
+    severity: "blocking" | "non_blocking";
+    title: string;
+    rationale: string;
+    evidenceRef: string | null;
+    file: string | null;
+    line: number | null;
+    firstRound: number;
+    lastRound: number;
+}, {
+    status: "open" | "resolved" | "recurring" | "superseded";
+    id: string;
+    issueId: string;
+    fingerprint: string;
+    severity: "blocking" | "non_blocking";
+    title: string;
+    rationale: string;
+    evidenceRef: string | null;
+    file: string | null;
+    line: number | null;
+    firstRound: number;
+    lastRound: number;
+}>;
+export type Finding = z.infer<typeof Finding>;

package/bundle/shared/dist/findings.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const FindingSeverity = z.enum(["blocking", "non_blocking"]);
+export const FindingStatus = z.enum(["open", "resolved", "recurring", "superseded"]);
+export const Finding = z.object({
+    id: z.string().uuid(),
+    issueId: z.string().uuid(),
+    fingerprint: z.string(),
+    severity: FindingSeverity,
+    title: z.string(),
+    rationale: z.string(),
+    evidenceRef: z.string().nullable(),
+    file: z.string().nullable(),
+    line: z.number().int().nullable(),
+    status: FindingStatus,
+    firstRound: z.number().int().min(1),
+    lastRound: z.number().int().min(1),
+});

package/bundle/shared/dist/findings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bundle/shared/dist/findings.test.js

@@ -0,0 +1,20 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Finding } from "./findings.js";
+test("Finding schema parses an open finding", () => {
+    const finding = {
+        id: "88888888-8888-8888-8888-888888888888",
+        issueId: "11111111-1111-1111-1111-111111111111",
+        fingerprint: "missing-null-check-auth-ts-42",
+        severity: "blocking",
+        title: "Missing null check",
+        rationale: "user can be undefined here",
+        evidenceRef: "https://github.com/org/repo/pull/1#discussion_r1",
+        file: "src/auth.ts",
+        line: 42,
+        status: "open",
+        firstRound: 1,
+        lastRound: 1,
+    };
+    assert.deepStrictEqual(Finding.parse(finding), finding);
+});

package/bundle/shared/dist/github-repo.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/**
+ * Canonical portable GitHub repository identity stored on issues (NOT-149).
+ * Form: `github.com/<owner>/<repo>` (no scheme, no `.git`, no trailing slash).
+ */
+export declare const GitHubRepoIdentity: z.ZodString;
+export type GitHubRepoIdentity = z.infer<typeof GitHubRepoIdentity>;
+export interface ParsedGitHubRepo {
+    owner: string;
+    repo: string;
+    /** Canonical identity: `github.com/owner/repo`. */
+    identity: GitHubRepoIdentity;
+    /** HTTPS clone URL without credentials. */
+    cloneUrl: string;
+}
+/**
+ * True when the value looks like a local filesystem path (legacy issue.repo), not a
+ * portable GitHub identity or URL. Used for explicit compatibility routing — never
+ * silently guessed into a remote.
+ */
+export declare function looksLikeLocalRepoPath(value: string): boolean;
+/**
+ * Normalize a GitHub repository URL or `owner/repo` shorthand into a portable identity.
+ * Rejects local filesystem paths — those need an explicit migration path, not guessing.
+ */
+export declare function parseGitHubRepoInput(raw: string): ParsedGitHubRepo;
+/** Zod transform for Create/UpdateIssueInput.repo — accepts URL or owner/repo. */
+export declare const GitHubRepoInput: z.ZodEffects<z.ZodString, string, string>;

package/bundle/shared/dist/github-repo.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+/**
+ * Canonical portable GitHub repository identity stored on issues (NOT-149).
+ * Form: `github.com/<owner>/<repo>` (no scheme, no `.git`, no trailing slash).
+ */
+export const GitHubRepoIdentity = z
+    .string()
+    .regex(/^github\.com\/[^/]+\/[^/]+$/, "Expected github.com/<owner>/<repo>");
+const OWNER_REPO = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+/**
+ * True when the value looks like a local filesystem path (legacy issue.repo), not a
+ * portable GitHub identity or URL. Used for explicit compatibility routing — never
+ * silently guessed into a remote.
+ */
+export function looksLikeLocalRepoPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith("/") || trimmed.startsWith("~") || trimmed.startsWith("."))
+        return true;
+    // Windows drive / UNC
+    if (/^[A-Za-z]:[\\/]/.test(trimmed) || trimmed.startsWith("\\\\"))
+        return true;
+    return false;
+}
+/**
+ * Normalize a GitHub repository URL or `owner/repo` shorthand into a portable identity.
+ * Rejects local filesystem paths — those need an explicit migration path, not guessing.
+ */
+export function parseGitHubRepoInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Repository is required");
+    }
+    if (looksLikeLocalRepoPath(trimmed)) {
+        throw new Error("Local filesystem paths are no longer accepted. Pass a GitHub URL or owner/repo (e.g. https://github.com/acme/app or acme/app).");
+    }
+    let owner;
+    let repo;
+    // owner/repo shorthand
+    const short = OWNER_REPO.exec(trimmed);
+    if (short && !trimmed.includes("://") && !trimmed.toLowerCase().includes("github.com")) {
+        owner = short[1];
+        repo = short[2];
+    }
+    else {
+        // Strip credentials and normalize to a URL we can parse
+        let urlText = trimmed;
+        if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(urlText)) {
+            // github.com/owner/repo or git@github.com:owner/repo.git
+            if (urlText.startsWith("git@")) {
+                urlText = urlText.replace(/^git@([^:]+):/, "https://$1/");
+            }
+            else {
+                urlText = `https://${urlText}`;
+            }
+        }
+        let url;
+        try {
+            url = new URL(urlText);
+        }
+        catch {
+            throw new Error(`Unrecognized GitHub repository reference: ${raw}`);
+        }
+        if (!/^([^.]+\.)?github\.com$/i.test(url.hostname)) {
+            throw new Error(`Only github.com repositories are supported (got host ${url.hostname})`);
+        }
+        const parts = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
+        if (parts.length < 2 || !parts[0] || !parts[1]) {
+            throw new Error(`Unrecognized GitHub repository reference: ${raw}`);
+        }
+        owner = parts[0];
+        repo = parts[1].replace(/\.git$/i, "");
+    }
+    if (!owner || !repo || owner.includes("..") || repo.includes("..")) {
+        throw new Error(`Unrecognized GitHub repository reference: ${raw}`);
+    }
+    const identity = GitHubRepoIdentity.parse(`github.com/${owner}/${repo}`);
+    return {
+        owner,
+        repo,
+        identity,
+        cloneUrl: `https://github.com/${owner}/${repo}.git`,
+    };
+}
+/** Zod transform for Create/UpdateIssueInput.repo — accepts URL or owner/repo. */
+export const GitHubRepoInput = z
+    .string()
+    .min(1)
+    .transform((value, ctx) => {
+    try {
+        return parseGitHubRepoInput(value).identity;
+    }
+    catch (err) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: err.message });
+        return z.NEVER;
+    }
+});

package/bundle/shared/dist/github-repo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bundle/shared/dist/github-repo.test.js

@@ -0,0 +1,32 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { GitHubRepoInput, looksLikeLocalRepoPath, parseGitHubRepoInput, } from "./github-repo.js";
+test("parseGitHubRepoInput normalizes HTTPS URL, SSH, and owner/repo", () => {
+    assert.deepEqual(parseGitHubRepoInput("https://github.com/acme/app"), {
+        owner: "acme",
+        repo: "app",
+        identity: "github.com/acme/app",
+        cloneUrl: "https://github.com/acme/app.git",
+    });
+    assert.equal(parseGitHubRepoInput("https://github.com/acme/app.git").identity, "github.com/acme/app");
+    assert.equal(parseGitHubRepoInput("git@github.com:acme/app.git").identity, "github.com/acme/app");
+    assert.equal(parseGitHubRepoInput("github.com/acme/app").identity, "github.com/acme/app");
+    assert.equal(parseGitHubRepoInput("acme/app").identity, "github.com/acme/app");
+    assert.equal(parseGitHubRepoInput("  acme/app  ").identity, "github.com/acme/app");
+});
+test("parseGitHubRepoInput rejects local paths and non-GitHub hosts", () => {
+    assert.throws(() => parseGitHubRepoInput("/Users/me/projects/app"), /Local filesystem/);
+    assert.throws(() => parseGitHubRepoInput("~/projects/app"), /Local filesystem/);
+    assert.throws(() => parseGitHubRepoInput("./relative"), /Local filesystem/);
+    assert.throws(() => parseGitHubRepoInput("https://gitlab.com/acme/app"), /Only github.com/);
+    assert.throws(() => parseGitHubRepoInput(""), /required/);
+});
+test("looksLikeLocalRepoPath distinguishes legacy checkouts from portable refs", () => {
+    assert.equal(looksLikeLocalRepoPath("/tmp/repo"), true);
+    assert.equal(looksLikeLocalRepoPath("github.com/acme/app"), false);
+    assert.equal(looksLikeLocalRepoPath("acme/app"), false);
+});
+test("GitHubRepoInput zod transform stores the canonical identity", () => {
+    assert.equal(GitHubRepoInput.parse("acme/app"), "github.com/acme/app");
+    assert.throws(() => GitHubRepoInput.parse("/local/path"));
+});

package/bundle/shared/dist/human-actions.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export declare const HumanActionType: z.ZodEnum<["product_scope_decision", "policy_escalation", "attempts_exhausted", "final_review", "deck_interaction_required", "reflection_interaction_required", "outbound_delivery_interaction_required"]>;
+export type HumanActionType = z.infer<typeof HumanActionType>;
+export declare const HumanActionStatus: z.ZodEnum<["open", "resolved"]>;
+export type HumanActionStatus = z.infer<typeof HumanActionStatus>;
+export declare const HumanAction: z.ZodObject<{
+    id: z.ZodString;
+    /** Null for a Run-scoped action (`runId` set instead) — outbound-draft delivery parking
+     * (NOT-95) has no Issue. Exactly one of issueId/runId is set. */
+    issueId: z.ZodNullable<z.ZodString>;
+    /** Null for an Issue-scoped action. See `issueId`. */
+    runId: z.ZodNullable<z.ZodString>;
+    /** Nullable for pre-start product_scope_decision and imported legacy actions. */
+    workflowInstanceId: z.ZodNullable<z.ZodString>;
+    actionType: z.ZodEnum<["product_scope_decision", "policy_escalation", "attempts_exhausted", "final_review", "deck_interaction_required", "reflection_interaction_required", "outbound_delivery_interaction_required"]>;
+    reason: z.ZodString;
+    question: z.ZodString;
+    evidenceJson: z.ZodNullable<z.ZodString>;
+    responseOptionsJson: z.ZodNullable<z.ZodString>;
+    continuationPreviewJson: z.ZodNullable<z.ZodString>;
+    /** Agent Deck's own correlation id for the INTERACTION_REQUIRED response that raised
+     * this action (deck_interaction_required / reflection_interaction_required only) —
+     * null for every other action type and for one Deck raised without a correlation id
+     * (NOT-93). */
+    requestId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<["open", "resolved"]>;
+    resolutionJson: z.ZodNullable<z.ZodString>;
+    resolvedBy: z.ZodNullable<z.ZodString>;
+    requestedAt: z.ZodString;
+    resolvedAt: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "resolved";
+    id: string;
+    issueId: string | null;
+    runId: string | null;
+    workflowInstanceId: string | null;
+    actionType: "product_scope_decision" | "policy_escalation" | "attempts_exhausted" | "final_review" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
+    reason: string;
+    question: string;
+    evidenceJson: string | null;
+    responseOptionsJson: string | null;
+    continuationPreviewJson: string | null;
+    requestId: string | null;
+    resolutionJson: string | null;
+    resolvedBy: string | null;
+    requestedAt: string;
+    resolvedAt: string | null;
+}, {
+    status: "open" | "resolved";
+    id: string;
+    issueId: string | null;
+    runId: string | null;
+    workflowInstanceId: string | null;
+    actionType: "product_scope_decision" | "policy_escalation" | "attempts_exhausted" | "final_review" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
+    reason: string;
+    question: string;
+    evidenceJson: string | null;
+    responseOptionsJson: string | null;
+    continuationPreviewJson: string | null;
+    requestId: string | null;
+    resolutionJson: string | null;
+    resolvedBy: string | null;
+    requestedAt: string;
+    resolvedAt: string | null;
+}>;
+export type HumanAction = z.infer<typeof HumanAction>;

package/bundle/shared/dist/human-actions.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export const HumanActionType = z.enum([
+    "product_scope_decision",
+    "policy_escalation",
+    "attempts_exhausted",
+    "final_review",
+    /** Agent Deck returned a typed control-plane requirement (INTERACTION_REQUIRED) for a
+     * mint/tool call under execution authority (NOT-87) — the worker was released rather
+     * than left holding an in-flight call. */
+    "deck_interaction_required",
+    /** Agent Deck returned INTERACTION_REQUIRED while a completed issue's post-review
+     * reflection tried to read/propose against a playbook under execution authority
+     * (NOT-94) — parks that reflection attempt only. Deliberately distinct from
+     * `deck_interaction_required`: reflection runs after the issue is already `done`, and
+     * resolving this action never reopens the issue or enqueues developer/reviewer work,
+     * unlike `deck_interaction_required`'s "resume" choice. */
+    "reflection_interaction_required",
+    /** Agent Deck returned INTERACTION_REQUIRED while minting or calling authority for an
+     * approved outbound draft's delivery (NOT-95) — parks that delivery attempt only, on the
+     * legacy Run model rather than an Issue (outbound drafts predate the issue/coordinator
+     * kernel and never go through it). Resolved outside `resolveHumanActionOutcome` by
+     * `resolveOutboundDeliveryAction`, same reasoning as `reflection_interaction_required`. */
+    "outbound_delivery_interaction_required",
+]);
+export const HumanActionStatus = z.enum(["open", "resolved"]);
+export const HumanAction = z.object({
+    id: z.string().uuid(),
+    /** Null for a Run-scoped action (`runId` set instead) — outbound-draft delivery parking
+     * (NOT-95) has no Issue. Exactly one of issueId/runId is set. */
+    issueId: z.string().uuid().nullable(),
+    /** Null for an Issue-scoped action. See `issueId`. */
+    runId: z.string().uuid().nullable(),
+    /** Nullable for pre-start product_scope_decision and imported legacy actions. */
+    workflowInstanceId: z.string().uuid().nullable(),
+    actionType: HumanActionType,
+    reason: z.string(),
+    question: z.string(),
+    evidenceJson: z.string().nullable(),
+    responseOptionsJson: z.string().nullable(),
+    continuationPreviewJson: z.string().nullable(),
+    /** Agent Deck's own correlation id for the INTERACTION_REQUIRED response that raised
+     * this action (deck_interaction_required / reflection_interaction_required only) —
+     * null for every other action type and for one Deck raised without a correlation id
+     * (NOT-93). */
+    requestId: z.string().nullable(),
+    status: HumanActionStatus,
+    resolutionJson: z.string().nullable(),
+    resolvedBy: z.string().nullable(),
+    requestedAt: z.string(),
+    resolvedAt: z.string().nullable(),
+});

package/bundle/shared/dist/human-actions.test.d.ts

@@ -0,0 +1 @@
+export {};