pikiclaw 0.3.39 → 0.3.40

package/dist/agent/drivers/claude.js

@@ -1618,6 +1618,63 @@ function getClaudeUsageFromTelemetry(home, model) {
     const windows = [{ label: ageLabel, usedPercent: null, remainingPercent: null, resetAt, resetAfterSeconds, status }];
     return { ok: true, agent: 'claude', source: 'telemetry', capturedAt: chosen.capturedAt, status, windows, error: null };
 }
+function claudeSessionTranscriptPath(workdir, sessionId) {
+    const home = getHome();
+    if (!home || !workdir || !sessionId)
+        return '';
+    return path.join(home, '.claude', 'projects', encodePathAsDirName(workdir), `${sessionId}.jsonl`);
+}
+/**
+ * Scan a claude session transcript for the latest native /goal state. Returns
+ * null when no `goal_status` attachment is present.
+ */
+export function getClaudeNativeGoal(workdir, sessionId) {
+    const file = claudeSessionTranscriptPath(workdir, sessionId);
+    if (!file || !fs.existsSync(file))
+        return null;
+    // Goal status lines are tiny attachments. Walk the tail (1 MB) to find the
+    // last one — tail covers all realistic session sizes without parsing every
+    // line of a long transcript.
+    const lines = readTailLines(file, 1024 * 1024);
+    let latest = null;
+    for (const raw of lines) {
+        if (!raw || raw[0] !== '{')
+            continue;
+        // Cheap pre-filter so we only JSON.parse the relevant subset.
+        if (!raw.includes('"goal_status"'))
+            continue;
+        try {
+            const ev = JSON.parse(raw);
+            const att = ev?.attachment;
+            if (!att || att.type !== 'goal_status')
+                continue;
+            const condition = typeof att.condition === 'string' ? att.condition : '';
+            const met = !!att.met;
+            const ts = typeof ev.timestamp === 'string' ? Date.parse(ev.timestamp) : NaN;
+            latest = {
+                condition,
+                met,
+                status: met || !condition ? 'complete' : 'active',
+                updatedAtMs: Number.isFinite(ts) ? ts : Date.now(),
+            };
+        }
+        catch { /* skip */ }
+    }
+    // After auto-clear (met:true) claude still leaves the goal_status line in the
+    // transcript; pikiclaw treats "no active goal" as null so the bridge mirrors
+    // the codex semantics where `goal_get` returns null after a clear.
+    if (latest && latest.met)
+        return null;
+    return latest;
+}
+/** Build the user-prompt that triggers claude's native `/goal <condition>` slash command. */
+export function buildClaudeSetGoalPrompt(objective) {
+    return `/goal ${objective.trim()}`;
+}
+/** Build the user-prompt that triggers claude's native `/goal clear` slash command. */
+export function buildClaudeClearGoalPrompt() {
+    return '/goal clear';
+}
 // ---------------------------------------------------------------------------
 // Driver
 // ---------------------------------------------------------------------------

package/dist/agent/drivers/codex.js

@@ -115,7 +115,13 @@ export class CodexAppServer {
                 }
                 this.pending.clear();
             });
