release: v0.1.15

* fix(publish): make git operations idempotent

- Check for staged changes before commit
- Check if tag exists before creating
- Check if release exists before creating

* fix(session-recovery): handle empty content from interrupted reasoning

- Add THINKING_TYPES set including 'reasoning' type (OpenCode's thinking)
- Add hasNonEmptyOutput() to detect messages with only thinking/meta parts
- Add findEmptyContentMessage() to scan all messages for empty content
- Handle step-start/step-finish meta parts in empty content detection
- Patch interrupted messages with '(interrupted)' text before falling back to revert

AGENTS.md

@@ -84,9 +84,31 @@ bun run build
 bun run rebuild
 ```
 
+## DEPLOYMENT
+
+**배포는 GitHub Actions workflow_dispatch로만 진행**
+
+1. package.json 버전은 수정하지 않음 (워크플로우에서 자동 bump)
+2. 변경사항 커밋 & 푸시
+3. GitHub Actions에서 `publish` 워크플로우 수동 실행
+   - `bump`: major | minor | patch 선택
+   - `version`: (선택) 특정 버전 지정 가능
+
+```bash
+# 워크플로우 실행 (CLI)
+gh workflow run publish -f bump=patch
+
+# 워크플로우 상태 확인
+gh run list --workflow=publish
+```
+
+**주의사항**:
+- `bun publish` 직접 실행 금지 (OIDC provenance 문제)
+- 로컬에서 버전 bump 하지 말 것
+
 ## NOTES
 
 - **No tests**: Test framework not configured
-- **No CI/CD**: GitHub workflows not present
+- **CI/CD**: GitHub Actions publish workflow 사용
 - **Version requirement**: OpenCode >= 1.0.132 (earlier versions have config bugs)
 - **Multi-language docs**: README.md, README.en.md, README.ko.md

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

script/publish.ts

@@ -78,13 +78,35 @@ async function gitTagAndRelease(newVersion: string, changelog: string): Promise<
   await $`git config user.email "github-actions[bot]@users.noreply.github.com"`
   await $`git config user.name "github-actions[bot]"`
   await $`git add package.json`
-  await $`git commit -m "release: v${newVersion}"`
-  await $`git tag v${newVersion}`
+
+  // Commit only if there are staged changes (idempotent)
+  const hasStagedChanges = await $`git diff --cached --quiet`.nothrow()
+  if (hasStagedChanges.exitCode !== 0) {
+    await $`git commit -m "release: v${newVersion}"`
+  } else {
+    console.log("No changes to commit (version already updated)")
+  }
+
+  // Tag only if it doesn't exist (idempotent)
+  const tagExists = await $`git rev-parse v${newVersion}`.nothrow()
+  if (tagExists.exitCode !== 0) {
+    await $`git tag v${newVersion}`
+  } else {
+    console.log(`Tag v${newVersion} already exists`)
+  }
+
+  // Push (idempotent - git push is already idempotent)
   await $`git push origin HEAD --tags`
 
+  // Create release only if it doesn't exist (idempotent)
   console.log("\nCreating GitHub release...")
   const releaseNotes = changelog || "No notable changes"
-  await $`gh release create v${newVersion} --title "v${newVersion}" --notes ${releaseNotes}`
+  const releaseExists = await $`gh release view v${newVersion}`.nothrow()
+  if (releaseExists.exitCode !== 0) {
+    await $`gh release create v${newVersion} --title "v${newVersion}" --notes ${releaseNotes}`
+  } else {
+    console.log(`Release v${newVersion} already exists`)
+  }
 }
 
 async function checkVersionExists(version: string): Promise<boolean> {

src/hooks/session-recovery.ts

@@ -211,29 +211,93 @@ async function recoverThinkingDisabledViolation(
   return false
 }
 
+const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
+
+function hasNonEmptyOutput(msg: MessageData): boolean {
+  const parts = msg.parts
+  if (!parts || parts.length === 0) return false
+
+  return parts.some((p) => {
+    if (THINKING_TYPES.has(p.type)) return false
+    if (p.type === "step-start" || p.type === "step-finish") return false
+    if (p.type === "text" && p.text && p.text.trim()) return true
+    if (p.type === "tool_use" && p.id) return true
+    if (p.type === "tool_result") return true
+    return false
+  })
+}
+
+function findEmptyContentMessage(msgs: MessageData[]): MessageData | null {
+  for (let i = 0; i < msgs.length; i++) {
+    const msg = msgs[i]
+    const isLastMessage = i === msgs.length - 1
+    const isAssistant = msg.info?.role === "assistant"
+
+    if (isLastMessage && isAssistant) continue
+
+    if (!hasNonEmptyOutput(msg)) {
+      return msg
+    }
+  }
+  return null
+}
+
 async function recoverEmptyContentMessage(
   client: Client,
   sessionID: string,
   failedAssistantMsg: MessageData,
   directory: string
 ): Promise<boolean> {
-  const messageID = failedAssistantMsg.info?.id
-  const parentMsgID = failedAssistantMsg.info?.parentID
-
-  if (!messageID) {
-    return false
-  }
-
-  // Revert to parent message (delete the empty message)
-  const revertTargetID = parentMsgID || messageID
-
   try {
+    const messagesResp = await client.session.messages({
+      path: { id: sessionID },
+      query: { directory },
+    })
+    const msgs = (messagesResp as { data?: MessageData[] }).data
+
+    if (!msgs || msgs.length === 0) return false
+
+    const emptyMsg = findEmptyContentMessage(msgs) || failedAssistantMsg
+    const messageID = emptyMsg.info?.id
+    if (!messageID) return false
+
+    const existingParts = emptyMsg.parts || []
+    const hasOnlyThinkingOrMeta = existingParts.length > 0 && existingParts.every(
+      (p) => THINKING_TYPES.has(p.type) || p.type === "step-start" || p.type === "step-finish"
+    )
+
+    if (hasOnlyThinkingOrMeta) {
+      const strippedParts: MessagePart[] = [{ type: "text", text: "(interrupted)" }]
+
+      try {
+        // @ts-expect-error - Experimental API
+        await client.message?.update?.({
+          path: { id: messageID },
+          body: { parts: strippedParts },
+        })
+        return true
+      } catch {
+        // message.update not available
+      }
+
+      try {
+        // @ts-expect-error - Experimental API
+        await client.session.patch?.({
+          path: { id: sessionID },
+          body: { messageID, parts: strippedParts },
+        })
+        return true
+      } catch {
+        // session.patch not available
+      }
+    }
+
+    const revertTargetID = emptyMsg.info?.parentID || messageID
     await client.session.revert({
       path: { id: sessionID },
       body: { messageID: revertTargetID },
       query: { directory },
     })
-
     return true
   } catch {
     return false

src/tools/ast-grep/tools.ts

@@ -10,13 +10,55 @@ function showOutputToUser(context: unknown, output: string): void {
   ctx.metadata?.({ metadata: { output } })
 }
 
+/**
+ * JS/TS languages that require complete function declaration patterns
+ */
+const JS_TS_LANGUAGES = ["javascript", "typescript", "tsx"] as const
+
+/**
+ * Validates AST pattern for common incomplete patterns that will fail silently.
+ * Only validates JS/TS languages where function declarations require body.
+ *
+ * @throws Error with helpful message if pattern is incomplete
+ */
+function validatePatternForCli(pattern: string, lang: CliLanguage): void {
+  if (!JS_TS_LANGUAGES.includes(lang as (typeof JS_TS_LANGUAGES)[number])) {
+    return
+  }
+
+  const src = pattern.trim()
+
+  // Detect incomplete function declarations:
+  // - "function $NAME" (no params/body)
+  // - "export function $NAME" (no params/body)
+  // - "export async function $NAME" (no params/body)
+  // - "export default function $NAME" (no params/body)
+  // Pattern: ends with $METAVAR (uppercase, underscore, digits) without ( or {
+  const incompleteFunctionDecl =
+    /^(export\s+)?(default\s+)?(async\s+)?function\s+\$[A-Z_][A-Z0-9_]*\s*$/i.test(src)
+
+  if (incompleteFunctionDecl) {
+    throw new Error(
+      `Incomplete AST pattern for ${lang}: "${pattern}"\n\n` +
+        `ast-grep requires complete AST nodes. Function declarations must include parameters and body.\n\n` +
+        `Examples of correct patterns:\n` +
+        `  - "export async function $NAME($$$) { $$$ }" (matches export async functions)\n` +
+        `  - "function $NAME($$$) { $$$ }" (matches all function declarations)\n` +
+        `  - "async function $NAME($$$) { $$$ }" (matches async functions)\n\n` +
+        `Your pattern "${pattern}" is missing the parameter list and body.`
+    )
+  }
+}
+
 export const ast_grep_search = tool({
   description:
     "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. " +
     "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " +
+    "IMPORTANT: Patterns must be complete AST nodes (valid code). " +
+    "For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. " +
     "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
   args: {
-    pattern: tool.schema.string().describe("AST pattern with meta-variables ($VAR, $$$)"),
+    pattern: tool.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
     lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
     paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search (default: ['.'])"),
     globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
@@ -24,6 +66,8 @@ export const ast_grep_search = tool({
   },
   execute: async (args, context) => {
     try {
+      validatePatternForCli(args.pattern, args.lang as CliLanguage)
+
       const matches = await runSg({
         pattern: args.pattern,
         lang: args.lang as CliLanguage,