@otto-assistant/bridge 0.4.102 → 0.4.103

package/src/skill-filter.ts

@@ -0,0 +1,42 @@
+// Computes opencode permission.skill rules from kimaki's --enable-skill /
+// --disable-skill CLI flags.
+//
+// OpenCode filters skills available to the model via
+// Permission.evaluate("skill", skill.name, agent.permission). We inject a
+// top-level permission.skill ruleset into the generated opencode-config.json
+// so every agent inherits the same whitelist/blacklist via Permission.merge.
+//
+// Whitelist mode: { '*': 'deny', 'name': 'allow', ... }
+// Blacklist mode: { 'name': 'deny', ... }
+// Neither set:    undefined (skills are unfiltered)
+//
+// cli.ts validates mutual exclusion of the two flags at startup, so this
+// helper assumes at most one of the two arrays is non-empty.
+
+type PermissionAction = 'ask' | 'allow' | 'deny'
+
+export type SkillPermissionRule = Record<string, PermissionAction>
+
+export function computeSkillPermission({
+  enabledSkills,
+  disabledSkills,
+}: {
+  enabledSkills: string[]
+  disabledSkills: string[]
+}): SkillPermissionRule | undefined {
+  if (enabledSkills.length > 0) {
+    const rules: SkillPermissionRule = { '*': 'deny' }
+    for (const name of enabledSkills) {
+      rules[name] = 'allow'
+    }
+    return rules
+  }
+  if (disabledSkills.length > 0) {
+    const rules: SkillPermissionRule = {}
+    for (const name of disabledSkills) {
+      rules[name] = 'deny'
+    }
+    return rules
+  }
+  return undefined
+}

package/src/store.ts

@@ -65,6 +65,21 @@ export type KimakiState = {
   // Read by: system-message.ts (conditionally appends critique instructions).
   critiqueEnabled: boolean
 
+  // User-specified skill whitelist. When non-empty, only these skill names
+  // are injected into the model's system prompt (all others are hidden
+  // behind an opencode permission.skill deny-all rule). Mutually exclusive
+  // with disabledSkills — cli.ts enforces this at startup.
+  // Changes: set once at startup from --enable-skill CLI flag.
+  // Read by: opencode.ts when building opencode-config.json.
+  enabledSkills: string[]
+
+  // User-specified skill blacklist. Skills listed here are hidden from the
+  // model via opencode permission.skill deny rules. Mutually exclusive with
+  // enabledSkills — cli.ts enforces this at startup.
+  // Changes: set once at startup from --disable-skill CLI flag.
+  // Read by: opencode.ts when building opencode-config.json.
+  disabledSkills: string[]
+
   // Base URL for Discord REST API calls (default https://discord.com).
   // Overridden when using a gateway-proxy or gateway Discord mode.
   // Changes: set by getBotTokenWithMode() which runs at startup and on
@@ -114,6 +129,8 @@ export const store = createStore<KimakiState>(() => ({
   defaultVerbosity: 'text_and_essential_tools',
   defaultMentionMode: false,
   critiqueEnabled: true,
+  enabledSkills: [],
+  disabledSkills: [],
   discordBaseUrl: 'https://discord.com',
   gatewayToken: null,
   registeredUserCommands: [],

package/src/system-message.test.ts

@@ -37,7 +37,7 @@ describe('system-message', () => {
       Your current Discord thread ID is: thread_123
       Your current Discord guild ID is: guild_123
 
-      Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts. Worktree reminders are emitted only when the worktree changes.
+      Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts.
 
       ## permissions
 
@@ -188,6 +188,8 @@ describe('system-message', () => {
       - Replace \`@username\` with the relevant user from the current thread context.
       - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
       - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
+      - If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
+      - Example no-op cleanup command: \`kimaki session archive --session ses_123\`
 
       Manage scheduled tasks with:
 
@@ -203,6 +205,7 @@ describe('system-message', () => {
       - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username only when failures require review".
       - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
       - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
+      - Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive --session ses_123\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
       - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
       kimaki send --session ses_123 --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only --agent <current_agent>
@@ -615,12 +618,13 @@ describe('system-message', () => {
       </system-reminder>
 
       <system-reminder>
-      This session is running inside a git worktree.
-      - Worktree path: /repo/.worktrees/prompt-cache
+      This session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.
+      - New worktree path (new cwd / pwd, edit files here): /repo/.worktrees/prompt-cache
       - Branch: prompt-cache
-      - Main repo: /repo
-      Run checks in this worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.
-      </system-reminder>"
+      - Main repo path (previous folder, DO NOT TOUCH): /repo
+      You MUST read, write, and edit files only under the new worktree path /repo/.worktrees/prompt-cache. You MUST NOT read, write, or edit any files under the main repo path /repo — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.
+      </system-reminder>
+      "
     `)
   })
 })

package/src/system-message.ts

@@ -324,11 +324,17 @@ ${escapePromptText(repliedMessage.text)}
       : []),
     ...(worktree && worktreeChanged
       ? [
-          `<system-reminder>\nThis session is running inside a git worktree.\n- Worktree path: ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo: ${worktree.mainRepoDirectory}\nRun checks in this worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.\n</system-reminder>`,
+          `<system-reminder>\nThis session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.\n- New worktree path (new cwd / pwd, edit files here): ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo path (previous folder, DO NOT TOUCH): ${worktree.mainRepoDirectory}\nYou MUST read, write, and edit files only under the new worktree path ${worktree.worktreeDirectory}. You MUST NOT read, write, or edit any files under the main repo path ${worktree.mainRepoDirectory} — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.\n</system-reminder>`,
         ]
       : []),
   ]
-  return sections.join('\n\n')
+  if (sections.length === 0) {
+    return ''
+  }
+  // Always end synthetic context with a trailing newline so it does not fuse
+  // with the next text part (for example the user's actual prompt) when the
+  // model concatenates message parts.
+  return `${sections.join('\n\n')}\n`
 }
 
 export function getOpencodeSystemMessage({
@@ -374,7 +380,7 @@ This is required to distinguish essential bash calls from read-only ones in low-
 
 Your current OpenCode session ID is: ${sessionId}${channelId ? `\nYour current Discord channel ID is: ${channelId}` : ''}${threadId ? `\nYour current Discord thread ID is: ${threadId}` : ''}${guildId ? `\nYour current Discord guild ID is: ${guildId}` : ''}
 
-Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts. Worktree reminders are emitted only when the worktree changes.
+Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts.
 
 ## permissions
 
@@ -523,6 +529,8 @@ Notification strategy for scheduled tasks:
 - Replace \`@username\` with the relevant user from the current thread context.
 - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
 - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
+- If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
+- Example no-op cleanup command: \`kimaki session archive --session ${sessionId}\`
 
 Manage scheduled tasks with:
 
@@ -538,6 +546,7 @@ Use case patterns:
 - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username only when failures require review".
 - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
 - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
+- Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive --session ${sessionId}\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
 - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
 kimaki send --session ${sessionId} --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only --agent <current_agent>

package/src/thread-message-queue.e2e.test.ts

@@ -919,6 +919,132 @@ e2eTest('thread message queue ordering', () => {
     12_000,
   )
 
+  test(
+    '/clear-queue position clears only that queued message',
+    async () => {
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: clear-queue-setup',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: clear-queue-setup'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 4_000 })
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).runSlashCommand({
+        name: 'queue',
+        options: [{ name: 'message', type: 3, value: 'Reply with exactly: race-final' }],
+      })
+
+      const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: removed-queued-message' }],
+        })
+      const secondQueueAck = await th.waitForInteractionAck({
+        interactionId: secondQueueInteractionId,
+        timeout: 4_000,
+      })
+      if (!secondQueueAck.messageId) {
+        throw new Error('Expected second /queue response message id')
+      }
+
+      const secondQueueAckMessage = await waitForMessageById({
+        discord,
+        threadId: thread.id,
+        messageId: secondQueueAck.messageId,
+        timeout: 4_000,
+      })
+      expect(secondQueueAckMessage.content).toContain('Queued message (position 1)')
+
+      const { id: thirdQueueInteractionId } = await th.user(TEST_USER_ID).runSlashCommand({
+        name: 'queue',
+        options: [{ name: 'message', type: 3, value: 'Reply with exactly: kept-queued-message' }],
+      })
+      const thirdQueueAck = await th.waitForInteractionAck({
+        interactionId: thirdQueueInteractionId,
+        timeout: 4_000,
+      })
+      if (!thirdQueueAck.messageId) {
+        throw new Error('Expected third /queue response message id')
+      }
+
+      const thirdQueueAckMessage = await waitForMessageById({
+        discord,
+        threadId: thread.id,
+        messageId: thirdQueueAck.messageId,
+        timeout: 4_000,
+      })
+      expect(thirdQueueAckMessage.content).toContain('Queued message (position 2)')
+
+      const { id: clearInteractionId } = await th.user(TEST_USER_ID).runSlashCommand({
+        name: 'clear-queue',
+        options: [{ name: 'position', type: 4, value: 1 }],
+      })
+      const clearAck = await th.waitForInteractionAck({
+        interactionId: clearInteractionId,
+        timeout: 4_000,
+      })
+      if (!clearAck.messageId) {
+        throw new Error('Expected /clear-queue response message id')
+      }
+
+      const clearAckMessage = await waitForMessageById({
+        discord,
+        threadId: thread.id,
+        messageId: clearAck.messageId,
+        timeout: 4_000,
+      })
+      expect(clearAckMessage.content).toBe('Cleared queued message at position 1')
+
+      await waitForBotMessageContaining({
+        discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: '» **queue-tester:** Reply with exactly: kept-queued-message',
+        afterMessageId: clearAckMessage.id,
+        timeout: 8_000,
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: '⬥ ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const threadText = await th.text()
+      expect(threadText).toMatchInlineSnapshot(`
+        "--- from: user (queue-tester)
+        Reply with exactly: clear-queue-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **queue-tester:** Reply with exactly: race-final
+        Queued message (position 1)
+        Queued message (position 2)
+        Cleared queued message at position 1
+        ⬥ race-final
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **queue-tester:** Reply with exactly: kept-queued-message"
+      `)
+      expect(threadText).not.toContain('removed-queued-message')
+      expect(threadText).toContain('kept-queued-message')
+    },
+    12_000,
+  )
+
   test(
     'queued message waits for running session and then processes next',
     async () => {

package/src/worktree-lifecycle.e2e.test.ts

@@ -373,7 +373,12 @@ describe('worktree lifecycle', () => {
 
       // sdkDirectory should now point to the worktree path
       expect(runtimeAfter!.sdkDirectory).not.toBe(directories.projectDirectory)
-      expect(runtimeAfter!.sdkDirectory).toContain(`kimaki-${WORKTREE_NAME}`)
+      // Folder name drops the `opencode-kimaki-` prefix (branch name keeps it).
+      // See getManagedWorktreeDirectory in worktrees.ts.
+      expect(runtimeAfter!.sdkDirectory).toContain(WORKTREE_NAME)
+      expect(runtimeAfter!.sdkDirectory).toContain(
+        `${path.sep}worktrees${path.sep}`,
+      )
 
       // Snapshot uses dynamic worktree name so we verify structure, not exact text
       const text = await th.text()

package/src/worktrees.test.ts

@@ -8,19 +8,19 @@ import {
   buildSubmoduleReferencePlan,
   createWorktreeWithSubmodules,
   execAsync,
+  getManagedWorktreeDirectory,
   parseGitmodulesFileContent,
+  parseGitWorktreeListPorcelain,
 } from './worktrees.js'
+import {
+  formatAutoWorktreeName,
+  formatWorktreeName,
+  shortenWorktreeSlug,
+} from './commands/new-worktree.js'
+import { setDataDir } from './config.js'
 
 const GIT_TIMEOUT_MS = 60_000
 
-function gitCommand(args: string[]): string {
-  return `git ${args
-    .map((arg) => {
-      return JSON.stringify(arg)
-    })
-    .join(' ')}`
-}
-
 async function git({
   cwd,
   args,
@@ -28,7 +28,13 @@ async function git({
   cwd: string
   args: string[]
 }): Promise<string> {
-  const result = await execAsync(gitCommand(args), {
+  const command = `git ${args
+    .map((arg) => {
+      return JSON.stringify(arg)
+    })
+    .join(' ')}`
+
+  const result = await execAsync(command, {
     cwd,
     timeout: GIT_TIMEOUT_MS,
   })
@@ -221,4 +227,263 @@ describe('worktrees', () => {
     }
   })
 
+  test('createWorktreeWithSubmodules uses current HEAD even when origin does not have the commit', async () => {
+    const sandbox = createTestRoot()
+    const parentRemote = path.join(sandbox, 'parent-remote.git')
+    const parentLocal = path.join(sandbox, 'parent-local')
+    const worktreeName = `opencode/kimaki-local-head-${Date.now()}`
+
+    let createdWorktreeDirectory = ''
+
+    try {
+      await git({ cwd: sandbox, args: ['init', '--bare', '-b', 'main', parentRemote] })
+      await git({ cwd: sandbox, args: ['clone', parentRemote, parentLocal] })
+
+      await git({
+        cwd: parentLocal,
+        args: ['config', 'user.email', 'kimaki-tests@example.com'],
+      })
+      await git({
+        cwd: parentLocal,
+        args: ['config', 'user.name', 'Kimaki Tests'],
+      })
+
+      fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v1\n', 'utf-8')
+      await git({ cwd: parentLocal, args: ['add', 'README.md'] })
+      await git({ cwd: parentLocal, args: ['commit', '-m', 'v1'] })
+      await git({ cwd: parentLocal, args: ['push', 'origin', 'HEAD:main'] })
+
+      fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v2-local-only\n', 'utf-8')
+      await git({ cwd: parentLocal, args: ['commit', '-am', 'v2 local only'] })
+
+      const localHeadSha = await git({
+        cwd: parentLocal,
+        args: ['rev-parse', 'HEAD'],
+      })
+      const originHeadSha = await git({
+        cwd: parentLocal,
+        args: ['rev-parse', 'origin/main'],
+      })
+
+      const worktreeResult = await createWorktreeWithSubmodules({
+        directory: parentLocal,
+        name: worktreeName,
+      })
+
+      if (worktreeResult instanceof Error) {
+        throw worktreeResult
+      }
+
+      createdWorktreeDirectory = worktreeResult.directory
+      const worktreeHeadSha = await git({
+        cwd: createdWorktreeDirectory,
+        args: ['rev-parse', 'HEAD'],
+      })
+
+      expect({
+        localHeadShaLength: localHeadSha.length,
+        originHeadShaLength: originHeadSha.length,
+        worktreeHeadShaLength: worktreeHeadSha.length,
+        usesLocalOnlyHead: localHeadSha === worktreeHeadSha,
+        differsFromOrigin: localHeadSha !== originHeadSha,
+      }).toMatchInlineSnapshot(`
+        {
+          "differsFromOrigin": true,
+          "localHeadShaLength": 40,
+          "originHeadShaLength": 40,
+          "usesLocalOnlyHead": true,
+          "worktreeHeadShaLength": 40,
+        }
+      `)
+    } finally {
+      if (createdWorktreeDirectory) {
+        await git({
+          cwd: parentLocal,
+          args: ['worktree', 'remove', '--force', createdWorktreeDirectory],
+        }).catch(() => {
+          return ''
+        })
+      }
+      fs.rmSync(sandbox, { recursive: true, force: true })
+    }
+  })
+
+  test('shortenWorktreeSlug leaves short slugs alone', () => {
+    expect(shortenWorktreeSlug('short-name')).toMatchInlineSnapshot(
+      `"short-name"`,
+    )
+    expect(shortenWorktreeSlug('exactly-twenty-chars')).toMatchInlineSnapshot(
+      `"exactly-twenty-chars"`,
+    )
+  })
+
+  test('shortenWorktreeSlug strips vowels from long slugs', () => {
+    expect(
+      shortenWorktreeSlug('configurable-sidebar-width-by-component'),
+    ).toMatchInlineSnapshot(`"cnfgrbl-sdbr-wdth-by-cmpnnt"`)
+    expect(
+      shortenWorktreeSlug('add-dark-mode-toggle-to-settings-page'),
+    ).toMatchInlineSnapshot(`"add-drk-md-tggl-t-sttngs-pg"`)
+  })
+
+  test('formatWorktreeName keeps user-provided slugs verbatim', () => {
+    expect(
+      formatWorktreeName('Configurable sidebar width by component'),
+    ).toMatchInlineSnapshot(`"opencode/kimaki-configurable-sidebar-width-by-component"`)
+    expect(formatWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`)
+  })
+
+  test('formatAutoWorktreeName compresses long auto-derived slugs', () => {
+    expect(
+      formatAutoWorktreeName('Configurable sidebar width by component'),
+    ).toMatchInlineSnapshot(`"opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt"`)
+    expect(formatAutoWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`)
+  })
+
+  test('getManagedWorktreeDirectory writes under kimaki data dir and strips prefix', () => {
+    const sandbox = createTestRoot()
+    try {
+      setDataDir(sandbox)
+      const dir = getManagedWorktreeDirectory({
+        directory: '/Users/test/projects/my-app',
+        name: 'opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt',
+      })
+      // Must sit inside <dataDir>/worktrees/<8hash>/<basename>
+      const rel = path.relative(sandbox, dir)
+      const parts = rel.split(path.sep)
+      expect({
+        topLevel: parts[0],
+        hashLength: parts[1]?.length,
+        basename: parts[2],
+        partsCount: parts.length,
+      }).toMatchInlineSnapshot(`
+        {
+          "basename": "cnfgrbl-sdbr-wdth-by-cmpnnt",
+          "hashLength": 8,
+          "partsCount": 3,
+          "topLevel": "worktrees",
+        }
+      `)
+    } finally {
+      fs.rmSync(sandbox, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('parseGitWorktreeListPorcelain', () => {
+  test('parses porcelain output, skips main worktree', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature',
+      'HEAD def456',
+      'branch refs/heads/opencode/kimaki-feature',
+      '',
+      'worktree /Users/me/project-manual-wt',
+      'HEAD 789abc',
+      'branch refs/heads/my-branch',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "opencode/kimaki-feature",
+          "detached": false,
+          "directory": "/Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature",
+          "head": "def456",
+          "locked": false,
+          "prunable": false,
+        },
+        {
+          "branch": "my-branch",
+          "detached": false,
+          "directory": "/Users/me/project-manual-wt",
+          "head": "789abc",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `)
+  })
+
+  test('handles detached HEAD worktrees', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/detached-wt',
+      'HEAD deadbeef',
+      'detached',
+      '',
+    ].join('\n')
+
+    const result = parseGitWorktreeListPorcelain(output)
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": null,
+          "detached": true,
+          "directory": "/Users/me/detached-wt",
+          "head": "deadbeef",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `)
+  })
+
+  test('parses locked and prunable flags', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/locked-wt',
+      'HEAD aaa111',
+      'branch refs/heads/feature-locked',
+      'locked portable disk',
+      '',
+      'worktree /Users/me/prunable-wt',
+      'HEAD bbb222',
+      'branch refs/heads/stale-branch',
+      'prunable gitdir file points to non-existent location',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "feature-locked",
+          "detached": false,
+          "directory": "/Users/me/locked-wt",
+          "head": "aaa111",
+          "locked": true,
+          "prunable": false,
+        },
+        {
+          "branch": "stale-branch",
+          "detached": false,
+          "directory": "/Users/me/prunable-wt",
+          "head": "bbb222",
+          "locked": false,
+          "prunable": true,
+        },
+      ]
+    `)
+  })
+
+  test('returns empty array when only main worktree exists', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`[]`)
+  })
 })