pikiclaw 0.3.39 → 0.3.41

package/dist/bot/bot.js

@@ -7,7 +7,8 @@ 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, 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 { compactForHandover, describeHandoverRef } from '../agent/handover.js';
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
 import { getDriver, hasDriver, allDriverIds } from '../agent/driver.js';
 import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
@@ -44,37 +45,8 @@ export function thinkLabel(agent) {
     }
 }
 // ---------------------------------------------------------------------------
-// Cross-agent context migration
+// Prompt assembly helpers
 // ---------------------------------------------------------------------------
-const CROSS_AGENT_CONTEXT_MAX_CHARS = 4000;
-const CROSS_AGENT_MSG_MAX_CHARS = 600;
-/**
- * Format conversation messages from a previous agent session into a compact
- * context block that can be prepended to the first prompt of the new session.
- */
-function formatCrossAgentContext(agent, messages) {
-    const lines = [];
-    let totalLen = 0;
-    for (const msg of messages) {
-        const label = msg.role === 'user' ? 'User' : 'Assistant';
-        let text = msg.text.trim();
-        if (text.length > CROSS_AGENT_MSG_MAX_CHARS) {
-            text = text.slice(0, CROSS_AGENT_MSG_MAX_CHARS) + '…';
-        }
-        const line = `${label}: ${text}`;
-        if (totalLen + line.length > CROSS_AGENT_CONTEXT_MAX_CHARS)
-            break;
-        lines.push(line);
-        totalLen += line.length;
-    }
-    if (!lines.length)
-        return '';
-    return [
-        `<previous-conversation agent="${agent}">`,
-        ...lines,
-        '</previous-conversation>',
-    ].join('\n');
-}
 function appendExtraPrompt(base, extra) {
     const lhs = String(base || '').trim();
     const rhs = String(extra || '').trim();
@@ -142,6 +114,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
 // ---------------------------------------------------------------------------
@@ -518,6 +502,7 @@ export class Bot {
             codexCumulative: session.codexCumulative,
             modelId: session.modelId ?? null,
             thinkingEffort: session.thinkingEffort ?? null,
+            handoverFrom: session.handoverFrom ?? null,
         });
     }
     upsertSessionRuntime(session) {
@@ -544,6 +529,10 @@ export class Bot {
                 existing.modelId = session.modelId ?? null;
             if (session.thinkingEffort !== undefined)
                 existing.thinkingEffort = session.thinkingEffort ?? null;
+            // handoverFrom is one-shot: only set if not already set (the first staging wins).
+            if (session.handoverFrom !== undefined && !existing.handoverFrom) {
+                existing.handoverFrom = session.handoverFrom;
+            }
             return existing;
         }
         const runtime = {
@@ -557,6 +546,7 @@ export class Bot {
             modelId: session.modelId ?? null,
             thinkingEffort: session.thinkingEffort ?? null,
             runningTaskIds: new Set(),
+            handoverFrom: session.handoverFrom ?? null,
         };
         this.sessionStates.set(requestedKey, runtime);
         return runtime;
@@ -762,12 +752,19 @@ export class Bot {
         const selected = this.getSelectedSession(cs);
         if (selected)
             return selected;
+        // Auto-resume an existing same-thread session of this agent (back-and-forth
+        // toggling). The handover queued on `cs.pendingHandoverFrom` is intentionally
+        // dropped here — the resumed session already has its own history; replaying
+        // an external handover on top would just be duplicate context.
         const resumed = this.findThreadSessionRuntime(chatId, cs.activeThreadId, cs.agent);
         if (resumed) {
+            cs.pendingHandoverFrom = null;
             this.applySessionSelection(cs, resumed);
             return resumed;
         }
         const wd = this.chatWorkdir(chatId);
+        const handoverFrom = cs.pendingHandoverFrom ?? null;
+        cs.pendingHandoverFrom = null;
         const staged = stageSessionFiles({
             agent: cs.agent,
             workdir: wd,
@@ -775,6 +772,7 @@ export class Bot {
             sessionId: null,
             title: title || 'New session',
             threadId: cs.activeThreadId ?? null,
+            handoverFrom,
         });
         const runtime = this.upsertSessionRuntime({
             agent: cs.agent,
@@ -783,6 +781,7 @@ export class Bot {
             threadId: staged.threadId,
             modelId: this.modelForAgent(cs.agent),
             thinkingEffort: this.effortForAgent(cs.agent),
+            handoverFrom: staged.handoverFrom,
         });
         this.applySessionSelection(cs, runtime);
         return runtime;
@@ -1261,6 +1260,7 @@ export class Bot {
             // Only override when explicitly provided — undefined skips the overwrite in upsertSessionRuntime
             ...(opts.modelId !== undefined ? { modelId: opts.modelId } : {}),
             ...(opts.thinkingEffort !== undefined ? { thinkingEffort: opts.thinkingEffort } : {}),
+            ...(opts.handoverFrom !== undefined ? { handoverFrom: opts.handoverFrom } : {}),
         });
         const taskId = `ext-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
         const prompt = opts.prompt.trim();
@@ -1333,14 +1333,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 +1420,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 +1454,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 +1514,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 +1532,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 +1553,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 +1562,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) {
@@ -1577,15 +1640,32 @@ export class Bot {
         const cs = this.chat(chatId);
         if (cs.agent === agent)
             return false;
+        // Capture the live session of the *outgoing* agent so the next message to
+        // the new agent can replay it as a handover. We capture BEFORE flipping
+        // cs.agent so the ref is honest about which agent it points at.
+        const prevAgent = cs.agent;
+        const prevSessionId = cs.sessionId && !isPendingSessionId(cs.sessionId) ? cs.sessionId : null;
         cs.agent = agent;
+        // Pre-existing session of the new agent in this thread — back-and-forth
+        // toggling resumes it without handover. The user's intent is "continue what
+        // I had", not "translate cross-agent".
         const resumed = this.findThreadSessionRuntime(chatId, cs.activeThreadId, agent);
         if (resumed) {
+            cs.pendingHandoverFrom = null;
             this.applySessionSelection(cs, resumed);
             this.log(`agent switched to ${agent} chat=${chatId} resumed=${resumed.sessionId}`);
             return true;
         }
+        // No existing session of the new agent → next message will stage a fresh
+        // one. Park the outgoing session as the handover source. If the outgoing
+        // agent had no live session (e.g. the user is rapidly toggling agents
+        // before sending anything), keep any already-pending handover so the
+        // original source isn't lost across intermediate switches.
+        if (prevSessionId) {
+            cs.pendingHandoverFrom = { agent: prevAgent, sessionId: prevSessionId };
+        }
         this.resetChatConversation(cs, { clearThread: false });
-        this.log(`agent switched to ${agent} chat=${chatId}`);
+        this.log(`agent switched to ${agent} chat=${chatId} handoverFrom=${describeHandoverRef(cs.pendingHandoverFrom)}`);
         return true;
     }
     switchModelForChat(chatId, modelId) {
@@ -1929,34 +2009,34 @@ export class Bot {
         this.debug(`[runStream] agent=${cs.agent} session=${cs.sessionId || '(new)'} workdir=${sessionWorkdir} timeout=${this.runTimeout}s attachments=${attachments.length}`);
         this.debug(`[runStream] ${cs.agent} config: model=${resolvedModel} extraArgs=[${extraArgs.join(' ')}]`);
         const isFirstTurnOfSession = !cs.sessionId || isPendingSessionId(cs.sessionId);
-        // ── Cross-agent context migration ──
-        // When starting a new session that shares a threadId with a session from a
-        // different agent, fetch the previous conversation tail and prepend it so the
-        // new agent has continuity.
-        if (isFirstTurnOfSession) {
-            const threadId = 'threadId' in cs ? cs.threadId : ('activeThreadId' in cs ? cs.activeThreadId : null);
-            if (threadId) {
-                const prevSession = findThreadSessionAcrossAgents(sessionWorkdir, threadId, cs.agent);
-                if (prevSession?.sessionId && prevSession.agent) {
-                    try {
-                        const tail = await querySessionTail({
-                            agent: prevSession.agent,
-                            sessionId: prevSession.sessionId,
-                            workdir: sessionWorkdir,
-                            limit: 20,
-                        });
-                        if (tail.ok && tail.messages.length) {
-                            const contextBlock = formatCrossAgentContext(prevSession.agent, tail.messages);
-                            if (contextBlock) {
-                                prompt = contextBlock + '\n\n' + prompt;
-                                this.debug(`[runStream] injected cross-agent context from ${prevSession.agent}:${prevSession.sessionId} (${tail.messages.length} msgs)`);
-                            }
-                        }
-                    }
-                    catch (e) {
-                        this.debug(`[runStream] cross-agent context fetch failed: ${e?.message || e}`);
-                    }
+        // ── Cross-agent handover ──
+        // First turn of a session created by an agent switch: read the prior agent's
+        // session, compact it, and prepend the seed to this turn's prompt. After this
+        // single injection the new agent owns the canonical session file and `--resume`
+        // takes over. See agent/handover.ts.
+        const handoverFrom = ('handoverFrom' in cs && cs.handoverFrom) ? cs.handoverFrom : null;
+        if (isFirstTurnOfSession && handoverFrom) {
+            try {
+                const result = await compactForHandover({
+                    fromAgent: handoverFrom.agent,
+                    fromSessionId: handoverFrom.sessionId,
+                    workdir: sessionWorkdir,
+                    toAgent: cs.agent,
+                    toModel: resolvedModel,
+                });
+                if (result.ok && result.seed) {
+                    prompt = result.seed + '\n\n' + prompt;
+                    this.debug(`[runStream] handover ${describeHandoverRef(handoverFrom)} → ${cs.agent} `
+                        + `mode=${result.mode} msgs=${result.messagesIncluded}/${result.messagesTotal} `
+                        + `turnsTotal=${result.turnsTotal} chars=${result.charsIncluded}/${result.budgetChars}`);
                 }
+                else {
+                    this.warn(`[runStream] handover ${describeHandoverRef(handoverFrom)} → ${cs.agent} `
+                        + `failed (${result.error || 'unknown'}); proceeding without prior context`);
+                }
+            }
+            catch (e) {
+                this.warn(`[runStream] handover threw: ${e?.message || e}; proceeding without prior context`);
             }
         }
         const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(mcpSendFile ? buildMcpDeliveryPrompt() : '', onInteraction && cs.agent === 'claude' ? buildClaudeAskUserPrompt() : ''), buildBrowserAutomationPrompt(browserEnabled));

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

@@ -122,6 +122,8 @@ async function parseSessionSendRequest(c) {
             model: readStringField(form.get('model')),
             effort: readStringField(form.get('effort')).toLowerCase(),
             attachments: uploads.attachments,
+            previousAgent: readStringField(form.get('previousAgent')),
+            previousSessionId: readStringField(form.get('previousSessionId')),
             cleanup: uploads.cleanup,
         };
     }
@@ -134,6 +136,8 @@ async function parseSessionSendRequest(c) {
         model: readStringField(body?.model),
         effort: readStringField(body?.effort).toLowerCase(),
         attachments: [],
+        previousAgent: readStringField(body?.previousAgent),
+        previousSessionId: readStringField(body?.previousSessionId),
         cleanup: async () => { },
     };
 }
@@ -436,8 +440,8 @@ 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 { workdir, agent, sessionId, prompt, model, effort, attachments, previousAgent, previousSessionId, cleanup } = await parseSessionSendRequest(c);
+        const queued = await queueDashboardSessionTask({
             workdir,
             agent,
             sessionId,
@@ -445,6 +449,8 @@ app.post('/api/session-hub/session/send', async (c) => {
             model,
             effort,
             attachments,
+            previousAgent: previousAgent || null,
+            previousSessionId: previousSessionId || null,
         });
         await cleanup();
         if (!queued.ok) {

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, findPikiclawSession, 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,29 @@ 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) {
+/**
+ * Resolve a `handoverFrom` ref from the request's `previousAgent` /
+ * `previousSessionId` fields, validating that it points to a real, non-self,
+ * different-agent session managed by pikiclaw. Returns null when the inputs
+ * are absent or invalid — handover is best-effort and silent-skip on bad data.
+ */
+function resolveHandoverFrom(request, targetAgent) {
+    const prevAgent = typeof request.previousAgent === 'string' ? request.previousAgent.trim() : '';
+    const prevSessionId = typeof request.previousSessionId === 'string' ? request.previousSessionId.trim() : '';
+    if (!prevAgent || !prevSessionId)
+        return null;
+    if (!KNOWN_AGENTS.has(prevAgent))
+        return null;
+    if (prevAgent === targetAgent)
+        return null; // same-agent continuation goes via --resume, not handover
+    if (isPendingSessionId(prevSessionId))
+        return null; // no native history yet → nothing to compact
+    const record = findPikiclawSession(request.workdir, prevAgent, prevSessionId);
+    if (!record)
+        return null;
+    return { agent: prevAgent, sessionId: prevSessionId };
+}
+export async function queueDashboardSessionTask(request) {
     const bot = runtime.getBotRef();
     if (!bot)
         return { ok: false, error: 'Bot is not running' };
@@ -48,6 +98,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;
@@ -57,6 +115,11 @@ export function queueDashboardSessionTask(request) {
     }
     let sessionId = request.sessionId;
     let attachments = request.attachments || [];
+    // Resolve handover source. Only meaningful when we're about to stage a fresh
+    // session (sessionId blank or pending). For an existing session we never
+    // replay handover — that session's own --resume history is canonical.
+    const isFreshSession = !sessionId || isPendingSessionId(sessionId);
+    const handoverFrom = isFreshSession ? resolveHandoverFrom(request, resolvedAgent) : null;
     // Stage files into the session workspace so temp uploads survive cleanup.
     // Also creates a new pending session when no sessionId is provided.
     if (!sessionId || attachments.length) {
@@ -67,6 +130,7 @@ export function queueDashboardSessionTask(request) {
             sessionId: sessionId || null,
             title: request.prompt || 'New session',
             threadId: null,
+            handoverFrom,
         });
         if (!sessionId)
             sessionId = staged.sessionId;
@@ -82,8 +146,46 @@ export function queueDashboardSessionTask(request) {
         attachments,
         ...(modelId ? { modelId } : {}),
         ...(thinkingEffort ? { thinkingEffort } : {}),
+        ...(handoverFrom ? { handoverFrom } : {}),
     });
 }
+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.41",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {