overlord-cli 4.12.0 → 4.14.0

package/README.md

@@ -30,7 +30,7 @@ Common commands:
 ```bash
 ovld auth login
 ovld attach
-ovld create "Investigate the failing build"
+ovld create "Investigate the failing build" --agent codex
 ovld prompt "Draft a fix for the onboarding flow"
 ovld update
 ovld protocol discover-project
@@ -52,7 +52,7 @@ ovld doctor
 ## Commands
 
 - `attach` - search tickets and launch an agent interactively
-- `create` - create a ticket from a short objective
+- `create` - create a ticket from a short objective; supports the same delegate-identifying flags as `ovld protocol create` (`--agent`, `--model`, `--delegate`)
 - `prompt` - create a ticket and launch an agent on it
 - `auth` - log in, log out, or check auth status
 - `tickets` - list or create tickets

package/bin/_cli/index.mjs

@@ -29,7 +29,7 @@ Primary command: ${primaryCommand}
 
 Usage:
   ${primaryCommand} attach [ticketId] [agent]  Search tickets and launch an agent (interactive)
-  ${primaryCommand} create "<objective>"       Create a ticket with numbered project selection
+  ${primaryCommand} create "<objective>"       Create a ticket with numbered project selection; supports --agent/--model/--delegate
   ${primaryCommand} prompt "<objective>"       Create a ticket, then launch an agent on it
   ${primaryCommand} auth <subcommand>          Login, logout, repair, or check auth status
   ${primaryCommand} tickets <subcommand>       Create or list tickets
@@ -46,7 +46,7 @@ Usage:
 
 Agents:
   Use ${primaryCommand} protocol help for ticket lifecycle commands.
-  Key protocol commands: auth-status, discover-project, spawn, attach, connect, load-context.
+  Key protocol commands: auth-status, discover-project, create, spawn, attach, connect, load-context.
 
 Auth:
   ${primaryCommand} auth login               Authorize CLI via browser
@@ -55,7 +55,7 @@ Auth:
   ${primaryCommand} auth logout              Remove stored credentials
 
 Tickets:
-  ${primaryCommand} create "..." [options]
+  ${primaryCommand} create "..." [--agent <agent>] [--model <identifier>] [--delegate <agent>] [options]
   ${primaryCommand} prompt "..." [options]
   ${primaryCommand} tickets create "..." [options]
   ${primaryCommand} tickets list [--status <status>]

package/bin/_cli/new-ticket.mjs

@@ -47,10 +47,10 @@ function parseFlags(args) {
 
 function buildUsage(commandName) {
   if (commandName === 'prompt') {
-    return 'Usage: ovld prompt "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--agent <agent>] [--delegate <agent>]';
+    return 'Usage: ovld prompt "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--agent <agent>] [--model <identifier>] [--delegate <agent>]';
   }
 
-  return 'Usage: ovld create "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--delegate <agent>]';
+  return 'Usage: ovld create "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--agent <agent>] [--model <identifier>] [--delegate <agent>]';
 }
 
 function ensureObjective(commandName, objective) {
@@ -192,10 +192,27 @@ export function resolvePromptAgentIdentifier(agent) {
   return PROMPT_AGENT_IDENTIFIERS[agent] ?? agent;
 }
 
-export function resolveTicketCreationDelegate(flags = {}, selectedAgent = null) {
+export function resolveTicketCreationModelIdentifier(flags = {}) {
+  const explicitModel = typeof flags.model === 'string' ? flags.model.trim() : '';
+  if (explicitModel) return explicitModel;
+
+  const envModel =
+    process.env.OVERLORD_MODEL_IDENTIFIER?.trim() ||
+    process.env.MODEL_IDENTIFIER?.trim() ||
+    process.env.AGENT_MODEL?.trim();
+  return envModel || null;
+}
+
+export function resolveTicketCreationDelegate(flags = {}, selectedAgent = null, modelIdentifier = '') {
   const explicitDelegate = typeof flags.delegate === 'string' ? flags.delegate.trim() : '';
   if (explicitDelegate) return explicitDelegate;
 
+  const resolvedModel = typeof modelIdentifier === 'string' ? modelIdentifier.trim() : '';
+  if (resolvedModel) return resolvedModel;
+
+  const explicitAgent = typeof flags.agent === 'string' ? flags.agent.trim() : '';
+  if (explicitAgent) return resolvePromptAgentIdentifier(explicitAgent.toLowerCase()) ?? explicitAgent;
+
   if (selectedAgent) return resolvePromptAgentIdentifier(selectedAgent);
 
   const envAgent = process.env.AGENT_IDENTIFIER?.trim();
@@ -233,7 +250,8 @@ async function runTicketCreationFlow(args, { commandName, launchAgent }) {
       })))
     : null;
 
-  const ticketDelegate = resolveTicketCreationDelegate(flags, selectedAgent);
+  const modelIdentifier = resolveTicketCreationModelIdentifier(flags);
+  const ticketDelegate = resolveTicketCreationDelegate(flags, selectedAgent, modelIdentifier);
 
   const ticket = await createTicket(platformUrl, agentToken, localSecret, {
     objective,
@@ -262,7 +280,7 @@ export async function runCreateCommand(args) {
 Creates a ticket after interactive numbered project selection.
 
 Examples:
-  ovld create "Implement login page"
+  ovld create "Implement login page" --agent codex
   ovld create "Fix sync bug" --project-id <project-id>
 `);
     return;
