bluekiwi 0.3.13 → 0.3.14

package/dist/assets/index.js

@@ -5,6 +5,7 @@ const here = dirname(fileURLToPath(import.meta.url));
 const SKILLS_ROOT = join(here, "skills");
 export const BUNDLED_SKILLS = [
     "bk-start",
+    "bk-next",
     "bk-status",
     "bk-rewind",
     "bk-approve",
@@ -16,6 +17,7 @@ export const BUNDLED_SKILLS = [
     "bk-scan",
     "bk-share",
     "bk-version",
+    "bk-help",
 ].map((name) => ({
     name,
     content: readFileSync(join(SKILLS_ROOT, name, "SKILL.md"), "utf8"),

package/dist/assets/skills/bk-help/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: bk-help
+description: BlueKiwi help skill. Shows a formatted list of all available bk-* commands with descriptions and usage. Use when the user says "/bk-help", "bk help", "what bk commands are there", or asks about BlueKiwi commands.
+user_invocable: true
+---
+
+# BlueKiwi Help
+
+Output the following help text **exactly as formatted** (use markdown code-free output — render it as readable text, not a code block).
+
+---
+
+## BlueKiwi 명령어 도움말
+
+### 실행
+
+| 명령어                           | 설명                                                |
+| -------------------------------- | --------------------------------------------------- |
+| `/bk-start`                      | 워크플로 선택 후 즉시 실행. 미완료 태스크 복구 포함 |
+| `/bk-start <이름>`               | 이름으로 워크플로 매칭 후 바로 실행                 |
+| `/bk-start <ID>`                 | 워크플로 ID로 바로 실행 (숫자)                      |
+| `/bk-start #<태스크ID>`          | 특정 태스크 직접 재개                               |
+| `/bk-start <이름> :: <프롬프트>` | 워크플로 지정 + 초기 컨텍스트 전달                  |
+| `/bk-next`                       | 실행 중인 태스크를 찾아 현재 스텝부터 재개          |
+| `/bk-approve`                    | 대기 중인 HITL 승인 처리                            |
+| `/bk-rewind`                     | 이전 스텝으로 되돌리기                              |
+
+### 설계 / 관리
+
+| 명령어            | 설명                                       |
+| ----------------- | ------------------------------------------ |
+| `/bk-design`      | 자연어 목표로 새 워크플로 설계 및 등록     |
+| `/bk-improve`     | 기존 워크플로 분석 후 개선 버전 생성       |
+| `/bk-version`     | 버전 목록 조회, 활성화/비활성화, 버전 비교 |
+| `/bk-instruction` | 에이전트 인스트럭션 템플릿 생성·수정·삭제  |
+| `/bk-credential`  | 외부 서비스 API 키 등록·수정·삭제          |
+
+### 조회 / 공유
+
+| 명령어       | 설명                               |
+| ------------ | ---------------------------------- |
+| `/bk-status` | 실행 중·완료된 태스크 현황 조회    |
+| `/bk-report` | 태스크 결과 구조화 리포트 생성     |
+| `/bk-share`  | 워크플로·폴더를 그룹에 공유        |
+| `/bk-scan`   | 로컬 저장소 보안·컴플라이언스 스캔 |
+
+---
+
+**팁:**
+
+- `/bk-start`는 `/bk-run`의 상위 호환입니다 — 두 명령어 모두 동작합니다.
+- 태스크 재개가 필요하면 `/bk-start` (인자 없음) 또는 `/bk-start #<태스크ID>`를 사용하세요.
+- 도움말은 언제든 `/bk-help`로 다시 볼 수 있습니다.

package/dist/assets/skills/bk-next/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: bk-next
+description: BlueKiwi resume skill. Finds the active running task and resumes execution from the current step. Use when the user says "/bk-next", "next step", "next", "continue", "proceed", "이어서", "계속", or wants to resume a running BlueKiwi task from where it left off.
+user_invocable: true
+---
+
+# BlueKiwi Next Step
+
+Find the active task and resume execution from the current step. Works even in a fresh session with no prior context.
+
+## Core Principles
+
+- **Instructions are internal agent directives. Never expose raw instruction text to the user.**
+- Show only execution results (analysis, questions, suggestions) to the user.
+- Never use system terms like "node", "node_type" with the user.
+
+## Natural Language Triggers
+
+If the user says "proceed", "next", "continue", "let's go", "OK", "go ahead", "이어서", "계속" — treat it the same as `/bk-next`.
+
+## Step 0 — Find the Active Task
+
+<HARD-RULE>
+Always resolve the task to resume before doing anything else.
+
+1. Call `list_tasks(status=running)`.
+2. If **exactly one** running task exists → use it directly.
+3. If **multiple** running tasks exist → ask via AskUserQuestion:
+   - header: "태스크 선택"
+   - preview: list of tasks formatted as `"Task #{id} — {workflow_name} (Step {current_step}/{total_steps})"`
+   - options: up to 4 task entries (most recent first)
+4. If **no running tasks** → call `list_tasks(status=timed_out)` and check for timed-out tasks.
+   - If found → ask: "이어서 진행할 태스크가 없습니다. 타임아웃된 태스크를 재개할까요?" (options: 가장 최근 재개 / 취소)
+   - If none → tell the user "실행 중인 태스크가 없습니다. `/bk-start`로 새 워크플로를 시작하세요."
+
+Once task_id is resolved, call `advance(task_id, peek=true)` to load the current step without advancing.
+</HARD-RULE>
+
+## Session Restore (Context Injection)
+
+The `advance` response includes `task_context`. Use it to resume seamlessly in a new session.
+
+1. `task_context.running_context` — Accumulated decisions and project state. Read and internalize it.
+2. `task_context.completed_steps` — Summary of completed steps. Understand where we are.
+3. `task_context.artifacts` — List of available artifacts. Use the Read tool on `file_path` entries when needed.
+4. `task_context.last_session` — Last execution session info. Note if a different session/user progressed it.
+
+When resuming in a new session (no prior conversation context), use `task_context` to reconstruct the situation before proceeding.
+
+## execute_step Required Parameters
+
+<HARD-RULE>
+Always populate these parameters when calling execute_step:
+- `context_snapshot`: JSON string. Store decisions made, key findings, and hints for the next step.
+  Example: `{"decisions":[{"question":"tech stack","chosen":"Next.js","reason":"team experience"}],"key_findings":["RLS required"],"next_step_hint":"write implementation plan"}`
+- `session_id`: Current session ID (omit if unknown)
+- `agent_id`: Agent identifier (e.g., "claude-code")
+- `model_id`: Current LLM model ID (e.g., "claude-opus-4-6", "gpt-5.2"). Check system prompt.
+- `user_name`: User name (omit if unknown)
+
+If files were created or modified, record in the `artifacts` array:
+
+- File created: `{artifact_type: "file", title: "Design Doc", file_path: "docs/specs/design.md"}`
+- Git commit: `{artifact_type: "git_commit", title: "Phase 1 Implementation", git_ref: "<hash>"}`
+- URL: `{artifact_type: "url", title: "PR", url: "https://..."}`
+  </HARD-RULE>
+
+## Credential Handling (API Service Nodes)
+
+If the `advance` response includes a `credentials` field, the node requires external API integration.
+
+<HARD-RULE>
+Use key-value pairs from `credentials.secrets` to make API calls.
+Example: `credentials.secrets.ACCESS_TOKEN` → `curl -H "Authorization: Bearer $TOKEN"`
+Never include raw secret values (tokens, keys) in `execute_step` output.
+Record only results (URL, status code, response summary).
+</HARD-RULE>
+
+## Execution Loop
+
+```
+LOOP:
+  1. If the current step is pending → extract response from conversation, save with execute_step
+     → Check execute_step response for next_action field (see HITL section below)
+  2. Call advance(peek=false) to fetch the next step
+  3. If finished → call complete_task, then end
+  4. Execute the next step (see step-type handling below)
+  5. Check auto_advance:
+     - true  → show brief inline result, then go back to step 2
+     - false → HITL pause (see below)
+```
+
+<HARD-RULE>
+After executing an auto_advance=true step, always proceed to the next step automatically.
+Do not show "type /bk-next to continue" hint.
+Show a brief one-line update: "✅ [{title}] done → continuing to next step..."
+Repeat the loop until reaching an auto_advance=false step.
+</HARD-RULE>
+
+## HITL Pause (auto_advance=false steps)
+
+<HARD-RULE>
+When execute_step returns `next_action: "wait_for_human_approval"`:
+
+1. Call `request_approval` with a brief message summarizing what was done.
+2. Show the user:
+   ```
+   ⏸ Step [{title}] complete — waiting for approval before proceeding.
+   A notification has been sent. Use /bk-approve when ready.
+   ```
+3. STOP. Do NOT call `advance`. Do NOT proceed to the next step.
+
+The server will reject `advance` with 403 until a human approves via /bk-approve.
+</HARD-RULE>
+
+## Step-Type Handling
+
+### action step
+
+1. Read the instruction and execute it. Reference task context.
+2. **Use heartbeat actively**: For tasks taking 30+ seconds, send heartbeat regularly.
+   Example: "Analyzing architecture section...", "Designing API endpoints...", "Writing design doc line 119..."
+3. Show the result to the user.
+4. Save with `execute_step`.
+
+### gate step
+
+1. Check `get_web_response` for a web response first.
+2. If none, ask naturally via `AskUserQuestion`.
+3. **Partial edit option**: For approve/modify questions, offer 3 options: "Approve (Recommended)" / "Partial edit" / "Full rewrite".
+4. Save the response with `execute_step`.
+
+### loop step
+
+1. Execute the instruction.
+2. **Confirm before stopping**: When the stop condition is met, do not auto-stop — ask via AskUserQuestion:
+   - "Enough information collected. Do you have anything else to add?"
+   - "That's enough (Recommended)" / "I have more to add"
+3. **Call execute_step once per loop iteration.** Do not merge multiple answers into one. Each iteration is a separate log entry.
+4. Pass `loop_continue` true/false to execute_step.
+
+## Progress Display
+
+Show progress at the start of each step as a single line:
+
+```
+✅1 → ✅2 → ✅3 → **4** → 5 → 6 → 7 → 8 → 9 → 10 → 11
+```
+
+## When Pausing (auto_advance=false only)
+
+- **HITL approval required** (execute_step returned `next_action: "wait_for_human_approval"`):
+  Call `request_approval`, show waiting message, stop. Resume only after `/bk-approve`.
+- **Gate step**: Wait for user response via AskUserQuestion.
+- **Other action step pausing without HITL**: "Type `/bk-next` to proceed."
+
+## Completion Message
+
+<HARD-RULE>
+When the workflow finishes, call `complete_task` with a non-empty `summary`.
+The summary must include decisions made, artifact paths, and suggested next actions, formatted in Markdown.
+</HARD-RULE>
+
+```
+complete_task(task_id=N, status="completed", summary="## Decisions\n- Goal: ...\n- Approach: ...\n\n## Artifacts\n- Design doc: `docs/specs/...`\n\n## Next Steps\nStart implementation from Phase 1.")
+```
+
+Show completion message to user:
+
+```
+🎉 Workflow complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## Summary
+[key decisions table]
+
+## Artifacts
+- 📄 Design doc: `docs/specs/YYYY-MM-DD-xxx-design.md`
+
+## Next Steps
+Start implementation from Phase 1.
+━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## output Format
+
+<HARD-RULE>
+All output must be at least 200 characters. Do not send one-line summaries only.
+Always use ## heading structure.
+Write in past-tense declarative form ("I analyzed...", "I generated...").
+Include absolute paths for any files created.
+</HARD-RULE>
+
+action:
+
+```markdown
+## Actions Taken
+
+Analyzed the project context.
+
+## Results
+
+- **Project name**: recipe-sharing-app
+- **Current state**: Initial stage (no code yet)
+- **Tech stack**: TBD
+- **Key findings**: ...
+
+## Artifacts
+
+Saved design doc to `/tmp/or-test-verify/docs/specs/2026-04-08-recipe-design.md`.
+```
+
+gate:
+
+```markdown
+## Question
+
+What is the core problem this project management tool aims to solve?
+
+## Options
+
+1. Personal task management (Recommended)
+2. Team collaboration
+3. Educational use
+
+## Response
+
+Selected "Personal task management" — proceeding as a personal productivity task tracker.
+```
+
+## Comment Check
+
+If comments are present, notify the user before executing and ask how to handle them via AskUserQuestion.
+
+## Failure Handling
+
+Ask via AskUserQuestion: Skip / Retry / Previous step / Abort.

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import prompts from "prompts";
 import pc from "picocolors";
 import { BlueKiwiClient } from "../api-client.js";
 import { BUNDLED_MCP_PATH, BUNDLED_SKILLS } from "../assets/index.js";
-import { saveConfig } from "../config.js";
+import { loadConfig, saveConfig } from "../config.js";
 import { detectInstalledAdapters, getAllAdapters } from "../runtimes/detect.js";
 function normalizeEnvValue(value) {
     const trimmed = value?.trim();
@@ -30,8 +30,15 @@ function uniquePreserveOrder(values) {
     }
     return unique;
 }
+function maskApiKey(key) {
+    if (key.length <= 8)
+        return key;
+    return key.slice(0, 8) + "***";
+}
 export async function initCommand(options = {}) {
     const isNonInteractive = options.yes === true || process.stdin.isTTY !== true;
+    // Load existing config for pre-filling prompts
+    const existingCfg = loadConfig();
     let server = normalizeEnvValue(options.server) ??
         normalizeEnvValue(process.env.BLUEKIWI_SERVER);
     let apiKey = normalizeEnvValue(options.apiKey) ??
@@ -43,18 +50,37 @@ export async function initCommand(options = {}) {
                 type: "text",
                 name: "server",
                 message: "BlueKiwi server URL",
+                initial: existingCfg?.server_url,
             });
         }
         if (apiKey === undefined) {
+            const maskedKey = existingCfg?.api_key
+                ? maskApiKey(existingCfg.api_key)
+                : undefined;
             questions.push({
-                type: "password",
+                type: "text",
                 name: "apiKey",
-                message: "API key (bk_...)",
+                message: maskedKey
+                    ? `API key (press Enter to keep ${maskedKey})`
+                    : "API key (bk_...)",
+                initial: maskedKey,
             });
         }
         const answers = await prompts(questions);
         server ??= answers.server;
-        apiKey ??= answers.apiKey;
+        // If user kept the masked key (just pressed Enter), restore original
+        if (apiKey === undefined) {
+            const entered = answers.apiKey;
+            const maskedKey = existingCfg?.api_key
+                ? maskApiKey(existingCfg.api_key)
+                : undefined;
+            if (entered && maskedKey && entered === maskedKey) {
+                apiKey = existingCfg.api_key;
+            }
+            else {
+                apiKey = entered;
+            }
+        }
     }
     if (server === undefined || apiKey === undefined) {
         if (isNonInteractive) {

package/dist/commands/upgrade.js

@@ -13,10 +13,12 @@ export async function upgradeCommand() {
         console.log(pc.yellow("No config found. Run `bluekiwi accept` or `bluekiwi init` next."));
         return;
     }
+    const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
     for (const adapter of getAllAdapters()) {
         if (!cfg.runtimes.includes(adapter.name))
             continue;
         adapter.installSkills(BUNDLED_SKILLS);
+        adapter.pruneSkills(bundledNames);
         adapter.installMcp({
             command: "node",
             args: [BUNDLED_MCP_PATH],

package/dist/runtimes/claude-code.js

@@ -25,6 +25,15 @@ export class ClaudeCodeAdapter {
             writeFileSync(join(dir, "SKILL.md"), skill.content);
         }
     }
+    pruneSkills(keep) {
+        if (!existsSync(SKILLS_DIR))
+            return;
+        for (const entry of readdirSync(SKILLS_DIR)) {
+            if (entry.startsWith("bk-") && !keep.has(entry)) {
+                rmSync(join(SKILLS_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
     installMcp(config) {
         let existing = {};
         if (existsSync(MCP_CONFIG)) {

package/dist/runtimes/codex.js

@@ -24,6 +24,15 @@ export class CodexAdapter {
             writeFileSync(join(dir, "SKILL.md"), skill.content);
         }
     }
+    pruneSkills(keep) {
+        if (!existsSync(SKILLS_DIR))
+            return;
+        for (const entry of readdirSync(SKILLS_DIR)) {
+            if (entry.startsWith("bk-") && !keep.has(entry)) {
+                rmSync(join(SKILLS_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
     installMcp(config) {
         mkdirSync(BASE, { recursive: true });
         const envLines = Object.entries(config.env)

package/dist/runtimes/gemini-cli.js

@@ -24,6 +24,15 @@ export class GeminiCliAdapter {
             writeFileSync(join(dir, "SKILL.md"), skill.content);
         }
     }
+    pruneSkills(keep) {
+        if (!existsSync(SKILLS_DIR))
+            return;
+        for (const entry of readdirSync(SKILLS_DIR)) {
+            if (entry.startsWith("bk-") && !keep.has(entry)) {
+                rmSync(join(SKILLS_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
     installMcp(config) {
         mkdirSync(BASE, { recursive: true });
         let existing = {};

package/dist/runtimes/openclaw.js

@@ -24,6 +24,15 @@ export class OpenClawAdapter {
             writeFileSync(join(dir, "SKILL.md"), skill.content);
         }
     }
+    pruneSkills(keep) {
+        if (!existsSync(SKILLS_DIR))
+            return;
+        for (const entry of readdirSync(SKILLS_DIR)) {
+            if (entry.startsWith("bk-") && !keep.has(entry)) {
+                rmSync(join(SKILLS_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
     installMcp(config) {
         mkdirSync(BASE, { recursive: true });
         let existing = {};

package/dist/runtimes/opencode.js

@@ -24,6 +24,15 @@ export class OpenCodeAdapter {
             writeFileSync(join(dir, "SKILL.md"), skill.content);
         }
     }
+    pruneSkills(keep) {
+        if (!existsSync(SKILLS_DIR))
+            return;
+        for (const entry of readdirSync(SKILLS_DIR)) {
+            if (entry.startsWith("bk-") && !keep.has(entry)) {
+                rmSync(join(SKILLS_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
     installMcp(config) {
         mkdirSync(BASE, { recursive: true });
         let existing = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluekiwi",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "BlueKiwi CLI — install MCP client and skills into your agent runtime",
   "license": "MIT",
   "repository": {