npm package: @hyperdrive.bot/gut
Description: Git Unified Tooling - Enhanced git with workspace intelligence for entity-based organization
Author: DevSquad
Latest version: 0.1.12

gut
===

Git Unified Tooling - Enhanced git with workspace intelligence for entity-based organization

[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![Version](https://img.shields.io/npm/v/@devsquad/gut.svg)](https://npmjs.org/package/@devsquad/gut)
[![Downloads/week](https://img.shields.io/npm/dw/@devsquad/gut.svg)](https://npmjs.org/package/@devsquad/gut)

<!-- toc -->
* [Usage](#usage)
* [Commands](#commands)
<!-- tocstop -->
# Usage
<!-- usage -->
```sh-session
$ npm install -g @hyperdrive.bot/gut
$ gut COMMAND
running command...
$ gut (--version)
@hyperdrive.bot/gut/0.1.12 linux-x64 node-v22.22.1
$ gut --help [COMMAND]
USAGE
  $ gut COMMAND
...
```
<!-- usagestop -->
# Commands
<!-- commands -->
* [`gut add [PATH]`](#gut-add-path)
* [`gut affected [ENTITY]`](#gut-affected-entity)
* [`gut audit`](#gut-audit)
* [`gut auth login`](#gut-auth-login)
* [`gut auth logout`](#gut-auth-logout)
* [`gut auth status`](#gut-auth-status)
* [`gut back`](#gut-back)
* [`gut checkout BRANCH`](#gut-checkout-branch)
* [`gut commit`](#gut-commit)
* [`gut context`](#gut-context)
* [`gut contexts`](#gut-contexts)
* [`gut deps [ENTITY]`](#gut-deps-entity)
* [`gut entity add NAME TYPE`](#gut-entity-add-name-type)
* [`gut entity clone NAME`](#gut-entity-clone-name)
* [`gut entity clone-all`](#gut-entity-clone-all)
* [`gut entity list`](#gut-entity-list)
* [`gut entity remove NAME`](#gut-entity-remove-name)
* [`gut extract FOLDERPATH`](#gut-extract-folderpath)
* [`gut focus [ENTITYNAME] [ENTITYTYPEORNAME]`](#gut-focus-entityname-entitytypeorname)
* [`gut graph`](#gut-graph)
* [`gut help [COMMAND]`](#gut-help-command)
* [`gut init`](#gut-init)
* [`gut insights`](#gut-insights)
* [`gut patterns`](#gut-patterns)
* [`gut pull`](#gut-pull)
* [`gut push`](#gut-push)
* [`gut quick-setup`](#gut-quick-setup)
* [`gut recent`](#gut-recent)
* [`gut related [ENTITY]`](#gut-related-entity)
* [`gut repos`](#gut-repos)
* [`gut stack`](#gut-stack)
* [`gut status`](#gut-status)
* [`gut sync`](#gut-sync)
* [`gut ticket`](#gut-ticket)
* [`gut ticket config`](#gut-ticket-config)
* [`gut ticket focus TICKETID`](#gut-ticket-focus-ticketid)
* [`gut ticket get TICKETID`](#gut-ticket-get-ticketid)
* [`gut ticket hint [HINT] TICKETID`](#gut-ticket-hint-hint-ticketid)
* [`gut ticket list`](#gut-ticket-list)
* [`gut ticket sync TICKETID`](#gut-ticket-sync-ticketid)
* [`gut ticket update TICKETID`](#gut-ticket-update-ticketid)
* [`gut unfocus`](#gut-unfocus)
* [`gut used-by [ENTITY]`](#gut-used-by-entity)
* [`gut workspace ACTION`](#gut-workspace-action)
* [`gut worktree create NAME`](#gut-worktree-create-name)

## `gut add [PATH]`

Stage changes in focused entities

```
USAGE
  $ gut add [PATH] [-A] [-p]

ARGUMENTS
  PATH  [default: .] Path(s) to stage

FLAGS
  -A, --all    Stage all changes (equivalent to git add -A)
  -p, --patch  Interactive staging

DESCRIPTION
  Stage changes in focused entities

EXAMPLES
  $ gut add

  $ gut add .

  $ gut add src/

  $ gut add --all
```

## `gut affected [ENTITY]`

Detect entities potentially affected by changes in current focus

```
USAGE
  $ gut affected [ENTITY] [--include-docs] [--include-tests] [-s <value>] [-v]

ARGUMENTS
  ENTITY  Entity to analyze (uses current focus if not provided)

FLAGS
  -s, --since=<value>  [default: HEAD~1] Git reference to compare against
  -v, --verbose        Show detailed analysis
      --include-docs   Include documentation changes in analysis
      --include-tests  Include test file changes in analysis

DESCRIPTION
  Detect entities potentially affected by changes in current focus

EXAMPLES
  $ gut affected

  $ gut affected my-app

  $ gut affected --since HEAD~5

  $ gut affected --include-tests
```

## `gut audit`

Access and change audit across workspace

```
USAGE
  $ gut audit [-a] [--changes] [-c] [-e <value>] [--json] [-s]

FLAGS
  -a, --access          audit access patterns and permissions
  -c, --compliance      focus on compliance audit
  -e, --entity=<value>  audit specific entity
  -s, --security        focus on security audit
      --changes         audit recent changes and activity
      --json            output as JSON

DESCRIPTION
  Access and change audit across workspace

EXAMPLES
  $ gut audit

  $ gut audit --entity mindtools

  $ gut audit --security

  $ gut audit --compliance
```

## `gut auth login`

Authenticate with Gut using OAuth 2.0 PKCE flow

```
USAGE
  $ gut auth login [-d <value>] [-p <value>]

FLAGS
  -d, --domain=<value>  Tenant domain (e.g., acme.hyperdrive.bot)
  -p, --port=<value>    [default: 8766] Local callback server port

DESCRIPTION
  Authenticate with Gut using OAuth 2.0 PKCE flow

EXAMPLES
  $ gut auth login

  $ gut auth login --domain acme.hyperdrive.bot

  $ gut auth login --port 9876
```

## `gut auth logout`

Remove stored credentials and logout

```
USAGE
  $ gut auth logout

DESCRIPTION
  Remove stored credentials and logout

EXAMPLES
  $ gut auth logout
```

## `gut auth status`

Show current authentication status

```
USAGE
  $ gut auth status [-v]

FLAGS
  -v, --verbose  Show detailed credential information

DESCRIPTION
  Show current authentication status

EXAMPLES
  $ gut auth status

  $ gut auth status --verbose
```

## `gut back`

Navigate back to the previous focus

```
USAGE
  $ gut back

DESCRIPTION
  Navigate back to the previous focus

EXAMPLES
  $ gut back
```

## `gut checkout BRANCH`

Checkout or create branches in focused repositories

```
USAGE
  $ gut checkout BRANCH [-b] [-f] [--from <value>]

ARGUMENTS
  BRANCH  Branch name to checkout or create

FLAGS
  -b, --create-branch  Create a new branch
  -f, --force          Force checkout (discard local changes)
      --from=<value>   Base branch to create from (use with -b)

DESCRIPTION
  Checkout or create branches in focused repositories

EXAMPLES
  $ gut checkout main

  $ gut checkout -b feature/new-feature

  $ gut checkout -b PRD-123 --from main
```

## `gut commit`

Commit changes in focused repositories

```
USAGE
  $ gut commit [-a] [--amend] [-m <value>]

FLAGS
  -a, --all              Stage all changes before committing
  -m, --message=<value>  Commit message
      --amend            Amend the previous commit

DESCRIPTION
  Commit changes in focused repositories

EXAMPLES
  $ gut commit -m "Fix bug"

  $ gut commit --message "Add feature"

  $ gut commit
```

## `gut context`

Show current focus context with entity details

```
USAGE
  $ gut context

DESCRIPTION
  Show current focus context with entity details

EXAMPLES
  $ gut context
```

## `gut contexts`

List all available contexts and focus history

```
USAGE
  $ gut contexts

DESCRIPTION
  List all available contexts and focus history

EXAMPLES
  $ gut contexts
```

## `gut deps [ENTITY]`

Show dependencies of current focus or specified entity

```
USAGE
  $ gut deps [ENTITY]

ARGUMENTS
  ENTITY  Entity name to analyze dependencies for

DESCRIPTION
  Show dependencies of current focus or specified entity

EXAMPLES
  $ gut deps

  $ gut deps mindtools
```

## `gut entity add NAME TYPE`

Add a new entity to the workspace

```
USAGE
  $ gut entity add NAME TYPE -p <value> [-d <value>] [-r <value>] [--repo <value>]

ARGUMENTS
  NAME  Entity name
  TYPE  (client|prospect|company|initiative|system|delivery|module|service|tool) Entity type

FLAGS
  -d, --description=<value>  entity description
  -p, --path=<value>         (required) path to entity
  -r, --remote=<value>       git remote URL
      --repo=<value>         repository name (for GitLab/GitHub)

DESCRIPTION
  Add a new entity to the workspace

EXAMPLES
  $ gut entity add delivery my-app --path ./apps/my-app

  $ gut entity add module my-lib --path ./libs/my-lib --remote git@github.com:org/my-lib.git
```

## `gut entity clone NAME`

Clone a specific entity from its repository

```
USAGE
  $ gut entity clone NAME [-b <value>] [-d <value>] [-f] [-p <value>]

ARGUMENTS
  NAME  Name of the entity to clone

FLAGS
  -b, --branch=<value>  Branch to clone (auto-detects workspace branch, falls back to master)
  -d, --depth=<value>   Create a shallow clone with specified depth
  -f, --force           Force clone even if directory exists
  -p, --path=<value>    Custom path to clone to (relative to workspace)

DESCRIPTION
  Clone a specific entity from its repository

EXAMPLES
  $ gut entity clone my-app

  $ gut entity clone my-app --branch develop

  $ gut entity clone my-app --depth 1
```

## `gut entity clone-all`

Clone all configured entities from their repositories

```
USAGE
  $ gut entity clone-all [-b <value>] [-d <value>] [-f] [-p] [--skip-existing]

FLAGS
  -b, --branch=<value>  Branch to clone for all entities (auto-detects workspace branch, falls back to master)
  -d, --depth=<value>   Create shallow clones with specified depth
  -f, --force           Force clone even if directories exist
  -p, --parallel        Clone entities in parallel
      --skip-existing   Skip entities that already exist

DESCRIPTION
  Clone all configured entities from their repositories

EXAMPLES
  $ gut entity clone-all

  $ gut entity clone-all --parallel

  $ gut entity clone-all --branch develop

  $ gut entity clone-all --skip-existing
```

## `gut entity list`

List all configured entities

```
USAGE
  $ gut entity list [--json] [-t client|company|delivery|initiative|module|prospect|service|system|tool] [-v]

FLAGS
  -t, --type=<option>  filter by entity type
                       <options: client|company|delivery|initiative|module|prospect|service|system|tool>
  -v, --verbose        show detailed information
      --json           output as JSON

DESCRIPTION
  List all configured entities

EXAMPLES
  $ gut entity list

  $ gut entity list --type delivery

  $ gut entity list --json
```

## `gut entity remove NAME`

Remove an entity from the workspace configuration

```
USAGE
  $ gut entity remove NAME [-f]

ARGUMENTS
  NAME  Entity name to remove

FLAGS
  -f, --force  skip confirmation prompt

DESCRIPTION
  Remove an entity from the workspace configuration

EXAMPLES
  $ gut entity remove my-app

  $ gut entity remove my-app --force
```

## `gut extract FOLDERPATH`

Extract a folder from the current repository into its own repository with full git history

```
USAGE
  $ gut extract FOLDERPATH [--dry-run] [-f] [--gitlab-token <value>] [--gitlab-url <value>] [--keep-temp]
    [--project-path <value>] [--target-path <value>] [--temp-dir <value>]

ARGUMENTS
  FOLDERPATH  Path to the folder to extract from the current repository

FLAGS
  -f, --force                 Force extraction even if target directory exists
      --dry-run               Show what would be done without actually doing it
      --gitlab-token=<value>  GitLab personal access token for creating projects
      --gitlab-url=<value>    [default: https://gitlab.com] GitLab instance URL
      --keep-temp             Keep temporary directory after extraction
      --project-path=<value>  GitLab project path (group/project-name)
      --target-path=<value>   [default: .] Target path in the new repository (default: same as source folder)
      --temp-dir=<value>      Custom temporary directory path

DESCRIPTION
  Extract a folder from the current repository into its own repository with full git history

EXAMPLES
  $ gut extract packages/my-package --gitlab-token <token> --project-path my-group/my-package

  $ gut extract src/components --gitlab-token <token> --project-path my-group/frontend/components --target-path .

  $ gut extract libs/shared --gitlab-token <token> --project-path company/backend/libs/shared-utils
```

## `gut focus [ENTITYNAME] [ENTITYTYPEORNAME]`

Set focus on one or more entities with optional type and mode

```
USAGE
  $ gut focus [ENTITYNAME...] [ENTITYTYPEORNAME...] [-c | -a | -m
    delivery|strategy|audit|debug|research|proposal] [-d <value>] [-r]

ARGUMENTS
  ENTITYNAME...        Entity name (when first arg is entity type)
  ENTITYTYPEORNAME...  Entity type (client/prospect/company/initiative) or entity name

FLAGS
  -a, --add               add to current focus instead of replacing
  -c, --clear             clear current focus
  -d, --duration=<value>  focus duration (e.g., 2h, 90m)
  -m, --mode=<option>     focus mode (delivery, strategy, audit, debug, research, proposal)
                          <options: delivery|strategy|audit|debug|research|proposal>
  -r, --remember          remember current focus before switching

DESCRIPTION
  Set focus on one or more entities with optional type and mode

EXAMPLES
  $ gut focus my-app

  $ gut focus client mindtools

  $ gut focus client mindtools --mode delivery

  $ gut focus prospect jazida --mode research

  $ gut focus my-app auth-service

  $ gut focus --clear
```

## `gut graph`

Visualize repository relationships and dependencies

```
USAGE
  $ gut graph [-d <value>] [--focus-only] [-f ascii|dot|json]

FLAGS
  -d, --depth=<value>    [default: 2] maximum depth of relationships to show
  -f, --format=<option>  [default: ascii] output format
                         <options: ascii|dot|json>
      --focus-only       show only focused entities and their relationships

DESCRIPTION
  Visualize repository relationships and dependencies

EXAMPLES
  $ gut graph

  $ gut graph --format ascii

  $ gut graph --focus-only
```

## `gut help [COMMAND]`

Display help for gut.

```
USAGE
  $ gut help [COMMAND...] [-n]

ARGUMENTS
  COMMAND...  Command to show help for.

FLAGS
  -n, --nested-commands  Include all nested commands in the output.

DESCRIPTION
  Display help for gut.
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.32/src/commands/help.ts)_

## `gut init`

Initialize a gut workspace

```
USAGE
  $ gut init [-f] [-w <value>]

FLAGS
  -f, --force              force initialization even if already initialized
  -w, --workspace=<value>  [default: /builds/JOkrpDV8M/0/dev_squad/repo/cli/gut] workspace root directory

DESCRIPTION
  Initialize a gut workspace

EXAMPLES
  $ gut init

  $ gut init --force
```

## `gut insights`

Display analytics and insights about the workspace

```
USAGE
  $ gut insights [-d] [-f table|json|summary] [--include-ignored]

FLAGS
  -d, --detailed         Show detailed statistics for each entity
  -f, --format=<option>  [default: table] Output format
                         <options: table|json|summary>
      --include-ignored  Include gitignored files in statistics

DESCRIPTION
  Display analytics and insights about the workspace

EXAMPLES
  $ gut insights

  $ gut insights --detailed

  $ gut insights --format json
```

## `gut patterns`

Show learned patterns for current context or entities

```
USAGE
  $ gut patterns [-e <value>] [--json] [-m delivery|strategy|audit|debug|research|proposal] [-t
    client|prospect|company|initiative|system]

FLAGS
  -e, --entity=<value>  show patterns for specific entity
  -m, --mode=<option>   show patterns for focus mode
                        <options: delivery|strategy|audit|debug|research|proposal>
  -t, --type=<option>   show patterns for entity type
                        <options: client|prospect|company|initiative|system>
      --json            output as JSON

DESCRIPTION
  Show learned patterns for current context or entities

EXAMPLES
  $ gut patterns

  $ gut patterns --entity mindtools

  $ gut patterns --type client

  $ gut patterns --mode strategy
```

## `gut pull`

Pull changes from remote repositories

```
USAGE
  $ gut pull [--all] [--no-commit] [-r]

FLAGS
  -r, --rebase     Rebase instead of merge
      --all        Fetch all remotes
      --no-commit  Perform merge but do not commit

DESCRIPTION
  Pull changes from remote repositories

EXAMPLES
  $ gut pull

  $ gut pull --rebase

  $ gut pull --all
```

## `gut push`

Push commits to remote repositories

```
USAGE
  $ gut push [-f] [-u] [--tags]

FLAGS
  -f, --force         Force push (use with caution)
  -u, --set-upstream  Set upstream branch
      --tags          Push tags

DESCRIPTION
  Push commits to remote repositories

EXAMPLES
  $ gut push

  $ gut push --force

  $ gut push --set-upstream
```

## `gut quick-setup`

Automated workspace setup based on common patterns

```
USAGE
  $ gut quick-setup [-a] [--clone-missing] [-p monorepo|microservices|fullstack|library] [--scan-depth <value>]

FLAGS
  -a, --auto                Auto-detect and configure without prompts
  -p, --profile=<option>    Use specific setup profile
                            <options: monorepo|microservices|fullstack|library>
      --clone-missing       Clone missing repositories if found
      --scan-depth=<value>  [default: 2] Directory depth to scan for entities

DESCRIPTION
  Automated workspace setup based on common patterns

EXAMPLES
  $ gut quick-setup

  $ gut quick-setup --auto

  $ gut quick-setup --profile monorepo

  $ gut quick-setup --scan-depth 3
```

## `gut recent`

Show recent focus history

```
USAGE
  $ gut recent [-l <value>]

FLAGS
  -l, --limit=<value>  [default: 5] Number of recent items to show

DESCRIPTION
  Show recent focus history

EXAMPLES
  $ gut recent

  $ gut recent --limit 10
```

## `gut related [ENTITY]`

Find entities related to a specific entity or current focus

```
USAGE
  $ gut related [ENTITY] [-d] [-t <value>] [--type all|dependencies|git|files]

ARGUMENTS
  ENTITY  Entity name (uses current focus if not provided)

FLAGS
  -d, --detailed           Show detailed relation information
  -t, --threshold=<value>  [default: 0.2] Minimum relation score (0-1)
      --type=<option>      [default: all] Type of relation to check
                           <options: all|dependencies|git|files>

DESCRIPTION
  Find entities related to a specific entity or current focus

EXAMPLES
  $ gut related my-app

  $ gut related --threshold 0.3

  $ gut related --type dependencies
```

## `gut repos`

List accessible repositories in the workspace

```
USAGE
  $ gut repos [-a] [--json] [-s] [-t client|prospect|company|initiative|system|delivery|module|service|tool]

FLAGS
  -a, --accessible     show only accessible repositories (with valid paths)
  -s, --status         show git status for each repository
  -t, --type=<option>  filter by entity type
                       <options: client|prospect|company|initiative|system|delivery|module|service|tool>
      --json           output as JSON

DESCRIPTION
  List accessible repositories in the workspace

EXAMPLES
  $ gut repos

  $ gut repos --type client

  $ gut repos --status

  $ gut repos --json
```

## `gut stack`

Show and manage the focus stack

```
USAGE
  $ gut stack [-c]

FLAGS
  -c, --clear  clear the focus stack

DESCRIPTION
  Show and manage the focus stack

EXAMPLES
  $ gut stack

  $ gut stack --clear
```

## `gut status`

Show git status for focused entities

```
USAGE
  $ gut status [-a] [--json] [-v]

FLAGS
  -a, --all      show status for all entities
  -v, --verbose  show detailed status
      --json     output as JSON

DESCRIPTION
  Show git status for focused entities

EXAMPLES
  $ gut status

  $ gut status --all

  $ gut status --verbose
```

## `gut sync`

Synchronize repositories with remote (fetch, merge/rebase, push)

```
USAGE
  $ gut sync [-f] [--no-push] [-r]

FLAGS
  -f, --force    Force push after sync
  -r, --rebase   Use rebase instead of merge
      --no-push  Skip the push step

DESCRIPTION
  Synchronize repositories with remote (fetch, merge/rebase, push)

EXAMPLES
  $ gut sync

  $ gut sync --rebase

  $ gut sync --force
```

## `gut ticket`

Manage gut tickets from the ADHB (Autonomous Development with Human Backstop) system

```
USAGE
  $ gut ticket [-h]

FLAGS
  -h, --help  Show CLI help.

DESCRIPTION
  Manage gut tickets from the ADHB (Autonomous Development with Human Backstop) system

EXAMPLES
  $ gut ticket list

  $ gut ticket get PROJ-1234

  $ gut ticket focus PROJ-1234

  $ gut ticket hint PROJ-1234 "Check the config file"

  $ gut ticket sync PROJ-1234

  $ gut ticket update PROJ-1234 --status in_progress
```

## `gut ticket config`

Configure ticket source (JIRA, GitHub, etc.) for this tenant

```
USAGE
  $ gut ticket config [--secret-arn <value>] [-j] [--show] [--type jira|github|linear] [--url <value>]

FLAGS
  -j, --json                output as JSON
      --secret-arn=<value>  AWS Secrets Manager ARN for credentials
      --show                show current configuration
      --type=<option>       source type
                            <options: jira|github|linear>
      --url=<value>         base URL (e.g., https://company.atlassian.net)

DESCRIPTION
  Configure ticket source (JIRA, GitHub, etc.) for this tenant

EXAMPLES
  $ gut ticket config --show

  $ gut ticket config --type jira --url https://company.atlassian.net --secret-arn arn:aws:secretsmanager:...
```

## `gut ticket focus TICKETID`

Focus on a ticket - downloads manifest and clones required entities

```
USAGE
  $ gut ticket focus TICKETID [-c] [-j] [-m] [-o <value>]

ARGUMENTS
  TICKETID  ticket ID to focus on (e.g., PROJ-1234)

FLAGS
  -c, --checkout        checkout the ticket branch after cloning
  -j, --json            output as JSON
  -m, --manifest-only   only download manifest, do not clone entities
  -o, --output=<value>  output directory for manifest (default: focus/)

DESCRIPTION
  Focus on a ticket - downloads manifest and clones required entities

EXAMPLES
  $ gut ticket focus PROJ-1234

  $ gut ticket focus PROJ-1234 --checkout

  $ gut ticket focus PROJ-1234 --manifest-only

  $ gut ticket focus PROJ-1234 --output ./my-ticket
```

## `gut ticket get TICKETID`

Get details for a gut ticket

```
USAGE
  $ gut ticket get TICKETID [-j]

ARGUMENTS
  TICKETID  ticket ID (e.g., PROJ-1234)

FLAGS
  -j, --json  output as JSON

DESCRIPTION
  Get details for a gut ticket

EXAMPLES
  $ gut ticket get PROJ-1234

  $ gut ticket get PROJ-1234 --json
```

## `gut ticket hint [HINT] TICKETID`

Add a hint to a blocked or needs_clarity ticket to help AI retry

```
USAGE
  $ gut ticket hint [HINT] TICKETID [-e] [-g <value>] [-j]

ARGUMENTS
  HINT      hint text to add (if not provided, will prompt)
  TICKETID  ticket ID to add hint to

FLAGS
  -e, --editor            open editor for hint text
  -g, --given-by=<value>  [default: human] identifier of who is giving the hint
  -j, --json              output as JSON

DESCRIPTION
  Add a hint to a blocked or needs_clarity ticket to help AI retry

EXAMPLES
  $ gut ticket hint PROJ-1234 "The auth token is in the Authorization header"

  $ gut ticket hint PROJ-1234 --editor

  $ gut ticket hint PROJ-1234
```

## `gut ticket list`

List gut tickets

```
USAGE
  $ gut ticket list [-j] [-l <value>] [-s
    enriching|needs_clarity|ready|in_progress|testing|in_review|blocked|ready_to_merge|deploying|validating|done]

FLAGS
  -j, --json             output as JSON
  -l, --limit=<value>    [default: 20] maximum number of tickets to show
  -s, --status=<option>  filter by status (enriching, needs_clarity, ready, in_progress, testing, in_review, blocked,
                         ready_to_merge, deploying, validating, done)
                         <options: enriching|needs_clarity|ready|in_progress|testing|in_review|blocked|ready_to_merge|de
                         ploying|validating|done>

DESCRIPTION
  List gut tickets

EXAMPLES
  $ gut ticket list

  $ gut ticket list --status ready

  $ gut ticket list --status blocked --limit 10

  $ gut ticket list --json
```

## `gut ticket sync TICKETID`

Sync ticket state with external source (JIRA, GitHub, etc.)

```
USAGE
  $ gut ticket sync TICKETID [-d push|pull] [-j] [--no-enrich]

ARGUMENTS
  TICKETID  ticket ID to sync (e.g., PROJ-1234)

FLAGS
  -d, --direction=<option>  [default: push] sync direction (push: gut -> source, pull: source -> gut)
                            <options: push|pull>
  -j, --json                output as JSON
      --no-enrich           skip enrichment queue when pulling new tickets

DESCRIPTION
  Sync ticket state with external source (JIRA, GitHub, etc.)

  For pull direction:
  - If ticket exists in gut: updates from source
  - If ticket doesn't exist: creates it and queues enrichment

  For push direction:
  - Updates source system with gut ticket state

EXAMPLES
  $ gut ticket sync PROJ-1234

  $ gut ticket sync PROJ-1234 --direction push

  $ gut ticket sync PROJ-1234 --direction pull

  $ gut ticket sync PROJ-1234 --direction pull --no-enrich
```

## `gut ticket update TICKETID`

Update a ticket status or confidence

```
USAGE
  $ gut ticket update TICKETID [-c <value>] [-j] [-p
    enrichment|planning|implementation|testing|review|merge|deployment|validation] [-s
    enriching|needs_clarity|ready|in_progress|testing|in_review|blocked|ready_to_merge|deploying|validating|done]

ARGUMENTS
  TICKETID  ticket ID to update

FLAGS
  -c, --confidence=<value>  new confidence score (0-100)
  -j, --json                output as JSON
  -p, --phase=<option>      new workflow phase
                            <options: enrichment|planning|implementation|testing|review|merge|deployment|validation>
  -s, --status=<option>     new ticket status (enriching, needs_clarity, ready, in_progress, testing, in_review,
                            blocked, ready_to_merge, deploying, validating, done)
                            <options: enriching|needs_clarity|ready|in_progress|testing|in_review|blocked|ready_to_merge
                            |deploying|validating|done>

DESCRIPTION
  Update a ticket status or confidence

EXAMPLES
  $ gut ticket update PROJ-1234 --status in_progress

  $ gut ticket update PROJ-1234 --status testing --confidence 85

  $ gut ticket update PROJ-1234 --phase implementation
```

## `gut unfocus`

Clear the current focus

```
USAGE
  $ gut unfocus

DESCRIPTION
  Clear the current focus

EXAMPLES
  $ gut unfocus
```

## `gut used-by [ENTITY]`

Show what entities depend on current focus or specified entity

```
USAGE
  $ gut used-by [ENTITY]

ARGUMENTS
  ENTITY  Entity name to analyze usage for

DESCRIPTION
  Show what entities depend on current focus or specified entity

EXAMPLES
  $ gut used-by

  $ gut used-by api
```

## `gut workspace ACTION`

Manage workspace structure and entity metadata

```
USAGE
  $ gut workspace ACTION [-t client|prospect|company|initiative|system] [-f]

ARGUMENTS
  ACTION  (init|structure|generate-metadata) Action to perform (init, structure, generate-metadata)

FLAGS
  -f, --force                 force overwrite existing files
  -t, --entity-type=<option>  entity type for metadata generation
                              <options: client|prospect|company|initiative|system>

DESCRIPTION
  Manage workspace structure and entity metadata

EXAMPLES
  $ gut workspace init

  $ gut workspace structure

  $ gut workspace generate-metadata
```

## `gut worktree create NAME`

Create mirrored worktrees for super-repo and focused entities

```
USAGE
  $ gut worktree create NAME [--base-dir <value>] [--from <value>] [--install]

ARGUMENTS
  NAME  Branch name for the worktree

FLAGS
  --base-dir=<value>  [default: /tmp/gut-worktrees] Root directory for worktrees
  --from=<value>      Base branch to create from (defaults to current branch)
  --install           Run pnpm install after creation

DESCRIPTION
  Create mirrored worktrees for super-repo and focused entities

EXAMPLES
  $ gut worktree create workflow/deploy-batch

  $ gut worktree create workflow/deploy-batch --from master --install

  $ gut worktree create feature/story-42 --base-dir /home/user/worktrees
```
<!-- commandsstop -->