@@ -279,7 +297,7 @@ Creates a ticket after interactive numbered project selection, then lets you pic
 
 Examples:
   ovld prompt "Implement login page"
-  ovld prompt "Investigate flaky tests" --agent codex
+  ovld prompt "Investigate flaky tests" --agent codex --model gpt-5.4
 `);
     return;
   }

package/bin/_cli/protocol.mjs

@@ -43,10 +43,13 @@ export function resolveProtocolAgentIdentifier(flags = {}) {
   return envAgent || 'claude-code';
 }
 
-export function resolveProtocolTicketDelegate(flags = {}, agentIdentifier = '') {
+export function resolveProtocolTicketDelegate(flags = {}, modelIdentifier = '', agentIdentifier = '') {
   const explicitDelegate = typeof flags.delegate === 'string' ? flags.delegate.trim() : '';
   if (explicitDelegate) return explicitDelegate;
 
+  const resolvedModel = typeof modelIdentifier === 'string' ? modelIdentifier.trim() : '';
+  if (resolvedModel) return resolvedModel;
+
   const resolvedAgent = String(agentIdentifier).trim();
   return resolvedAgent || null;
 }
@@ -1039,6 +1042,7 @@ async function protocolSpawn(args) {
   const { platformUrl, agentToken, localSecret } = resolveAuth();
   const timeoutMs = resolveTimeout(flags);
   const agentIdentifier = resolveProtocolAgentIdentifier(flags);
+  const modelIdentifier = resolveProtocolModelIdentifier(flags);
 
   // When --project-id is not provided, auto-send cwd as workingDirectory
   // so the server can resolve the project from the local_working_directory setting.
@@ -1056,7 +1060,7 @@ async function protocolSpawn(args) {
     ...(flags['acceptance-criteria'] ? { acceptanceCriteria: String(flags['acceptance-criteria']) } : {}),
     ...(flags['available-tools'] ? { availableTools: String(flags['available-tools']) } : {}),
     ...(flags['execution-target'] ? { executionTarget: String(flags['execution-target']) } : {}),
-    delegate: resolveProtocolTicketDelegate(flags, agentIdentifier),
+    delegate: resolveProtocolTicketDelegate(flags, modelIdentifier, agentIdentifier),
     ...(flags['parent-session-key'] ? { parentSessionKey: String(flags['parent-session-key']) } : {}),
     ...(flags['parent-ticket-id'] ? { parentTicketId: String(flags['parent-ticket-id'] ?? process.env.TICKET_ID ?? '') } : {})
   };
@@ -1082,6 +1086,93 @@ async function protocolSpawn(args) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// create (create follow-up ticket draft only)
+// ---------------------------------------------------------------------------
+
+async function protocolCreateTicket(args) {
+  const flags = parseFlags(args);
+  const { sessionKey, ticketId } = resolveSessionFlags(flags);
+  const objective = requireFlag(flags, 'objective', undefined);
+  const { platformUrl, agentToken, localSecret } = resolveAuth();
+  const timeoutMs = resolveTimeout(flags);
+  const agentIdentifier = resolveProtocolAgentIdentifier(flags);
+  const modelIdentifier = resolveProtocolModelIdentifier(flags);
+
+  const hasSessionContext = Boolean(sessionKey && ticketId);
+
+  // Follow-up mode: create a draft ticket linked to the current session ticket.
+  if (hasSessionContext) {
+    const body = {
+      sessionKey,
+      ticketId,
+      objective,
+      ...(flags.title ? { title: String(flags.title) } : {}),
+      ...(flags.priority ? { priority: String(flags.priority) } : {}),
+      ...(flags['acceptance-criteria'] ? { acceptanceCriteria: String(flags['acceptance-criteria']) } : {}),
+      ...(flags['available-tools'] ? { availableTools: String(flags['available-tools']) } : {}),
+      ...(flags['execution-target'] ? { executionTarget: String(flags['execution-target']) } : {}),
+      delegate: resolveProtocolTicketDelegate(flags, modelIdentifier, agentIdentifier)
+    };
+
+    const data = await apiPost(
+      platformUrl,
+      agentToken,
+      localSecret,
+      '/api/protocol/create-ticket',
+      body,
+      timeoutMs
+    );
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  // Standalone mode: resolve project from cwd/--working-directory first, then create draft ticket.
+  if (sessionKey || ticketId) {
+    throw new Error(
+      'Provide both --session-key and --ticket-id for follow-up create, or provide neither for standalone create.'
+    );
+  }
+
+  const workingDirectory = String(flags['working-directory'] ?? process.cwd());
+  const discovered = await apiPost(
+    platformUrl,
+    agentToken,
+    localSecret,
+    '/api/protocol/discover-project',
+    { workingDirectory },
+    timeoutMs
+  );
+
+  const projectId = discovered?.project?.id;
+  if (!projectId) {
+    throw new Error(
+      'Could not resolve project from working directory. Set project local working directory in Overlord or pass --working-directory.'
+    );
+  }
+
+  const standaloneBody = {
+    objective,
+    projectId,
+    ...(flags.title ? { title: String(flags.title) } : {}),
+    ...(flags.priority ? { priority: String(flags.priority) } : {}),
+    ...(flags['acceptance-criteria'] ? { acceptanceCriteria: String(flags['acceptance-criteria']) } : {}),
+    ...(flags['available-tools'] ? { availableTools: String(flags['available-tools']) } : {}),
+    ...(flags['execution-target'] ? { executionTarget: String(flags['execution-target']) } : {}),
+    delegate: resolveProtocolTicketDelegate(flags, modelIdentifier, agentIdentifier)
+  };
+
+  const data = await apiPost(
+    platformUrl,
+    agentToken,
+    localSecret,
+    '/api/protocol/tickets',
+    standaloneBody,
+    timeoutMs
+  );
+  console.log(JSON.stringify(data, null, 2));
+}
+
 // ---------------------------------------------------------------------------
 // auth-status (agent-friendly auth diagnostics)
 // ---------------------------------------------------------------------------
@@ -1118,9 +1209,9 @@ export async function runProtocolCommand(subcommand, args) {
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log(`ovld protocol <subcommand> [flags]
 