-            this.call('initialize', { clientInfo: { name: 'pikiclaw', version: '0.2.0' } })
+            // Declare experimentalApi so `thread/goal/*` is reachable. Codex 0.130+
+            // gates these RPCs behind that capability — without it, every goal call
+            // returns "requires experimentalApi capability".
+            this.call('initialize', {
+                clientInfo: { name: 'pikiclaw', version: '0.2.0' },
+                capabilities: { experimentalApi: true },
+            })
                 .then(resp => {
                 clearTimeout(timer);
                 if (resp.error) {

package/dist/agent/index.js

@@ -32,6 +32,8 @@ export { getProjectSkillPaths, initializeProjectSkills, listSkills, getGlobalSki
 export { readGoal, writeGoal, clearGoal, setGoal, pauseGoal, resumeGoal, completeGoal, accountTurn, bumpContinuationCount, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, sessionGoalPath, DEFAULT_MAX_CONTINUATIONS, } from './goal.js';
 // ── Re-export: native codex goal bridge ──────────────────────────────────────
 export { setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, } from './drivers/codex.js';
+// ── Re-export: native claude goal bridge ─────────────────────────────────────
+export { getClaudeNativeGoal, buildClaudeSetGoalPrompt, buildClaudeClearGoalPrompt, } from './drivers/claude.js';
 // ── Re-export: MCP extensions ───────────────────────────────────────────────
 export { listAllMcpExtensions, addGlobalMcpExtension, removeGlobalMcpExtension, updateGlobalMcpExtension, addWorkspaceMcpExtension, removeWorkspaceMcpExtension, updateWorkspaceMcpExtension, loadGlobalMcpExtensions, loadWorkspaceMcpExtensions, getCatalogItems, getCatalogItem, buildInstalledConfigFromRecommended, checkMcpHealth, getCachedHealth, cacheHealth, } from './mcp/extensions.js';
 export { getRecommendedMcpServers, getRecommendedMcpServer, getRecommendedSkillRepos, searchMcpServers, searchSkills as searchSkillRepos, } from './mcp/registry.js';

package/dist/bot/bot.js

@@ -7,7 +7,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { getActiveUserConfig, loadWorkspaces, onUserConfigChange, resolveUserWorkdir, setUserWorkdir, updateUserConfig } from '../core/config/user-config.js';
-import { doStream, ensureManagedSession, findManagedThreadSession, findThreadSessionAcrossAgents, getSessionStoredConfig, getUsage, initializeProjectSkills, listAgents, resolveAgentModels, listSkills, stageSessionFiles, reconcileOrphanedRunningSessions, getAgentBoundModelId, setAgentBoundModelId, collapseSkillPrompt, readGoal, accountTurn, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, bumpContinuationCount, pauseGoal, resumeGoal, setGoal as setGoalState, clearGoal as clearGoalState, setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, isPendingSessionId, } from '../agent/index.js';
+import { doStream, ensureManagedSession, findManagedThreadSession, findThreadSessionAcrossAgents, getSessionStoredConfig, getUsage, initializeProjectSkills, listAgents, resolveAgentModels, listSkills, stageSessionFiles, reconcileOrphanedRunningSessions, getAgentBoundModelId, setAgentBoundModelId, collapseSkillPrompt, readGoal, accountTurn, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, bumpContinuationCount, pauseGoal, resumeGoal, setGoal as setGoalState, clearGoal as clearGoalState, setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, getClaudeNativeGoal, buildClaudeSetGoalPrompt, buildClaudeClearGoalPrompt, isPendingSessionId, } from '../agent/index.js';
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
 import { getDriver, hasDriver, allDriverIds } from '../agent/driver.js';
 import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
@@ -142,6 +142,18 @@ function normalizeFromCodex(goal) {
         continuationCount: null,
     };
 }
+function normalizeFromClaudeNative(goal) {
+    return {
+        source: 'claude',
+        objective: goal.condition,
+        // Native /goal exposes no pause/budget — it's either active or absent.
+        status: 'active',
+        tokenBudget: null,
+        tokensUsed: 0,
+        timeUsedSeconds: 0,
+        continuationCount: null,
+    };
+}
 // ---------------------------------------------------------------------------
 // Bot
 // ---------------------------------------------------------------------------
@@ -1333,14 +1345,14 @@ export class Bot {
      * tasks that get cancelled or errored auto-pause the goal so the loop does
      * not silently resume on the user's next message.
      *
-     * Codex sessions short-circuit: codex CLI runs its own native `/goal`
-     * lifecycle (state machine + continuation engine) inside its app-server, so
-     * pikiclaw stays out to avoid a double loop. See setSessionGoal et al — they
-     * bridge to codex's `thread/goal/*` RPC instead of writing pikiclaw's
-     * goal.json for codex sessions.
+     * Codex and Claude sessions short-circuit: each runs its own native `/goal`
+     * lifecycle (codex's app-server state machine; claude's in-process Stop
+     * hook), so pikiclaw stays out to avoid a double loop. See setSessionGoal
+     * et al — they bridge to codex's `thread/goal/*` RPC and to claude's
+     * `/goal <condition>` slash command instead of writing pikiclaw's goal.json.
      */
     maybeEnqueueGoalContinuation(session, opts, result) {
-        if (session.agent === 'codex')
+        if (session.agent === 'codex' || session.agent === 'claude')
             return;
         const sessionId = (result.sessionId || session.sessionId || '').trim();
         if (!sessionId || isPendingSessionId(sessionId))
@@ -1420,6 +1432,12 @@ export class Bot {
             const goal = await getCodexGoal(sessionId);
             return goal ? normalizeFromCodex(goal) : null;
         }
+        if (agent === 'claude') {
+            if (!sessionId || isPendingSessionId(sessionId))
+                return null;
+            const goal = getClaudeNativeGoal(workdir, sessionId);
+            return goal ? normalizeFromClaudeNative(goal) : null;
+        }
         const goal = readGoal(workdir, agent, sessionId);
         return goal ? normalizeFromPikiclaw(goal) : null;
     }
@@ -1448,6 +1466,37 @@ export class Bot {
                 throw new Error('codex did not return a goal snapshot');
             return normalizeFromCodex(goal);
         }
+        if (agent === 'claude') {
+            if (!sessionId || isPendingSessionId(sessionId)) {
+                throw new Error('claude session must exist before /goal — send a first message to create the transcript');
+            }
+            // Native /goal owns its own continuation engine (Stop hook). pikiclaw
+            // just submits the slash command as the next task; claude internally
+            // sets up the goal_status attachment, injects its meta directive, and
+            // keeps looping until the Haiku completion check returns met. Token
+            // budget is accepted in the API for shape parity with codex/portable
+            // but ignored — claude native /goal has no budget concept.
+            const objective = opts.objective.trim();
+            if (!objective)
+                throw new Error('objective must be non-empty');
+            this.submitSessionTask({
+                agent,
+                sessionId,
+                workdir,
+                prompt: buildClaudeSetGoalPrompt(objective),
+                chatId: opts.chatId,
+                modelId: opts.modelId,
+                thinkingEffort: opts.thinkingEffort,
+            });
+            // Return an optimistic snapshot — the actual goal_status attachment is
+            // written by claude during the task; readers can poll getSessionGoal.
+            return normalizeFromClaudeNative({
+                condition: objective,
+                status: 'active',
+                met: false,
+                updatedAtMs: Date.now(),
+            });
+        }
         const goal = setGoalState(workdir, agent, sessionId, {
             objective: opts.objective,
             tokenBudget: opts.tokenBudget ?? null,
@@ -1477,6 +1526,11 @@ export class Bot {
             const goal = resp.goal ?? (await getCodexGoal(sessionId));
             return goal ? normalizeFromCodex(goal) : null;
         }
+        if (agent === 'claude') {
+            // Claude's native /goal exposes no pause/resume — only set and clear.
+            // Surface a clear error so the IM layer can render a friendly message.
+            throw new Error('Claude native /goal does not support pause/resume — only `/goal clear`. Re-issue `/goal <objective>` to start fresh.');
+        }
         const goal = pauseGoal(workdir, agent, sessionId);
         return goal ? normalizeFromPikiclaw(goal) : null;
     }
@@ -1490,6 +1544,9 @@ export class Bot {
             const goal = resp.goal ?? (await getCodexGoal(sessionId));
             return goal ? normalizeFromCodex(goal) : null;
         }
+        if (agent === 'claude') {
+            throw new Error('Claude native /goal does not support pause/resume — re-issue `/goal <objective>` to start fresh.');
+        }
         const goal = resumeGoal(workdir, agent, sessionId);
         if (!goal || goal.status !== 'active')
             return goal ? normalizeFromPikiclaw(goal) : null;
@@ -1508,7 +1565,7 @@ export class Bot {
         }
         return normalizeFromPikiclaw(goal);
     }
-    async clearSessionGoal(workdir, agent, sessionId) {
+    async clearSessionGoal(workdir, agent, sessionId, opts = {}) {
         if (agent === 'codex') {
             if (!sessionId || isPendingSessionId(sessionId))
                 return;
@@ -1517,6 +1574,24 @@ export class Bot {
                 throw new Error(resp.error);
             return;
         }
+        if (agent === 'claude') {
+            if (!sessionId || isPendingSessionId(sessionId))
+                return;
+            // Read goal-status first to avoid spawning a no-op turn when nothing is set.
+            const existing = getClaudeNativeGoal(workdir, sessionId);
+            if (!existing)
+                return;
+            this.submitSessionTask({
+                agent,
+                sessionId,
+                workdir,
+                prompt: buildClaudeClearGoalPrompt(),
+                chatId: opts.chatId,
+                modelId: opts.modelId,
+                thinkingEffort: opts.thinkingEffort,
+            });
+            return;
+        }
         clearGoalState(workdir, agent, sessionId);
     }
     cancelTask(taskId) {

package/dist/bot/commands.js

@@ -72,8 +72,11 @@ export function getWorkspacesData(bot, chatId) {
  * the IM renderer to send back. Returns null when there is no active session
  * for the chat (caller renders its own "pick a session first" message).
  *
- * For codex sessions this awaits codex's native `thread/goal/*` RPC; for other
- * drivers it's effectively sync but stays async for a uniform call site.
+ * Per-agent routing:
+ *   - codex → native `thread/goal/*` RPC (state machine + budget + pause/resume)
+ *   - claude → native `/goal <condition>` slash command (Stop hook continuation,
+ *              auto-clear on completion, no budget / no pause/resume)
+ *   - others → pikiclaw's portable goal.json with continuation injection
  */
 export async function handleGoalCommand(bot, chatId, rawArgs) {
     const session = bot.selectedSession(chatId);
@@ -104,12 +107,17 @@ export async function handleGoalCommand(bot, chatId, rawArgs) {
             return `Resumed goal: ${truncate(goal.objective, 80)}`;
         }
         if (lower === 'clear' || lower === 'cancel' || lower === 'stop') {
-            await bot.clearSessionGoal(workdir, agent, sessionId);
-            return 'Cleared goal.';
+            await bot.clearSessionGoal(workdir, agent, sessionId, { chatId });
+            return agent === 'claude'
+                ? 'Submitted `/goal clear` to claude. (Native /goal auto-clears once the condition is met, so this is only needed to stop early.)'
+                : 'Cleared goal.';
         }
         const { objective, tokenBudget } = parseObjective(args);
         if (!objective)
             return 'Usage: /goal <objective>  (or pause / resume / clear)';
+        if (agent === 'claude' && tokenBudget != null) {
+            return 'Claude native /goal does not support `budget=N` — drop the budget prefix. (Use a codex session if you need a token budget.)';
+        }
         const goal = await bot.setSessionGoal(workdir, agent, sessionId, {
             objective,
             tokenBudget,
@@ -122,6 +130,12 @@ export async function handleGoalCommand(bot, chatId, rawArgs) {
                 'Send any message to trigger codex\'s native continuation loop. Each message resumes the thread and codex audits / continues until it marks the goal complete or hits the budget.',
             ].join('\n');
         }
+        if (agent === 'claude') {
+            return [
+                `Goal set (claude native): ${truncate(goal.objective, 120)}`,
+                'Claude\'s in-process Stop hook keeps working until a Haiku judge confirms the condition is met, then auto-clears. Send `/goal clear` to stop early; `/goal` to inspect.',
+            ].join('\n');
+        }
         return `Goal set${budgetLabel}: ${truncate(goal.objective, 120)}\nThe agent will keep working until it audits the objective complete${goal.tokenBudget != null ? ' or exhausts the budget' : ''}.`;
     }
     catch (e) {
@@ -131,6 +145,12 @@ export async function handleGoalCommand(bot, chatId, rawArgs) {
 function formatGoalStatusLine(goal, agent) {
     if (!goal)
         return 'No goal set for this session. Use `/goal <objective>` to set one.';
+    if (goal.source === 'claude') {
+        return [
+            `Goal: ${truncate(goal.objective, 200)}`,
+            `Status: ${goal.status}  ·  claude native (Stop hook, auto-clears on completion)`,
+        ].join('\n');
+    }
     const budget = goal.tokenBudget != null
         ? `${goal.tokensUsed}/${goal.tokenBudget} tokens`
         : `${goal.tokensUsed} tokens (no budget)`;

package/dist/dashboard/routes/sessions.js

@@ -437,7 +437,7 @@ app.get('/api/session-hub/skills', (c) => {
 app.post('/api/session-hub/session/send', async (c) => {
     try {
         const { workdir, agent, sessionId, prompt, model, effort, attachments, cleanup } = await parseSessionSendRequest(c);
-        const queued = queueDashboardSessionTask({
+        const queued = await queueDashboardSessionTask({
             workdir,
             agent,
             sessionId,

package/dist/dashboard/session-control.js

@@ -2,10 +2,38 @@
  * Public session task control surface for dashboard and API routes.
  */
 import path from 'node:path';
-import { getProjectSkillPaths, listSkills, stageSessionFiles, ensureManagedSession, getDriverCapabilities } from '../agent/index.js';
+import { getProjectSkillPaths, listSkills, stageSessionFiles, ensureManagedSession, getDriverCapabilities, isPendingSessionId } from '../agent/index.js';
 import { loadUserConfig } from '../core/config/user-config.js';
 import { runtime } from './runtime.js';
 const KNOWN_AGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
+/**
+ * Parse a `/goal[ args]` prompt typed in the dashboard chat box. Returns null
+ * when the prompt is not a goal slash command. Sub-commands mirror the IM
+ * `handleGoalCommand` semantics (set / clear / pause / resume / status).
+ *
+ * Routing /goal through the native bridge is the dashboard's analog of what
+ * channels/{telegram,feishu,weixin}/bot.ts do via `handleGoalCommand` — before
+ * this hook, dashboard /goal was matched by the legacy `goal` skill resolver
+ * and silently rewritten to "Read SKILL.md and execute", which bypassed both
+ * the claude native /goal slash command and codex's thread/goal RPC.
+ */
+function parseGoalSlash(prompt) {
+    const trimmed = prompt.trim();
+    const m = trimmed.match(/^\/goal(?:\s+([\s\S]*))?$/);
+    if (!m)
+        return null;
+    const args = (m[1] || '').trim();
+    if (!args)
+        return { action: 'status', objective: '' };
+    const lower = args.toLowerCase();
+    if (lower === 'clear' || lower === 'cancel' || lower === 'stop')
+        return { action: 'clear', objective: '' };
+    if (lower === 'pause')
+        return { action: 'pause', objective: '' };
+    if (lower === 'resume')
+        return { action: 'resume', objective: '' };
+    return { action: 'set', objective: args };
+}
 /**
  * Resolve a `/skill-name [args]` prompt into the full skill execution prompt.
  * Returns null if the prompt is not a skill invocation or the skill is not found.
@@ -33,7 +61,7 @@ function resolveSkillFromPrompt(workdir, prompt) {
     const resolvedPrompt = `${workdirHint}Read the skill definition at \`${targetPath}\` and execute the instructions defined there.${extra}`;
     return { resolvedPrompt, skillName: skill.name };
 }
-export function queueDashboardSessionTask(request) {
+export async function queueDashboardSessionTask(request) {
     const bot = runtime.getBotRef();
     if (!bot)
         return { ok: false, error: 'Bot is not running' };
@@ -48,6 +76,14 @@ export function queueDashboardSessionTask(request) {
     const thinkingEffort = resolvedAgent === 'gemini'
         ? ''
         : (typeof request.effort === 'string' ? request.effort.trim().toLowerCase() : '');
+    // /goal — route directly to the goal bridge (claude native slash, codex RPC,
+    // or portable goal.json for gemini/hermes). Must run BEFORE skill resolution
+    // so the legacy `goal` skill doesn't grab the prompt and rewrite it into a
+    // "Read SKILL.md" instruction.
+    const goalCmd = parseGoalSlash(request.prompt || '');
+    if (goalCmd && request.sessionId && !isPendingSessionId(request.sessionId)) {
+        return runDashboardGoalSlash(bot, resolvedAgent, request, goalCmd, modelId, thinkingEffort);
+    }
     // Resolve /skill-name prompts into full skill execution prompts
     let prompt = request.prompt;
     const skillResult = prompt ? resolveSkillFromPrompt(request.workdir, prompt) : null;
@@ -84,6 +120,43 @@ export function queueDashboardSessionTask(request) {
         ...(thinkingEffort ? { thinkingEffort } : {}),
     });
 }
+async function runDashboardGoalSlash(bot, agent, request, cmd, modelId, thinkingEffort) {
+    const opts = { chatId: 'dashboard', modelId: modelId || undefined, thinkingEffort: thinkingEffort || undefined };
+    const sessionKey = `${agent}:${request.sessionId}`;
+    // Synthetic task id — for set / clear / resume on agents that internally
+    // submit a follow-up task (claude native slash, portable continuation),
+    // the real task id is owned by submitSessionTask. The dashboard's SSE
+    // stream listener picks that up via session events; this id is just to
+    // give the HTTP caller a non-empty taskId field.
+    const taskId = `goal-${cmd.action}-${Date.now().toString(36)}`;
+    try {
+        if (cmd.action === 'status') {
+            const goal = await bot.getSessionGoal(request.workdir, agent, request.sessionId);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        if (cmd.action === 'clear') {
+            await bot.clearSessionGoal(request.workdir, agent, request.sessionId, opts);
+            return { ok: true, taskId, sessionKey, queued: false };
+        }
+        if (cmd.action === 'pause') {
+            const goal = await bot.pauseSessionGoal(request.workdir, agent, request.sessionId);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        if (cmd.action === 'resume') {
+            const goal = await bot.resumeSessionGoal(request.workdir, agent, request.sessionId, opts);
+            return { ok: true, taskId, sessionKey, queued: false, goal };
+        }
+        // set
+        const goal = await bot.setSessionGoal(request.workdir, agent, request.sessionId, {
+            objective: cmd.objective,
+            ...opts,
+        });
+        return { ok: true, taskId, sessionKey, queued: true, goal };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message || String(e) };
+    }
+}
 export function forkDashboardSessionTask(request) {
     const bot = runtime.getBotRef();
     if (!bot)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.3.39",
+  "version": "0.3.40",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {