@dboio/cli 0.6.5 → 0.6.7

package/README.md

@@ -128,11 +128,12 @@ All configuration is **directory-scoped**. Each project folder maintains its own
 |------|---------|-----|
 | `config.json` | Domain, app metadata, placement preferences | Committable (shared) |
 | `config.local.json` | Per-user settings: plugin scopes, future user prefs | Gitignored (per-user) |
+| `ticketing.local.json` | Stored ticket IDs for submission error recovery | Gitignored (per-user) |
 | `credentials.json` | Username, user ID, UID, name, email (no password) | Gitignored (per-user) |
 | `cookies.txt` | Session cookie (Netscape format) | Gitignored (per-user) |
 | `structure.json` | Bin directory mapping (created by `dbo clone`) | Committable (shared) |
 
-`dbo init` automatically adds `.dbo/credentials.json`, `.dbo/cookies.txt`, and `.dbo/config.local.json` to `.gitignore` (creates the file if it doesn't exist).
+`dbo init` automatically adds `.dbo/credentials.json`, `.dbo/cookies.txt`, `.dbo/config.local.json`, and `.dbo/ticketing.local.json` to `.gitignore` (creates the file if it doesn't exist).
 
 #### config.json reference
 
@@ -1090,7 +1091,35 @@ The `add` and `push` commands never submit these server-managed columns:
 
 The `input`, `push`, and `add` commands automatically detect recoverable server errors and prompt for missing values instead of failing immediately.
 
-#### Ticket ID required
+#### Ticket error recovery
+
+When the server returns a `ticket_error` (record update requires a Ticket ID), the CLI prompts with interactive recovery options:
+
+```
+⚠ This record update requires a Ticket ID.
+? Record update requires a Ticket ID:
+❯ Apply a Ticket ID to this record and resubmit
+  Apply a Ticket ID to all updates in this transaction, and update my current Ticket ID reference
+  Skip this record update
+  Skip all updates that require a Ticket ID
+```
+
+When the server returns a `repo_mismatch` (Ticket ID belongs to a different repository), the CLI prompts:
+
+```
+⚠ Ticket "TICKET-123" is for another repository.
+? The Ticket ID of "TICKET-123" is for another Repository:
+❯ Commit anyway
+  Submit with another Ticket ID
+  Skip this record
+  Commit all transactions with this ID anyway
+  Commit all transactions with another Ticket ID, and update my current Ticket ID reference
+  Skip all
+```
+
+Ticket selections are stored in `.dbo/ticketing.local.json` for reuse across submissions. Per-record tickets are cleaned up after successful submission; the global ticket persists until explicitly cleared. The `--ticket` flag always takes precedence over stored tickets.
+
+#### Ticket ID required (legacy)
 
 When the server returns `ticket_lookup_required_error`, the CLI prompts:
 
@@ -1101,6 +1130,40 @@ When the server returns `ticket_lookup_required_error`, the CLI prompts:
 
 The submission is then retried with `_OverrideTicketID`. To skip the prompt, pass `--ticket <id>` upfront.
 
+#### Pre-submission ticket prompt
+
+When a stored ticket exists in `.dbo/ticketing.local.json`, the CLI prompts before batch submissions:
+
+```
+? Use stored Ticket ID "TICKET-123" for this submission?
+❯ Yes, use "TICKET-123"
+  No, clear stored ticket
+  Cancel submission
+```
+
+#### `.dbo/ticketing.local.json`
+
+Stores ticket IDs for automatic application during submissions:
+
+```json
+{
+  "ticket_id": "TICKET-123",
+  "records": [
+    {
+      "UID": "a2dxvg23rk6xsmnum7pdxa",
+      "RowID": 16012,
+      "entity": "content",
+      "ticket_id": "TICKET-456",
+      "expression": "RowID:16012;column:content._LastUpdatedTicketID=TICKET-456"
+    }
+  ]
+}
+```
+
+- `ticket_id` — Global ticket applied to all submissions until cleared
+- `records` — Per-record tickets (auto-cleared after successful submission)
+- `--ticket` flag always takes precedence over stored tickets
+
 #### User identity required
 
 When the server returns an error mentioning `LoggedInUser_UID`, `LoggedInUserID`, `CurrentUserID`, or `UserID`, the CLI checks for a stored user identity from `dbo login`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dboio/cli",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "CLI for the DBO.io framework",
   "type": "module",
   "bin": {

package/plugins/claude/dbo/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dbo",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "DBO.io CLI integration for Claude Code",
   "author": {
     "name": "DBO.io"

package/plugins/claude/dbo/commands/dbo.md

@@ -0,0 +1,274 @@
+# DBO CLI Command
+
+The dbo CLI interacts with DBO.io — a database-driven application framework.
+
+**STEP 1: Check if `$ARGUMENTS` is empty or blank.**
+
+If `$ARGUMENTS` is empty — meaning the user typed just `/dbo` with nothing after it — then you MUST NOT run any bash command. Do NOT run `dbo`, `dbo --help`, or anything else. Instead, respond ONLY with this text message:
+
+---
+
+Hi there! I can help you with running dbo commands. What would you like to do?
+
+Here are the available commands:
+
+| Command   | Description                                      |
+|-----------|--------------------------------------------------|
+| init      | Initialize .dbo/ configuration                   |
+| login     | Authenticate with a DBO.io instance              |
+| logout    | Clear session                                    |
+| status    | Show config, domain, and session info            |
+| input     | Submit CRUD operations (add/edit/delete records)  |
+| output    | Query data from outputs or entities              |
+| content   | Get or deploy content                            |
+| media     | Get media files                                  |
+| upload    | Upload a file                                    |
+| message   | Send messages (email, SMS, chatbot)              |
+| pull      | Pull records to local files                      |
+| push      | Push local files back to DBO.io                  |
+| add       | Add a new file to DBO.io                         |
+| clone     | Clone an app to local project structure           |
+| diff      | Compare local files with server versions          |
+| rm        | Remove a file and stage server deletion           |
+| deploy    | Deploy via manifest                              |
+| cache     | Manage cache                                     |
+| install   | Install or upgrade CLI, plugins, Claude commands (shorthand: `i`) |
+
+Just tell me what you'd like to do and I'll help you build the right command!
+
+---
+
+Then STOP. Wait for the user to respond. Guide them step by step — asking about entities, UIDs, file paths, flags, etc. to construct the correct `dbo` command. Run `dbo status` proactively to check if the CLI is initialized and authenticated before suggesting data commands.
+
+**STEP 2: If `$ARGUMENTS` is NOT empty, run the command:**
+
+```bash
+dbo $ARGUMENTS
+```
+
+## Command Reference
+
+Available subcommands:
+- `init` — Initialize .dbo/ configuration for the current directory
+- `login` — Authenticate with a DBO.io instance
+- `logout` — Clear session
+- `status` — Show config, domain, and session info
+- `input -d '<expr>'` — CRUD operations (add/edit/delete records)
+- `output -e <entity>` — Query data from entities
+- `output <uid>` — Query custom outputs
+- `content <uid>` — Get content, `content deploy <uid> <file>` to deploy
+- `pull [uid]` — Pull records to local files (default: content entity)
+- `pull -e <entity> [uid]` — Pull from any entity
+- `push <path>` — Push local files back to DBO using metadata
+- `add <path>` — Add a new file to DBO (creates record on server)
+- `media <uid>` — Get media files
+- `upload <file>` — Upload binary files
+- `message <uid>` — Send messages (email, SMS, chatbot)
+- `cache list|refresh` — Manage cache
+- `clone [source]` — Clone an app to local project (from file or server)
+- `clone --app <name>` — Clone by app short name from server
+- `diff [path]` — Compare local files against server and selectively merge changes
+- `diff -y` — Accept all server changes without prompting
+- `diff --no-interactive` — Show diffs without prompting to accept
+- `rm <file>` — Remove a file locally and stage server deletion for next push
+- `rm <directory>` — Remove a directory, all files, and sub-directories recursively
+- `rm -f <path>` — Remove without confirmation prompts
+- `rm --keep-local <path>` — Stage server deletions without deleting local files/directories
+- `deploy [name]` — Deploy via dbo.deploy.json manifest
+- `install` (alias: `i`) — Install or upgrade CLI, plugins, or Claude commands
+- `i dbo` or `i dbo@latest` — Install/upgrade the CLI from npm
+- `i dbo@0.4.1` — Install a specific CLI version
+- `install /path/to/src` — Install CLI from local source
+- `install plugins` — Install/upgrade Claude command plugins
+- `install plugins --global` — Install plugins to `~/.claude/commands/` (shared across projects)
+- `install plugins --local` — Install plugins to `.claude/commands/` (project only)
+- `install claudecommands` — Install/upgrade Claude Code commands
+- `install claudecode` — Install Claude Code CLI + commands
+- `install --claudecommand dbo --global` — Install a specific command globally
+
+## Change Detection (pull, clone, diff)
+
+When pulling or cloning records that already exist locally, the CLI compares file modification times against the server's `_LastUpdated` timestamp. If the server has newer data, you'll be prompted with options:
+
+1. **Overwrite** — Replace local files with server version
+2. **Compare** — Show a line-by-line diff and selectively merge
+3. **Skip** — Keep local files unchanged
+4. **Overwrite all** — Accept all remaining server changes
+5. **Skip all** — Skip all remaining files
+
+Use `dbo diff [path]` to compare without pulling. Use `-y` to auto-accept all changes.
+
+## Smart Command Building
+
+When helping the user build a command interactively:
+
+1. **Check readiness first**: Run `dbo status` to see if initialized and authenticated. If not, guide them through `dbo init` and `dbo login` first.
+2. **Understand intent**: Ask what they want to do (query data, deploy a file, add a record, etc.)
+3. **Gather parameters**: Ask for the specific values needed (entity name, UID, file path, filters, etc.)
+4. **Build the command**: Construct the full `dbo` command with proper flags and syntax
+5. **Execute**: Run it and explain the results
+
+### Common workflows to suggest:
+
+- **"I want to query data"** → Guide toward `dbo output -e <entity>` with filters
+- **"I want to deploy/update a file"** → Check if `.metadata.json` exists → `dbo push` or `dbo content deploy`
+- **"I want to add a new file"** → `dbo add <path>` (will create metadata interactively)
+- **"I want to pull files from the server"** → `dbo pull` or `dbo pull -e <entity>`
+- **"I want to delete/remove a file"** → `dbo rm <file>` (stages deletion for next `dbo push`)
+- **"I want to delete a directory"** → `dbo rm <directory>` (removes all files + sub-dirs, stages bin deletions)
+- **"I want to see what's on the server"** → `dbo output -e <entity> --format json`
+- **"I need to set up this project"** → `dbo init` → `dbo login` → `dbo status`
+- **"I want to clone an app"** → `dbo clone --app <name>` or `dbo clone <local.json>`
+- **"I want to set up and clone"** → `dbo init --domain <host> --app <name> --clone`
+
+## Add Command Details
+
+`dbo add <path>` registers a new local file with the DBO server by creating an insert record.
+
+```bash
+# Add a single file (interactive metadata wizard if no .metadata.json exists)
+dbo add assets/css/colors.css
+
+# Add with auto-accept and ticket
+dbo add assets/css/colors.css -y --ticket abc123
+
+# Scan current directory for all un-added files
+dbo add .
+
+# Scan a specific directory
+dbo add assets/
+```
+
+Flags: `-C/--confirm <true|false>`, `--ticket <id>`, `-y/--yes`, `--json`, `--jq <expr>`, `-v/--verbose`, `--domain <host>`
+
+### How add works
+
+1. Checks for a companion `<basename>.metadata.json` next to the file
+2. If metadata exists with `_CreatedOn` → already on server, skips (use `push` instead)
+3. If metadata exists without `_CreatedOn` → uses it to insert the record
+4. If no metadata → interactive wizard prompts for: entity, content column, AppID, BinID, SiteID, Path
+5. Creates `.metadata.json`, submits insert to `/api/input/submit`
+6. Writes returned UID back to metadata file
+7. Suggests running `dbo pull -e <entity> <uid>` to populate all server columns
+
+### Non-interactive add (for scripting)
+
+To add without prompts, create the `.metadata.json` first, then run `dbo add <file> -y`:
+
+```json
+{
+  "Name": "colors",
+  "Path": "assets/css/colors.css",
+  "Content": "@colors.css",
+  "_entity": "content",
+  "_contentColumns": ["Content"]
+}
+```
+
+Optional fields like `AppID`, `BinID`, `SiteID` are only included if the user provides values — they have no defaults and are omitted when left blank.
+
+The `@colors.css` value means "read content from colors.css in the same directory".
+
+### Directory scan (`dbo add .`)
+
+Finds files that have no `.metadata.json` or whose metadata lacks `_CreatedOn`. Skips `.dbo/`, `.git/`, `node_modules/`, dotfiles, and `.metadata.json` files. When adding multiple files, defaults from the first file are reused.
+
+## Push Command Details
+
+`dbo push <path>` pushes local file changes back to existing DBO records using their `.metadata.json`.
+
+```bash
+dbo push assets/css/colors.css          # single file
+dbo push assets/                         # all records in directory
+dbo push assets/ --content-only          # only file content, skip metadata
+dbo push assets/ --meta-only             # only metadata columns, skip files
+dbo push assets/ -y --ticket abc123      # auto-accept + ticket
+```
+
+Flags: `-C/--confirm`, `--ticket <id>`, `--meta-only`, `--content-only`, `-y/--yes`, `--json`, `--jq`, `-v/--verbose`, `--domain`
+
+## Column Filtering (add & push)
+
+These columns are **never submitted** in add or push payloads:
+- `_CreatedOn`, `_LastUpdated` — server-managed timestamps
+- `_LastUpdatedUserID`, `_LastUpdatedTicketID` — session-provided values
+- `UID` — server-assigned on insert; used as identifier on push (not as column value)
+- `_id`, `_entity`, `_contentColumns`, `_mediaFile` — internal/metadata fields
+
+## Pull → Edit → Push/Add Workflow
+
+```bash
+# Pull existing records
+dbo pull -e content --filter 'AppID=10100'
+
+# Edit files locally, then push changes back
+dbo push assets/css/colors.css
+
+# Or add a brand new file
+dbo add assets/css/newstyle.css
+```
+
+## Clone Command Details
+
+`dbo clone` scaffolds a local project from a DBO.io app export JSON, creating directories, files, metadata, and config.
+
+```bash
+# Clone from a local JSON export file
+dbo clone /path/to/app_export.json
+
+# Clone from server by app short name (requires login)
+dbo clone --app myapp
+
+# Clone using AppShortName already in config
+dbo clone
+
+# Init + clone in one step
+dbo init --domain my-domain.com --app myapp --clone
+```
+
+Flags: `--app <name>`, `--domain <host>`, `-y/--yes`, `-v/--verbose`
+
+### What clone does
+
+1. Loads app JSON (local file, server API, or prompt)
+2. Updates `.dbo/config.json` with `AppID`, `AppUID`, `AppName`, `AppShortName`
+3. Updates `package.json` with `name`, `productName`, `description`, `homepage`, and `deploy` script
+4. Creates directory structure from `children.bin` hierarchy → saves `.dbo/structure.json`
+5. Writes content files (decodes base64) with `*.metadata.json` into bin directories
+6. Downloads media files from server via `/api/media/{uid}` with `*.metadata.json`
+7. Processes entity-dir records (`extension`, `app_version`, `data_source`, `site`, `group`, `integration`, `automation`) into project directories (`Extensions/`, `Data Sources/`, etc.) as `.metadata.json` files with optional companion content files
+8. Processes remaining entities with BinID into corresponding bin directories
+9. Saves `app.json` to project root with `@path/to/*.metadata.json` references
+
+### Placement preferences
+
+When a record has both `Path`/`FullPath` and `BinID`, clone prompts the user to choose placement. Preferences are saved to `.dbo/config.json` and reused on future clones:
+
+- `ContentPlacement`: `bin` | `path` | `ask` — for content and other entities
+- `MediaPlacement`: `bin` | `fullpath` | `ask` — for media files
+
+Pre-set these in config.json to skip prompts. `.dbo/config.json` and `.dbo/structure.json` are shared via git; `.dbo/credentials.json` and `.dbo/cookies.txt` are gitignored (per-user).
+
+### AppID awareness (add & input)
+
+After cloning, the config has an `AppID`. When running `dbo add` or `dbo input` without an AppID in the data, the CLI prompts:
+1. Yes, use AppID from config
+2. No
+3. Enter custom AppID
+
+### Init flags for clone
+
+`dbo init` now supports `--app <shortName>` and `--clone` flags to combine initialization with app cloning.
+
+## Error Handling
+
+- If the command fails with a session/authentication error, suggest: `dbo login`
+- If it fails with "No domain configured", suggest: `dbo init`
+- If a command is not found, suggest: `dbo --help`
+
+## Output
+
+When showing results:
+- Format JSON output readably
+- For pull/push/add operations, list the files created or modified
+- For query operations, summarize the row count and key fields

package/src/commands/add.js

@@ -7,6 +7,7 @@ import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
 import { loadAppConfig } from '../lib/config.js';
+import { checkStoredTicket, clearGlobalTicket } from '../lib/ticketing.js';
 
 // Directories and patterns to skip when scanning with `dbo add .`
 const IGNORE_DIRS = new Set(['.dbo', '.git', 'node_modules', '.svn', '.hg']);
@@ -245,10 +246,21 @@ async function submitAdd(meta, metaPath, filePath, client, options) {
   let body = await buildInputBody(dataExprs, extraParams);
   let result = await client.postUrlEncoded('/api/input/submit', body);
 
-  // Retry with prompted params if needed (ticket, user)
-  const retryParams = await checkSubmitErrors(result);
-  if (retryParams) {
-    Object.assign(extraParams, retryParams);
+  // Retry with prompted params if needed (ticket, user, repo mismatch)
+  const retryResult = await checkSubmitErrors(result);
+  if (retryResult) {
+    if (retryResult.skipRecord) {
+      log.warn('  Skipping record');
+      return null;
+    }
+    if (retryResult.skipAll) {
+      throw new Error('SKIP_ALL');
+    }
+    if (retryResult.ticketExpressions?.length > 0) {
+      dataExprs.push(...retryResult.ticketExpressions);
+    }
+    const params = retryResult.retryParams || retryResult;
+    Object.assign(extraParams, params);
     body = await buildInputBody(dataExprs, extraParams);
     result = await client.postUrlEncoded('/api/input/submit', body);
   }
@@ -302,6 +314,19 @@ async function addDirectory(dirPath, client, options) {
     if (!proceed) return;
   }
 
+  // Pre-flight ticket validation
+  if (!options.ticket) {
+    const ticketCheck = await checkStoredTicket(options);
+    if (ticketCheck.cancel) {
+      log.info('Submission cancelled');
+      return;
+    }
+    if (ticketCheck.clearTicket) {
+      await clearGlobalTicket();
+      log.dim('  Cleared stored ticket');
+    }
+  }
+
   let succeeded = 0;
   let failed = 0;
   let batchDefaults = null;
@@ -314,6 +339,10 @@ async function addDirectory(dirPath, client, options) {
         succeeded++;
       }
     } catch (err) {
+      if (err.message === 'SKIP_ALL') {
+        log.info('Skipping remaining records');
+        break;
+      }
       log.error(`Failed: ${relative(process.cwd(), filePath)} — ${err.message}`);
       failed++;
     }

package/src/commands/init.js

@@ -62,7 +62,7 @@ export const initCommand = new Command('init')
       }
 
       // Ensure sensitive files are gitignored
-      await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/config.local.json']);
+      await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/config.local.json', '.dbo/ticketing.local.json']);
 
       log.success(`Initialized .dbo/ for ${domain}`);
       log.dim('  Run "dbo login" to authenticate.');

package/src/commands/input.js

@@ -3,6 +3,7 @@ import { DboClient } from '../lib/client.js';
 import { buildInputBody, parseFileArg, checkSubmitErrors } from '../lib/input-parser.js';
 import { formatResponse, formatError } from '../lib/formatter.js';
 import { loadAppConfig } from '../lib/config.js';
+import { checkStoredTicket, clearGlobalTicket } from '../lib/ticketing.js';
 import { log } from '../lib/logger.js';
 
 function collect(value, previous) {
@@ -31,6 +32,19 @@ export const inputCommand = new Command('input')
       if (options.login) extraParams['_login'] = 'true';
       if (options.transactional) extraParams['_transactional'] = 'true';
 
+      // Pre-flight ticket validation
+      if (!options.ticket) {
+        const ticketCheck = await checkStoredTicket(options);
+        if (ticketCheck.cancel) {
+          log.info('Submission cancelled');
+          return;
+        }
+        if (ticketCheck.clearTicket) {
+          await clearGlobalTicket();
+          log.dim('  Cleared stored ticket');
+        }
+      }
+
       // Check if data expressions include AppID; if not and config has one, prompt
       const allDataText = options.data.join(' ');
       const hasAppId = /\.AppID[=@]/.test(allDataText) || /AppID=/.test(allDataText);
@@ -79,10 +93,15 @@ export const inputCommand = new Command('input')
         const files = options.file.map(parseFileArg);
         let result = await client.postMultipart('/api/input/submit', fields, files);
 
-        // Retry with prompted params if needed (ticket, user)
-        const retryParams = await checkSubmitErrors(result);
-        if (retryParams) {
-          Object.assign(fields, retryParams);
+        // Retry with prompted params if needed (ticket, user, repo mismatch)
+        const retryResult = await checkSubmitErrors(result);
+        if (retryResult) {
+          if (retryResult.skipRecord || retryResult.skipAll) {
+            log.warn('Skipping submission');
+            return;
+          }
+          const params = retryResult.retryParams || retryResult;
+          Object.assign(fields, params);
           result = await client.postMultipart('/api/input/submit', fields, files);
         }
 
@@ -93,10 +112,15 @@ export const inputCommand = new Command('input')
         let body = await buildInputBody(options.data, extraParams);
         let result = await client.postUrlEncoded('/api/input/submit', body);
 
-        // Retry with prompted params if needed (ticket, user)
-        const retryParams = await checkSubmitErrors(result);
-        if (retryParams) {
-          Object.assign(extraParams, retryParams);
+        // Retry with prompted params if needed (ticket, user, repo mismatch)
+        const retryResult = await checkSubmitErrors(result);
+        if (retryResult) {
+          if (retryResult.skipRecord || retryResult.skipAll) {
+            log.warn('Skipping submission');
+            return;
+          }
+          const params = retryResult.retryParams || retryResult;
+          Object.assign(extraParams, params);
           body = await buildInputBody(options.data, extraParams);
           result = await client.postUrlEncoded('/api/input/submit', body);
         }

package/src/commands/install.js

@@ -116,6 +116,41 @@ async function unregisterPlugin(pluginName) {
   }
 }
 
+/**
+ * Extract commands/*.md from a directory plugin to ~/.claude/commands/ or .claude/commands/.
+ * This provides the /commandName shorthand alongside the /plugin:skill format.
+ * @param {string} pluginSourcePath - Path to the plugin source directory
+ * @param {'project' | 'global'} scope - Installation scope
+ * @returns {Promise<number>} Number of commands extracted
+ */
+async function extractPluginCommands(pluginSourcePath, scope) {
+  const commandsSourceDir = join(pluginSourcePath, 'commands');
+  if (!existsSync(commandsSourceDir)) return 0;
+
+  const commandsTargetDir = getCommandsDir(scope);
+  await mkdir(commandsTargetDir, { recursive: true });
+
+  let extracted = 0;
+  const files = await readdir(commandsSourceDir);
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+    const srcPath = join(commandsSourceDir, file);
+    const destPath = join(commandsTargetDir, file);
+    const srcContent = await readFile(srcPath, 'utf8');
+
+    if (await fileExists(destPath)) {
+      const destContent = await readFile(destPath, 'utf8');
+      if (fileHash(srcContent) === fileHash(destContent)) continue;
+    }
+
+    await copyFile(srcPath, destPath);
+    const label = scope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
+    log.dim(`  Extracted command: ${label}${file}`);
+    extracted++;
+  }
+  return extracted;
+}
+
 /**
  * Check if a plugin source is a directory-based plugin (has .claude-plugin/).
  * @param {string} pluginPath - Path to the plugin directory
@@ -680,6 +715,9 @@ export async function installOrUpdateClaudeCommands(options = {}) {
         }
       }
 
+      // Extract commands/*.md to ~/.claude/commands/ or .claude/commands/
+      await extractPluginCommands(plugin.path, targetScope);
+
       // Persist scope + metadata to config.local.json
       if (hasProject && (options.global || options.local || !await getPluginScope(plugin.name))) {
         await setPluginScope(plugin.name, {
@@ -691,19 +729,22 @@ export async function installOrUpdateClaudeCommands(options = {}) {
         log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
       }
 
-      // Clean up legacy file if it exists
-      const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
-      const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
-      if (await fileExists(legacyProjectPath)) {
-        const { unlink } = await import('fs/promises');
-        await unlink(legacyProjectPath);
-        await removeFromGitignore(`.claude/commands/${legacyFileName}`);
-        log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
-      }
-      if (await fileExists(legacyGlobalPath)) {
-        const { unlink } = await import('fs/promises');
-        await unlink(legacyGlobalPath);
-        log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+      // Clean up legacy command files (but not ones we just extracted from commands/)
+      const hasPluginCommand = existsSync(join(plugin.path, 'commands', legacyFileName));
+      if (!hasPluginCommand) {
+        const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
+        const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
+        if (await fileExists(legacyProjectPath)) {
+          const { unlink } = await import('fs/promises');
+          await unlink(legacyProjectPath);
+          await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+          log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
+        }
+        if (await fileExists(legacyGlobalPath)) {
+          const { unlink } = await import('fs/promises');
+          await unlink(legacyGlobalPath);
+          log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+        }
       }
 
       if (targetScope === 'global' && locations.project) {
@@ -766,7 +807,7 @@ export async function installOrUpdateClaudeCommands(options = {}) {
   if (upToDate > 0) log.dim(`${upToDate} plugin(s) already up to date.`);
   if (skipped > 0) log.dim(`${skipped} plugin(s) skipped.`);
   if (installed > 0 || updated > 0) {
-    log.info('Use /dbo:cli in Claude Code.');
+    log.info('Use /dbo in Claude Code.');
     log.warn('Note: Plugins will be available in new Claude Code sessions (restart any active session).');
   }
 }
@@ -872,6 +913,9 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
       }
     }
 
+    // Extract commands/*.md to ~/.claude/commands/ or .claude/commands/
+    await extractPluginCommands(plugin.path, targetScope);
+
     // Persist scope + metadata to config.local.json
     if (hasProject && (options.global || options.local || !await getPluginScope(pluginName))) {
       await setPluginScope(pluginName, {
@@ -883,19 +927,22 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
       log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
     }
 
-    // Clean up legacy files
-    const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
-    const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
-    if (await fileExists(legacyProjectPath)) {
-      const { unlink } = await import('fs/promises');
-      await unlink(legacyProjectPath);
-      await removeFromGitignore(`.claude/commands/${legacyFileName}`);
-      log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
-    }
-    if (await fileExists(legacyGlobalPath)) {
-      const { unlink } = await import('fs/promises');
-      await unlink(legacyGlobalPath);
-      log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+    // Clean up legacy command files (but not ones we just extracted from commands/)
+    const hasPluginCommand = existsSync(join(plugin.path, 'commands', legacyFileName));
+    if (!hasPluginCommand) {
+      const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
+      const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
+      if (await fileExists(legacyProjectPath)) {
+        const { unlink } = await import('fs/promises');
+        await unlink(legacyProjectPath);
+        await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+        log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
+      }
+      if (await fileExists(legacyGlobalPath)) {
+        const { unlink } = await import('fs/promises');
+        await unlink(legacyGlobalPath);
+        log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+      }
     }
 
     if (targetScope === 'global' && locations.project) {

package/src/commands/login.js

@@ -48,7 +48,7 @@ export const loginCommand = new Command('login')
         log.success(`Authenticated as ${username} on ${await client.getDomain()}`);
 
         // Ensure sensitive files are gitignored
-        await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt']);
+        await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/ticketing.local.json']);
 
         // Fetch current user info to store ID and UID for future submissions
         try {

package/src/commands/push.js

@@ -7,6 +7,7 @@ import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
 import { loadConfig, loadSynchronize, saveSynchronize, loadAppJsonBaseline, saveAppJsonBaseline, hasBaseline } from '../lib/config.js';
+import { checkStoredTicket, applyStoredTicketToSubmission, clearRecordTicket, clearGlobalTicket } from '../lib/ticketing.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
 import { findMetadataFiles } from '../lib/diff.js';
 import { detectChangedColumns, findBaselineEntry } from '../lib/delta.js';
@@ -68,9 +69,15 @@ async function processPendingDeletes(client, options) {
       const result = await client.postUrlEncoded('/api/input/submit', body);
 
       // Retry with prompted params if needed
-      const retryParams = await checkSubmitErrors(result);
-      if (retryParams) {
-        Object.assign(extraParams, retryParams);
+      const retryResult = await checkSubmitErrors(result);
+      if (retryResult) {
+        if (retryResult.skipRecord || retryResult.skipAll) {
+          log.warn(`  Skipping deletion of "${entry.name}"`);
+          remaining.push(entry);
+          continue;
+        }
+        const params = retryResult.retryParams || retryResult;
+        Object.assign(extraParams, params);
         const retryBody = await buildInputBody([entry.expression], extraParams);
         const retryResult = await client.postUrlEncoded('/api/input/submit', retryBody);
         if (retryResult.successful) {
@@ -217,6 +224,19 @@ async function pushDirectory(dirPath, client, options) {
     return;
   }
 
+  // Pre-flight ticket validation (only if no --ticket flag)
+  if (!options.ticket && toPush.length > 0) {
+    const ticketCheck = await checkStoredTicket(options);
+    if (ticketCheck.cancel) {
+      log.info('Submission cancelled');
+      return;
+    }
+    if (ticketCheck.clearTicket) {
+      await clearGlobalTicket();
+      log.dim('  Cleared stored ticket');
+    }
+  }
+
   // Group by entity and apply dependency ordering
   const byEntity = {};
   for (const item of toPush) {
@@ -240,6 +260,10 @@ async function pushDirectory(dirPath, client, options) {
         failed++;
       }
     } catch (err) {
+      if (err.message === 'SKIP_ALL') {
+        log.info('Skipping remaining records');
+        break;
+      }
       log.error(`Failed: ${item.metaPath} — ${err.message}`);
       failed++;
     }
@@ -321,16 +345,36 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
   const fieldLabel = changedColumns ? `${dataExprs.length} changed field(s)` : `${dataExprs.length} field(s)`;
   log.info(`Pushing ${basename(metaPath, '.metadata.json')} (${entity}:${uid}) — ${fieldLabel}`);
 
+  // Apply stored ticket if no --ticket flag
+  await applyStoredTicketToSubmission(dataExprs, entity, uid, uid, options);
+
   const extraParams = { '_confirm': options.confirm };
   if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
 
   let body = await buildInputBody(dataExprs, extraParams);
   let result = await client.postUrlEncoded('/api/input/submit', body);
 
-  // Retry with prompted params if needed (ticket, user)
-  const retryParams = await checkSubmitErrors(result);
-  if (retryParams) {
-    Object.assign(extraParams, retryParams);
+  // Retry with prompted params if needed (ticket, user, repo mismatch)
+  const retryResult = await checkSubmitErrors(result);
+  if (retryResult) {
+    // Handle skip actions
+    if (retryResult.skipRecord) {
+      log.warn('  Skipping record');
+      return false;
+    }
+    if (retryResult.skipAll) {
+      throw new Error('SKIP_ALL');
+    }
+
+    // Append ticket expressions
+    if (retryResult.ticketExpressions?.length > 0) {
+      dataExprs.push(...retryResult.ticketExpressions);
+    }
+
+    // Merge retry params (new-style has retryParams nested, legacy is flat)
+    const params = retryResult.retryParams || retryResult;
+    Object.assign(extraParams, params);
+
     body = await buildInputBody(dataExprs, extraParams);
     result = await client.postUrlEncoded('/api/input/submit', body);
   }
@@ -347,6 +391,9 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     return false;
   }
 
+  // Clean up per-record ticket on success
+  await clearRecordTicket(uid);
+
   // Update file timestamps from server response
   try {
     const editResults = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];

package/src/lib/input-parser.js

@@ -1,6 +1,7 @@
 import { readFile } from 'fs/promises';
 import { log } from './logger.js';
 import { loadUserInfo } from './config.js';
+import { buildTicketExpression, setGlobalTicket, setRecordTicket } from './ticketing.js';
 
 /**
  * Parse DBO input syntax and build form data.
@@ -96,24 +97,41 @@ const USER_ID_PATTERNS = [
  * resolved by prompting the user for missing parameters.
  *
  * Detects:
- * - ticket_lookup_required_error → prompts for Ticket ID
+ * - ticket_error → interactive ticket recovery (4 options)
+ * - repo_mismatch → repository mismatch recovery (6 options)
+ * - ticket_lookup_required_error → prompts for Ticket ID (legacy)
  * - LoggedInUser_UID, LoggedInUserID, CurrentUserID, UserID not found
  *   → prompts for User ID or UID (session not authenticated)
  *
- * Returns an object of extra params to add on retry, or null if no
- * recoverable errors were found.
+ * Returns an object with retry information, or null if no recoverable errors found.
+ *
+ * Return shape for ticket errors:
+ *   { retryParams, ticketExpressions, skipRecord, skipAll }
+ *
+ * Return shape for legacy/user errors (backward compatible):
+ *   { _OverrideTicketID, _OverrideUserUID, _OverrideUserID, ... }
  */
 export async function checkSubmitErrors(result) {
   const messages = result.messages || result.data?.Messages || [];
   const allText = messages.filter(m => typeof m === 'string').join(' ');
 
-  const needsTicket = allText.includes('ticket_lookup_required_error');
+  // --- Ticket error detection (new interactive handling) ---
+  const hasTicketError = allText.includes('ticket_error');
+  const hasRepoMismatch = allText.includes('repo_mismatch');
+
+  if (hasTicketError) {
+    return await handleTicketError(allText);
+  }
+
+  if (hasRepoMismatch) {
+    return await handleRepoMismatch(allText);
+  }
 
-  // Detect which user identity variant is needed
+  // --- Legacy ticket and user identity handling ---
+  const needsTicket = allText.includes('ticket_lookup_required_error');
   const matchedUserPattern = USER_ID_PATTERNS.find(p => allText.includes(p));
   const needsUser = !!matchedUserPattern;
   const needsUserUid = matchedUserPattern && matchedUserPattern.includes('UID');
-  const needsUserId = matchedUserPattern && !needsUserUid;
 
   if (!needsTicket && !needsUser) return null;
 
@@ -126,7 +144,6 @@ export async function checkSubmitErrors(result) {
     log.dim('  Your session may have expired, or you may not be logged in.');
     log.dim('  You can log in with "dbo login" to avoid this prompt in the future.');
 
-    // Check for stored user info from a previous login
     const stored = await loadUserInfo();
     const storedValue = needsUserUid ? stored.userUid : (stored.userId || stored.userUid);
     const storedLabel = needsUserUid
@@ -176,11 +193,9 @@ export async function checkSubmitErrors(result) {
 
   if (answers.ticketId) retryParams['_OverrideTicketID'] = answers.ticketId.trim();
 
-  // Resolve user identity from choice or direct input
   const userValue = answers.userValue
     || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
   if (userValue) {
-    // Use the appropriate override param based on what the server asked for
     if (needsUserUid) {
       retryParams['_OverrideUserUID'] = userValue.trim();
     } else {
@@ -191,6 +206,162 @@ export async function checkSubmitErrors(result) {
   return retryParams;
 }
 
+/**
+ * Handle ticket_error: Record update requires a Ticket ID but none was provided.
+ * Prompts the user with 4 recovery options.
+ */
+async function handleTicketError(allText) {
+  const inquirer = (await import('inquirer')).default;
+
+  // Try to extract record details from error text
+  const entityMatch = allText.match(/entity:(\w+)/);
+  const rowIdMatch = allText.match(/RowID:(\d+)/);
+  const uidMatch = allText.match(/UID:([a-zA-Z0-9]+)/);
+  const entity = entityMatch?.[1];
+  const rowId = rowIdMatch?.[1];
+  const uid = uidMatch?.[1];
+
+  log.warn('This record update requires a Ticket ID.');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'ticketAction',
+      message: 'Record update requires a Ticket ID:',
+      choices: [
+        { name: 'Apply a Ticket ID to this record and resubmit', value: 'apply_one' },
+        { name: 'Apply a Ticket ID to all updates in this transaction, and update my current Ticket ID reference', value: 'apply_all' },
+        { name: 'Skip this record update', value: 'skip_one' },
+        { name: 'Skip all updates that require a Ticket ID', value: 'skip_all' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'ticketId',
+      message: 'Enter Ticket ID:',
+      when: (a) => a.ticketAction === 'apply_one' || a.ticketAction === 'apply_all',
+      validate: v => v.trim() ? true : 'Ticket ID is required',
+    },
+  ]);
+
+  if (answers.ticketAction === 'skip_one') {
+    return { skipRecord: true };
+  }
+  if (answers.ticketAction === 'skip_all') {
+    return { skipAll: true };
+  }
+
+  const ticketId = answers.ticketId.trim();
+  const ticketExpressions = [];
+
+  if (entity && rowId) {
+    ticketExpressions.push(buildTicketExpression(entity, rowId, ticketId));
+  }
+
+  // Store ticket based on scope
+  if (answers.ticketAction === 'apply_all') {
+    await setGlobalTicket(ticketId);
+    log.dim(`  Stored ticket "${ticketId}" for all future submissions`);
+  } else if (uid) {
+    await setRecordTicket(uid, rowId, entity, ticketId);
+    log.dim(`  Stored ticket "${ticketId}" for record ${uid}`);
+  }
+
+  return {
+    retryParams: { '_OverrideTicketID': ticketId },
+    ticketExpressions,
+  };
+}
+
+/**
+ * Handle repo_mismatch: The provided Ticket ID belongs to a different repository.
+ * Prompts the user with 6 recovery options.
+ */
+async function handleRepoMismatch(allText) {
+  const inquirer = (await import('inquirer')).default;
+
+  // Try to extract ticket ID from error text
+  const ticketMatch = allText.match(/Ticket(?:\s+ID)?\s+(?:of\s+)?([A-Za-z0-9_-]+)/i);
+  const ticketId = ticketMatch?.[1] || 'unknown';
+
+  // Try to extract record details
+  const entityMatch = allText.match(/entity:(\w+)/);
+  const rowIdMatch = allText.match(/RowID:(\d+)/);
+  const uidMatch = allText.match(/UID:([a-zA-Z0-9]+)/);
+  const entity = entityMatch?.[1];
+  const rowId = rowIdMatch?.[1];
+  const uid = uidMatch?.[1];
+
+  log.warn(`Ticket "${ticketId}" is for another repository.`);
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'repoAction',
+      message: `The Ticket ID of "${ticketId}" is for another Repository:`,
+      choices: [
+        { name: 'Commit anyway', value: 'commit_one' },
+        { name: 'Submit with another Ticket ID', value: 'change_one' },
+        { name: 'Skip this record', value: 'skip_one' },
+        { name: 'Commit all transactions with this ID anyway', value: 'commit_all' },
+        { name: 'Commit all transactions with another Ticket ID, and update my current Ticket ID reference', value: 'change_all' },
+        { name: 'Skip all', value: 'skip_all' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'newTicketId',
+      message: 'Enter new Ticket ID:',
+      when: (a) => a.repoAction === 'change_one' || a.repoAction === 'change_all',
+      validate: v => v.trim() ? true : 'Ticket ID is required',
+    },
+  ]);
+
+  if (answers.repoAction === 'skip_one') {
+    return { skipRecord: true };
+  }
+  if (answers.repoAction === 'skip_all') {
+    return { skipAll: true };
+  }
+
+  // "Commit anyway" options — retry with same ticket
+  if (answers.repoAction === 'commit_one') {
+    return {
+      retryParams: { '_OverrideTicketID': ticketId },
+      ticketExpressions: [],
+    };
+  }
+  if (answers.repoAction === 'commit_all') {
+    await setGlobalTicket(ticketId);
+    log.dim(`  Will use ticket "${ticketId}" for all remaining submissions`);
+    return {
+      retryParams: { '_OverrideTicketID': ticketId },
+      ticketExpressions: [],
+    };
+  }
+
+  // "Change ticket" options
+  const newTicketId = answers.newTicketId.trim();
+  const ticketExpressions = [];
+
+  if (entity && rowId) {
+    ticketExpressions.push(buildTicketExpression(entity, rowId, newTicketId));
+  }
+
+  if (answers.repoAction === 'change_all') {
+    await setGlobalTicket(newTicketId);
+    log.dim(`  Stored ticket "${newTicketId}" for all future submissions`);
+  } else if (uid) {
+    await setRecordTicket(uid, rowId, entity, newTicketId);
+    log.dim(`  Stored ticket "${newTicketId}" for record ${uid}`);
+  }
+
+  return {
+    retryParams: { '_OverrideTicketID': newTicketId },
+    ticketExpressions,
+  };
+}
+
 /**
  * Parse file arguments in the format: field=@path or just @path
  * Returns objects suitable for multipart upload.

package/src/lib/ticketing.js

@@ -0,0 +1,189 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { log } from './logger.js';
+
+const DBO_DIR = '.dbo';
+const TICKETING_FILE = 'ticketing.local.json';
+
+function dboDir() {
+  return join(process.cwd(), DBO_DIR);
+}
+
+function ticketingPath() {
+  return join(dboDir(), TICKETING_FILE);
+}
+
+const DEFAULT_TICKETING = { ticket_id: null, records: [] };
+
+/**
+ * Load ticketing.local.json. Returns default structure if missing or corrupted.
+ */
+export async function loadTicketing() {
+  try {
+    const raw = await readFile(ticketingPath(), 'utf8');
+    const data = JSON.parse(raw);
+    return {
+      ticket_id: data.ticket_id || null,
+      records: Array.isArray(data.records) ? data.records : [],
+    };
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      log.warn('Ticketing config is corrupted or unreadable — starting fresh.');
+    }
+    return { ...DEFAULT_TICKETING, records: [] };
+  }
+}
+
+/**
+ * Save ticketing.local.json.
+ */
+export async function saveTicketing(data) {
+  await mkdir(dboDir(), { recursive: true });
+  await writeFile(ticketingPath(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Get the global ticket_id, or null if not set.
+ */
+export async function getGlobalTicket() {
+  const data = await loadTicketing();
+  return data.ticket_id || null;
+}
+
+/**
+ * Get the per-record ticket for a specific UID, or null.
+ */
+export async function getRecordTicket(uid) {
+  const data = await loadTicketing();
+  const record = data.records.find(r => r.UID === uid);
+  return record ? record.ticket_id : null;
+}
+
+/**
+ * Set the global ticket_id.
+ */
+export async function setGlobalTicket(ticketId) {
+  const data = await loadTicketing();
+  data.ticket_id = ticketId;
+  await saveTicketing(data);
+}
+
+/**
+ * Store a per-record ticket entry. Deduplicates by UID.
+ */
+export async function setRecordTicket(uid, rowId, entity, ticketId) {
+  const data = await loadTicketing();
+  const idx = data.records.findIndex(r => r.UID === uid);
+  const entry = {
+    UID: uid,
+    RowID: rowId,
+    entity,
+    ticket_id: ticketId,
+    expression: buildTicketExpression(entity, rowId, ticketId),
+  };
+  if (idx >= 0) {
+    data.records[idx] = entry;
+  } else {
+    data.records.push(entry);
+  }
+  await saveTicketing(data);
+}
+
+/**
+ * Clear the global ticket_id (preserves records).
+ */
+export async function clearGlobalTicket() {
+  const data = await loadTicketing();
+  data.ticket_id = null;
+  await saveTicketing(data);
+}
+
+/**
+ * Remove a specific per-record ticket by UID.
+ */
+export async function clearRecordTicket(uid) {
+  const data = await loadTicketing();
+  const before = data.records.length;
+  data.records = data.records.filter(r => r.UID !== uid);
+  if (data.records.length !== before) {
+    await saveTicketing(data);
+  }
+}
+
+/**
+ * Clear all per-record tickets (preserves global ticket_id).
+ */
+export async function clearAllRecordTickets() {
+  const data = await loadTicketing();
+  if (data.records.length > 0) {
+    data.records = [];
+    await saveTicketing(data);
+  }
+}
+
+/**
+ * Build a ticket column expression for DBO input syntax.
+ */
+export function buildTicketExpression(entity, rowId, ticketId) {
+  return `RowID:${rowId};column:${entity}._LastUpdatedTicketID=${ticketId}`;
+}
+
+/**
+ * Check for a stored ticket before batch submission and prompt the user.
+ * Returns { useTicket, clearTicket, cancel }.
+ *
+ * @param {Object} options - Command options (checks options.ticket for flag override)
+ */
+export async function checkStoredTicket(options) {
+  // --ticket flag takes precedence; skip stored-ticket prompt
+  if (options.ticket) {
+    return { useTicket: false, clearTicket: false, cancel: false };
+  }
+
+  const data = await loadTicketing();
+  if (!data.ticket_id) {
+    return { useTicket: false, clearTicket: false, cancel: false };
+  }
+
+  const inquirer = (await import('inquirer')).default;
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: `Use stored Ticket ID "${data.ticket_id}" for this submission?`,
+    choices: [
+      { name: `Yes, use "${data.ticket_id}"`, value: 'use' },
+      { name: 'No, clear stored ticket', value: 'clear' },
+      { name: 'Cancel submission', value: 'cancel' },
+    ],
+  }]);
+
+  return {
+    useTicket: action === 'use',
+    clearTicket: action === 'clear',
+    cancel: action === 'cancel',
+  };
+}
+
+/**
+ * Apply a stored ticket to submission data expressions if no --ticket flag is set.
+ * Checks per-record ticket first, then global ticket.
+ *
+ * @param {string[]} dataExprs - The data expressions array (mutated in place)
+ * @param {string} entity - Entity name
+ * @param {string|number} rowId - Row ID or UID used in the submission
+ * @param {string} uid - Record UID for per-record lookup
+ * @param {Object} options - Command options
+ */
+export async function applyStoredTicketToSubmission(dataExprs, entity, rowId, uid, options) {
+  if (options.ticket) return; // --ticket flag takes precedence
+
+  const recordTicket = await getRecordTicket(uid);
+  const globalTicket = await getGlobalTicket();
+  const ticketToUse = recordTicket || globalTicket;
+
+  if (ticketToUse) {
+    const ticketExpr = buildTicketExpression(entity, rowId, ticketToUse);
+    dataExprs.push(ticketExpr);
+    log.dim(`  Applying ticket: ${ticketToUse}`);
+  }
+}