-Use this for agent workflow on a ticket: create one with \`ovld protocol spawn\`,
-attach with \`ovld protocol attach --ticket-id <id>\`, then begin executing with
-\`ovld protocol update --phase execute\`.
+Use this for ticket lifecycle work from an agent runtime: create a standalone
+draft with \`ovld protocol create\`, create-and-attach with \`ovld protocol spawn\`,
+or attach to an existing ticket with \`ovld protocol attach --ticket-id <id>\`.
 
 Project discovery:
   When spawning or creating tickets, the CLI automatically resolves the correct
@@ -1139,6 +1230,7 @@ Subcommands:
   attach                    Start a ticket session and return full working context
   connect                   Start a lightweight session without full context
   load-context              Read ticket context without creating a session
+  create                    Create a draft ticket without attaching (follow-up or standalone)
   spawn                     Create a follow-up ticket and attach to it immediately
   update                    Post progress, activity events, and optional change rationales
   record-change-rationales  Persist structured change rationales without a progress update
@@ -1335,6 +1427,31 @@ spawn:
   Returns:
     New ticket/session JSON plus SESSION_KEY and TICKET_ID on stderr when available
 
+create:
+  Purpose:
+    Create a draft ticket without attaching to it.
+    If session flags are provided, creates a follow-up draft linked to the current ticket.
+    If session flags are omitted, resolves project by working directory and creates a standalone draft.
+  Required:
+    --objective <text>
+  Optional:
+    --session-key <key>
+    --ticket-id <id>
+    --working-directory <path>  Resolve project by local working directory (default: cwd)
+    --title <text>
+    --priority <level>        low | medium | high | urgent
+    --acceptance-criteria <text>
+    --available-tools <text>
+    --execution-target <t>    agent | human
+    --delegate <model>        Model or delegate identifier that created the ticket
+    --agent <identifier>
+    --model <identifier>
+  Returns:
+    New draft ticket JSON (follow-up draft when session flags are provided)
+  Notes:
+    Standalone create auto-discovers the project from the current working directory.
+    Follow-up create requires both --session-key and --ticket-id.
+
 artifact-prepare-upload:
   Required:
     --session-key <key>
@@ -1388,6 +1505,8 @@ Examples:
   ovld protocol attach --ticket-id abc-123 --external-session-id null
   ovld protocol connect --ticket-id abc-123
   ovld protocol load-context --ticket-id abc-123
+  ovld protocol create --agent codex --objective "Capture follow-up work from this repo"
+  ovld protocol create --agent codex --session-key <key> --ticket-id <id> --objective "Capture follow-up work"
   ovld protocol spawn --agent codex --objective "Implement user auth" --priority high
   ovld protocol update --session-key <key> --ticket-id <id> --summary "Did X" --phase execute
   ovld protocol update --session-key <key> --ticket-id <id> --summary-file ./update.txt --event-type user_follow_up
@@ -1413,6 +1532,7 @@ Examples:
   if (subcommand === 'attach') { await protocolAttach(args); return; }
   if (subcommand === 'connect') { await protocolConnect(args); return; }
   if (subcommand === 'load-context') { await protocolLoadContext(args); return; }
+  if (subcommand === 'create' || subcommand === 'create-ticket') { await protocolCreateTicket(args); return; }
   if (subcommand === 'spawn') { await protocolSpawn(args); return; }
   if (subcommand === 'artifact-prepare-upload') { await protocolArtifactPrepareUpload(args); return; }
   if (subcommand === 'artifact-finalize-upload') { await protocolArtifactFinalizeUpload(args); return; }

package/bin/_cli/setup.mjs

@@ -14,7 +14,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { checkForCliUpdate, getCurrentCliVersion, printCliUpdateNotice } from './cli-update.mjs';
 
-const BUNDLE_VERSION = '1.8.0';
+const BUNDLE_VERSION = '1.9.0';
 const MD_MARKER_START = '<!-- overlord:managed:start -->';
 const MD_MARKER_END = '<!-- overlord:managed:end -->';
 const MANIFEST_DIR = path.join(os.homedir(), '.ovld');
@@ -110,6 +110,21 @@ ovld protocol record-change-rationales --session-key <sessionKey> --ticket-id $T
 
 Record only meaningful behavioral changes — skip formatting-only noise. Prefer 1–5 concise rationales per ticket, each tied to a specific file and diff hunk.
 
+## Project Discovery & Ticket Creation
+
+When creating tickets from within a repository:
+- Prefer \`ovld protocol create --agent claude-code\` by default for draft ticket creation.
+- Use \`ovld protocol spawn --agent claude-code\` only when the user explicitly asks to create and execute immediately.
+- Both commands can resolve the project from the current working directory; use \`--working-directory\` to override.
+
+\`\`\`bash
+ovld protocol create --agent claude-code --objective "Capture follow-up work from this repository"
+\`\`\`
+
+\`\`\`bash
+ovld protocol spawn --agent claude-code --objective "Implement feature X" --priority medium
+\`\`\`
+
 ## Context & Artifacts
 
 \`\`\`bash
@@ -174,6 +189,21 @@ ovld protocol record-change-rationales --session-key <sessionKey> --ticket-id $T
   --change-rationales-json '[{"label":"Add backoff","file_path":"lib/api.ts","summary":"Added retry.","why":"Transient failures.","impact":"Retries 3x.","hunks":[{"header":"@@ -22,4 +22,18 @@"}]}]'
 \`\`\`
 
+## Project Discovery & Ticket Creation
+
+When creating tickets from within a repository:
+- Prefer \`ovld protocol create --agent opencode\` by default for draft ticket creation.
+- Use \`ovld protocol spawn --agent opencode\` only when the user explicitly asks to create and execute immediately.
+- Both commands can resolve the project from the current working directory; use \`--working-directory\` to override.
+
+\`\`\`bash
+ovld protocol create --agent opencode --objective "Capture follow-up work from this repository"
+\`\`\`
+
+\`\`\`bash
+ovld protocol spawn --agent opencode --objective "Implement feature X" --priority medium
+\`\`\`
+
 ## Context & Artifacts
 
 \`\`\`bash
@@ -236,6 +266,7 @@ For larger delivery JSON, prefer \`--payload-file -\` with stdin so no scratch f
 Rules:
 - Always attach first and deliver last.
 - Use \`ovld protocol\` commands instead of ad hoc repo scripts for ticket lifecycle work.
+- Prefer \`ovld protocol create --agent cursor\` for draft ticket creation; use \`spawn --agent cursor\` only for create-and-execute requests.
 - If the user sends a new message during an active ticket session, publish a \`user_follow_up\` event before doing anything else.
 `;
 
@@ -356,6 +387,16 @@ disable-model-invocation: true
 ---
 
 Run \`ovld protocol load-context --ticket-id <ticketId>\` using \`$ARGUMENTS\` as the ticket ID.`
+      },
+      {
+        path: path.join(base, 'create.md'),
+        content: `---
+description: Create a draft Overlord ticket from the current conversation
+argument-hint: <objective or raw flags>
+disable-model-invocation: true
+---
+
+Run \`ovld protocol create --agent claude-code\` with \`$ARGUMENTS\`. If no flags are present, treat the arguments as the objective and call \`ovld protocol create --agent claude-code --objective "<objective>"\`.`
       },
       {
         path: path.join(base, 'spawn.md'),
@@ -383,6 +424,11 @@ Run \`ovld protocol spawn --agent claude-code\` with \`$ARGUMENTS\`. If no flags
         content:
           'Load Overlord ticket context without attaching.\n\nRun `ovld protocol load-context --ticket-id <ticketId>` using the text after `/load` as the ticket ID.\n'
       },
+      {
+        path: path.join(base, 'create.md'),
+        content:
+          'Create a draft Overlord ticket.\n\nRun `ovld protocol create --agent cursor --objective "<objective>"` using the text after `/create` unless raw flags were provided. If raw flags were provided, pass them after `ovld protocol create --agent cursor`.\n'
+      },
       {
         path: path.join(base, 'spawn.md'),
         content:
@@ -404,6 +450,11 @@ Run \`ovld protocol spawn --agent claude-code\` with \`$ARGUMENTS\`. If no flags
         content:
           'description = "Load Overlord ticket context without creating a new session."\nprompt = """\nRun `ovld protocol load-context --ticket-id <ticketId>` using `{{args}}` as the ticket ID.\n"""\n'
       },
+      {
+        path: path.join(base, 'create.toml'),
+        content:
+          'description = "Create a draft Overlord ticket from the current conversation."\nprompt = """\nRun `ovld protocol create --agent gemini --objective "<objective>"` using `{{args}}` as the objective unless raw flags were provided. If raw flags were provided, pass them after `ovld protocol create --agent gemini`.\n"""\n'
+      },
       {
         path: path.join(base, 'spawn.toml'),
         content:
@@ -431,6 +482,15 @@ agent: build
 ---
 
 Run \`ovld protocol load-context --ticket-id <ticketId>\` using \`$ARGUMENTS\` as the ticket ID. If no ticket ID was provided, ask the user for one and stop.`
+    },
+    {
+      path: path.join(base, 'create.md'),
+      content: `---
+description: Create a draft Overlord ticket from the current conversation
+agent: build
+---
+
+Run \`ovld protocol create --agent opencode\` with \`$ARGUMENTS\`. If no flags are present, treat the arguments as the objective and call \`ovld protocol create --agent opencode --objective "<objective>"\`.`
     },
     {
       path: path.join(base, 'spawn.md'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overlord-cli",
-  "version": "4.12.0",
+  "version": "4.14.0",
   "description": "Overlord CLI — launch AI agents on tickets from anywhere",
   "type": "module",
   "bin": {

package/plugins/claude/README.md

@@ -5,7 +5,7 @@ Claude Code plugin that exposes the Overlord local ticket workflow to any Claude
 ## What ships
 
 - `skills/overlord-ticket/SKILL.md` — durable attach → update → ask → deliver workflow.
-- `commands/{connect,load,spawn}.md` — slash commands for session routing and ticket creation.
+- `commands/{connect,load,create,spawn}.md` — slash commands for session routing and ticket creation.
 - `hooks/hooks.json` + `scripts/permission-hook.sh` — PermissionRequest notifier that calls `ovld protocol permission-request`.
 - `userConfig` for legacy `overlord_url` and `agent_token` installs. Current installs should authenticate with `ovld auth login` or Overlord Desktop; env vars remain optional overrides for remote shells, CI, and explicit token injection.
 
@@ -36,6 +36,6 @@ Older plugin versions prompted for `overlord_url` and `agent_token` at install t
 Inside Claude Code the components are surfaced with the plugin prefix:
 
 - skill → `overlord:overlord-ticket`
-- commands → `/overlord:connect`, `/overlord:load`, `/overlord:spawn`
+- commands → `/overlord:connect`, `/overlord:load`, `/overlord:create`, `/overlord:spawn`
 
 Prompts generated by Overlord (see `lib/overlord/ticket-prompt.ts`) already reference these names in `bundle` instruction mode.

package/plugins/claude/commands/create.md

@@ -0,0 +1,16 @@
+---
+description: Create a draft Overlord ticket from the current conversation
+argument-hint: <objective or raw flags>
+disable-model-invocation: true
+---
+
+Create a draft Overlord ticket from the user's request.
+
+Use `$ARGUMENTS` as the input.
+If it already contains flags such as `--title`, `--priority`, `--project-id`, or `--execution-target`, pass those flags through after `ovld protocol create --agent claude-code`.
+Otherwise, treat `$ARGUMENTS` as the objective text and run:
+`ovld protocol create --agent claude-code --objective "<objective>"`
+
+If no objective was provided, ask the user for one and stop.
+
+After the command succeeds, report the new `TICKET_ID`.

package/plugins/claude/skills/overlord-ticket/SKILL.md

@@ -71,12 +71,16 @@ For larger delivery payloads, prefer `--payload-file -` and stream the full JSON
 
 Use this mode when the conversation starts normally and the user asks Claude to create, inspect, connect to, or otherwise use Overlord.
 
-1. If the user wants a new ticket, use `/overlord:spawn` or run `ovld protocol spawn --agent claude-code --objective "..."`.
-2. If the user already has a ticket ID and only wants to inspect it, use `/overlord:load` or run `ovld protocol load-context --ticket-id <ticket-id>`.
-3. If the user wants to route the current session onto an existing ticket by ID, use `/overlord:connect` or run `ovld protocol connect --ticket-id <ticket-id>`.
-4. If the user wants to find a ticket but does not know the ID, use `ovld attach` for interactive ticket search and agent launch, or ask the user for the ticket ID if staying strictly inside chat is the better fit.
-5. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
-6. Once you attach to a ticket, switch back to Mode 1 and follow the full ticket lifecycle.
+1. If the user wants to create tickets (and does not ask to start execution), run `ovld protocol create --agent claude-code --objective "..."`.
+   - When `--session-key` and `--ticket-id` are provided, it creates a follow-up draft.
+   - When session flags are omitted, it resolves the project by matching current working directory (or `--working-directory`) to Overlord `local_working_directory`, then creates a standalone draft.
+2. Default to `create` for new tickets. Only use `/overlord:spawn` or `ovld protocol spawn --agent claude-code --objective "..."` when the user explicitly asks to create and execute immediately.
+   `spawn` creates the ticket in `execute` status and attaches immediately.
+3. If the user already has a ticket ID and only wants to inspect it, use `/overlord:load` or run `ovld protocol load-context --ticket-id <ticket-id>`.
+4. If the user wants to route the current session onto an existing ticket by ID, use `/overlord:connect` or run `ovld protocol connect --ticket-id <ticket-id>`.
+5. If the user wants to find a ticket but does not know the ID, use `ovld attach` for interactive ticket search and agent launch, or ask the user for the ticket ID if staying strictly inside chat is the better fit.
+6. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
+7. Once you attach to a ticket, switch back to Mode 1 and follow the full ticket lifecycle.
 
 ## Change Rationales
 
@@ -102,7 +106,14 @@ Record only meaningful behavioral changes. Skip formatting-only noise.
 
 ## Project Discovery And Ticket Creation
 
-When creating tickets from within a repository, `spawn` automatically resolves the correct project from the current working directory. No `--project-id` flag is needed unless you want to override resolution.
+When creating tickets from within a repository:
+- Prefer `create` by default for draft ticket creation.
+- Use `spawn` only when the user explicitly asks to start execution immediately.
+- Both commands can resolve the project from the current working directory; use `--working-directory` to override.
+
+```bash
+ovld protocol create --agent claude-code --objective "Capture follow-up work from this repository"
+```
 
 ```bash
 ovld protocol spawn --agent claude-code --objective "Implement feature X" --priority medium

package/plugins/cursor/commands/create.md

@@ -0,0 +1,9 @@
+Create a draft Overlord ticket.
+
+Use the text after `/create` as the objective unless raw flags are present.
+
+Run:
+`ovld protocol create --agent cursor --objective "<objective>"`
+
+If raw flags are present, pass them through after:
+`ovld protocol create --agent cursor`

package/plugins/cursor/skills/overlord-ticket/SKILL.md

@@ -19,12 +19,13 @@ Use this skill whenever Cursor needs to work with Overlord, whether the session
 
 ## Mode 2: Asked From Chat To Use Overlord
 
-1. If the user wants a new ticket, use `/spawn` or run `ovld protocol spawn --agent cursor --objective "..."`.
-2. If the user already has a ticket ID and only wants to inspect it, use `/load` or run `ovld protocol load-context --ticket-id <ticket-id>`.
-3. If the user wants to route the current session onto an existing ticket by ID, use `/connect` or run `ovld protocol connect --ticket-id <ticket-id>`.
-4. If the user wants to search for tickets by keyword or status, use the `search_tickets` MCP tool.
-5. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
-6. Once you attach to a ticket, switch back to Mode 1 and follow the full ticket lifecycle.
+1. If the user wants to create tickets (and does not ask to start execution), use `/create` or run `ovld protocol create --agent cursor --objective "..."`.
+2. Default to `create` for new tickets. Only use `/spawn` or `ovld protocol spawn --agent cursor --objective "..."` when the user explicitly asks to create and execute immediately.
+3. If the user already has a ticket ID and only wants to inspect it, use `/load` or run `ovld protocol load-context --ticket-id <ticket-id>`.
+4. If the user wants to route the current session onto an existing ticket by ID, use `/connect` or run `ovld protocol connect --ticket-id <ticket-id>`.
+5. If the user wants to search for tickets by keyword or status, use the `search_tickets` MCP tool.
+6. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
+7. Once you attach to a ticket, switch back to Mode 1 and follow the full ticket lifecycle.
 
 ## Rules
 

package/plugins/overlord/skills/overlord-ticket/SKILL.md

@@ -67,12 +67,13 @@ For larger delivery payloads, prefer `--payload-file -` and stream the full JSON
 
 ## Mode 2: Asked From Chat To Use Overlord
 
-1. If the user wants a new ticket, use `ovld protocol spawn --objective "..."`. It creates the ticket and attaches immediately.
-2. If the user wants to inspect an existing ticket without starting work, use `ovld protocol load-context --ticket-id <ticket-id>`.
-3. If the user wants to work an existing ticket, attach with `ovld protocol attach --ticket-id <ticket-id>` and then switch to Mode 1.
-4. If the user wants to find existing tickets by keyword or workflow state, use the `search_tickets` tool.
-5. If you need to understand project routing before spawning, use `ovld protocol discover-project`.
-6. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
+1. If the user wants to create tickets (and does not ask to start execution), run `ovld protocol create --agent codex --objective "..."`.
+2. Default to `create` for new tickets. Only use `ovld protocol spawn --agent codex --objective "..."` when the user explicitly asks to create and execute immediately.
+3. If the user wants to inspect an existing ticket without starting work, use `ovld protocol load-context --ticket-id <ticket-id>`.
+4. If the user wants to work an existing ticket, attach with `ovld protocol attach --ticket-id <ticket-id>` and then switch to Mode 1.
+5. If the user wants to find existing tickets by keyword or workflow state, use the `search_tickets` tool.
+6. If you need to understand project routing before spawning, use `ovld protocol discover-project`.
+7. If you need other lifecycle commands or flags, run `ovld protocol help` and use the real subcommand list instead of guessing.
 
 ## Change Rationales
 
@@ -105,6 +106,21 @@ ovld protocol artifact-upload-file --session-key <sessionKey> --ticket-id $TICKE
 ovld protocol artifact-download-url --session-key <sessionKey> --ticket-id $TICKET_ID --artifact-id <artifact-id>
 ```
 
+## Project Discovery And Ticket Creation
+
+When creating tickets from within a repository:
+- Prefer `create` by default for draft ticket creation.
+- Use `spawn` only when the user explicitly asks to start execution immediately.
+- Both commands can resolve the project from the current working directory; use `--working-directory` to override.
+
+```bash
+ovld protocol create --agent codex --objective "Capture follow-up work from this repository"
+```
+
+```bash
+ovld protocol spawn --agent codex --objective "Implement feature X" --priority medium
+```
+
 ## Rules
 
 - The authoritative lifecycle is the `ovld protocol` CLI once you are on a ticket.