@phuetz/code-buddy 1.0.0 → 1.1.0

package/dist/daemon/autonomous-loop.js

@@ -22,6 +22,7 @@
  */
 import { chooseAutonomousModel, } from '../agent/model-tier.js';
 import { beginFleetWork, isFleetSaturated } from '../fleet/fleet-load.js';
+import { DEFAULT_COLAB_GOAL_MAX_TURNS } from './colab-goal.js';
 export class FleetAutonomousLoop {
     store;
     tierConfig;
@@ -35,12 +36,14 @@ export class FleetAutonomousLoop {
      * success. Resets across process restarts — escalation is a within-run feature.
      */
     failures = new Map();
+    goalJudge;
     constructor(config) {
         this.store = config.store;
         this.tierConfig = config.tierConfig;
         this.executor = config.executor;
         this.policy = config.policy ?? {};
         this.enabled = config.enabled ?? (() => true);
+        this.goalJudge = config.goalJudge;
     }
     /** Run a single autonomous tick. Never throws — failures are logged + reported. */
     async tick() {
@@ -88,6 +91,14 @@ export class FleetAutonomousLoop {
             doneLoad();
         }
         if (result.ok) {
+            // Goal-mode gate (Hermes kanban goal-mode): a successful attempt is not
+            // enough — the judge must confirm the task's criteria are satisfied.
+            if (task.goalMode && this.goalJudge) {
+                const goalOutcome = await this.evaluateGoalModeTask(task, result, model);
+                if (goalOutcome)
+                    return goalOutcome;
+                // null → judge said done (or skipped): fall through to completion.
+            }
             this.failures.delete(task.id);
             this.store.completeTask(task.id, {
                 summary: result.summary,
@@ -118,5 +129,54 @@ export class FleetAutonomousLoop {
             ...(result.error ? { detail: result.error } : {}),
         };
     }
+    /**
+     * Goal-mode decision ladder. Returns a TickResult when the loop should NOT
+     * complete the task (judge says continue / budget exhausted), or null when
+     * the task may complete (judge done/skipped, or judge unreachable —
+     * fail-open like the interactive Ralph loop).
+     */
+    async evaluateGoalModeTask(task, result, model) {
+        let verdict;
+        try {
+            verdict = await this.goalJudge(task, result, model);
+        }
+        catch {
+            return null; // fail-open: an unusable judge never blocks completion
+        }
+        if (verdict.verdict !== 'continue')
+            return null;
+        const maxTurns = task.goalMaxTurns ?? DEFAULT_COLAB_GOAL_MAX_TURNS;
+        const turnsUsed = (task.goalTurnsUsed ?? 0) + 1;
+        if (turnsUsed >= maxTurns) {
+            // Hermes rule: block for human review instead of spinning forever.
+            const reason = `goal budget exhausted (${turnsUsed}/${maxTurns}) — judge: ${verdict.reason}`;
+            this.store.blockTask(task.id, reason);
+            this.store.appendWorklog({
+                agent: this.store.agentId,
+                taskId: task.id,
+                summary: `Goal-mode blocked after ${turnsUsed}/${maxTurns} turns: ${verdict.reason}`,
+                filesModified: result.filesModified ?? [],
+                issues: [reason],
+                nextSteps: ['human review: unblock, split, or complete the task manually'],
+            });
+            this.store.updatePresence({ status: 'idle', currentTask: null });
+            return { outcome: 'goal_blocked', taskId: task.id, taskTitle: task.title, model, detail: verdict.reason };
+        }
+        // Under budget: persist the consumed turn + reason, release the task so a
+        // later tick continues it with the continuation nudge. A judge "continue"
+        // is NOT an executor failure — the model ladder must not escalate.
+        this.store.recordGoalTurn(task.id, verdict.reason);
+        this.store.appendWorklog({
+            agent: this.store.agentId,
+            taskId: task.id,
+            summary: `Goal-mode turn ${turnsUsed}/${maxTurns} — judge: continue: ${verdict.reason}`,
+            filesModified: result.filesModified ?? [],
+            issues: [],
+            nextSteps: ['continue on a later tick with the goal continuation nudge'],
+        });
+        this.store.releaseTask(task.id);
+        this.store.updatePresence({ status: 'idle', currentTask: null });
+        return { outcome: 'goal_continue', taskId: task.id, taskTitle: task.title, model, detail: verdict.reason };
+    }
 }
 //# sourceMappingURL=autonomous-loop.js.map

package/dist/daemon/colab-goal.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Goal-mode for fleet colab tasks — port of Hermes Agent's kanban goal-mode.
+ *
+ * A task with `goalMode: true` is not completed on the worker's first
+ * successful attempt: an LLM judge checks the task's title/description (with
+ * `acceptanceCriteria` as strict numbered criteria) against the worker's
+ * output. "Continue" re-opens the task with a continuation nudge so the next
+ * tick keeps going; once `goalMaxTurns` is spent the task is BLOCKED for
+ * human review instead of spinning (Hermes' "block instead of loop" rule).
+ *
+ * The judge is fail-open (judgeGoal semantics): a broken judge yields
+ * "continue", and the turn budget is the backstop.
+ */
+import type { ColabTask } from '../fleet/colab-store.js';
+import { GoalJudgeResult } from '../goals/goal-judge.js';
+import type { AutonomousModelChoice } from '../agent/model-tier.js';
+import type { TaskExecutionResult } from './autonomous-loop.js';
+/**
+ * Conservative default for unattended subprocess loops (Hermes' kanban
+ * example uses 7; interactive /goal uses 20).
+ */
+export declare const DEFAULT_COLAB_GOAL_MAX_TURNS = 5;
+export type ColabGoalJudge = (task: ColabTask, result: TaskExecutionResult, model: AutonomousModelChoice) => Promise<GoalJudgeResult>;
+/** The goal text the judge evaluates: title + description. */
+export declare function goalTextForTask(task: Pick<ColabTask, 'title' | 'description'>): string;
+/**
+ * Continuation nudge fed to the worker on later goal-mode turns (port of
+ * Hermes' KANBAN_GOAL_CONTINUATION_TEMPLATE, adapted to the colab lifecycle:
+ * completion is decided by the loop's judge, so the worker is nudged to
+ * finish and state the outcome explicitly).
+ */
+export declare function buildColabGoalContinuationPrompt(task: ColabTask): string;
+/**
+ * Default judge: a one-shot call on the same tier model the worker ran on
+ * (local tiers stay free), overridable via `goals.judgeModel`. Task
+ * `acceptanceCriteria` become strict numbered criteria for the judge.
+ */
+export declare function createColabGoalJudge(): ColabGoalJudge;

package/dist/daemon/colab-goal.js

@@ -0,0 +1,73 @@
+/**
+ * Goal-mode for fleet colab tasks — port of Hermes Agent's kanban goal-mode.
+ *
+ * A task with `goalMode: true` is not completed on the worker's first
+ * successful attempt: an LLM judge checks the task's title/description (with
+ * `acceptanceCriteria` as strict numbered criteria) against the worker's
+ * output. "Continue" re-opens the task with a continuation nudge so the next
+ * tick keeps going; once `goalMaxTurns` is spent the task is BLOCKED for
+ * human review instead of spinning (Hermes' "block instead of loop" rule).
+ *
+ * The judge is fail-open (judgeGoal semantics): a broken judge yields
+ * "continue", and the turn budget is the backstop.
+ */
+import { CodeBuddyClient } from '../codebuddy/client.js';
+import { judgeGoal } from '../goals/goal-judge.js';
+import { resolveGoalsConfig } from '../goals/goal-manager.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Conservative default for unattended subprocess loops (Hermes' kanban
+ * example uses 7; interactive /goal uses 20).
+ */
+export const DEFAULT_COLAB_GOAL_MAX_TURNS = 5;
+/** The goal text the judge evaluates: title + description. */
+export function goalTextForTask(task) {
+    return `${task.title}\n\n${task.description ?? ''}`.trim();
+}
+/**
+ * Continuation nudge fed to the worker on later goal-mode turns (port of
+ * Hermes' KANBAN_GOAL_CONTINUATION_TEMPLATE, adapted to the colab lifecycle:
+ * completion is decided by the loop's judge, so the worker is nudged to
+ * finish and state the outcome explicitly).
+ */
+export function buildColabGoalContinuationPrompt(task) {
+    const criteria = task.acceptanceCriteria?.length
+        ? `\nAcceptance criteria (ALL must be satisfied):\n${task.acceptanceCriteria
+            .map((text, i) => `- ${i + 1}. ${text}`)
+            .join('\n')}\n`
+        : '';
+    const lastReason = task.goalLastReason ? `\nJudge's last verdict: ${task.goalLastReason}\n` : '';
+    return ('[Continuing toward this fleet task — the judge says it is not done yet]\n' +
+        `Task: ${goalTextForTask(task)}\n` +
+        criteria +
+        lastReason +
+        '\nFinish the remaining work. When everything is done, state completion ' +
+        'explicitly with evidence (file contents, command output). If you are ' +
+        'blocked, state the blocker clearly.');
+}
+/**
+ * Default judge: a one-shot call on the same tier model the worker ran on
+ * (local tiers stay free), overridable via `goals.judgeModel`. Task
+ * `acceptanceCriteria` become strict numbered criteria for the judge.
+ */
+export function createColabGoalJudge() {
+    return async (task, result, model) => {
+        try {
+            const config = resolveGoalsConfig();
+            const client = new CodeBuddyClient(process.env.GROK_API_KEY || process.env.OPENAI_API_KEY || 'local', config.judgeModel || model.model, model.baseUrl);
+            return await judgeGoal(client, {
+                goal: goalTextForTask(task),
+                lastResponse: result.output || result.summary,
+                ...(task.acceptanceCriteria?.length ? { subgoals: task.acceptanceCriteria } : {}),
+                ...(config.judgeModel ? { model: config.judgeModel } : {}),
+                timeoutMs: config.judgeTimeoutMs,
+            });
+        }
+        catch (error) {
+            // Fail-open, like judgeGoal itself: never wedge the loop on judge setup.
+            logger.debug('colab goal judge: setup failed — continue', { error: String(error) });
+            return { verdict: 'continue', reason: `judge setup error: ${String(error)}`, parseFailed: false };
+        }
+    };
+}
+//# sourceMappingURL=colab-goal.js.map

package/dist/fleet/colab-store.d.ts

@@ -48,6 +48,20 @@ export interface ColabTask {
     verifyCommand?: string;
     /** Ids of tasks that must be `completed` before this one is claimable (DAG). */
     dependsOn?: string[];
+    /**
+     * Goal-mode (Hermes kanban goal-mode parity): the worker loops on this task
+     * — after each attempt an LLM judge checks the title/description (+
+     * `acceptanceCriteria` as strict criteria); "continue" re-opens the task
+     * with a continuation nudge until `goalMaxTurns` is spent, then it is
+     * BLOCKED for human review instead of spinning.
+     */
+    goalMode?: boolean;
+    /** Per-task turn budget for goal-mode (default 5). */
+    goalMaxTurns?: number;
+    /** Goal-mode turns consumed so far (persisted — survives daemon restarts). */
+    goalTurnsUsed?: number;
+    /** Last judge reason (shown in the next continuation nudge). */
+    goalLastReason?: string;
     createdBy?: string;
     createdAt?: string;
 }
@@ -104,6 +118,8 @@ export interface AddTaskInput {
     acceptanceCriteria?: string[];
     verifyCommand?: string;
     dependsOn?: string[];
+    goalMode?: boolean;
+    goalMaxTurns?: number;
     createdBy?: string;
     id?: string;
 }
@@ -164,6 +180,11 @@ export declare class FleetColabStore {
     };
     /** Block a task with a reason (needs human/unblocking). */
     blockTask(taskId: string, reason: string): ColabTask;
+    /**
+     * Record a consumed goal-mode turn (persisted, so the budget survives daemon
+     * restarts) and remember the judge's reason for the next continuation nudge.
+     */
+    recordGoalTurn(taskId: string, reason: string): ColabTask;
     /** Release a claimed task back to the open pool. */
     releaseTask(taskId: string): ColabTask;
     addTask(input: AddTaskInput): ColabTask;

package/dist/fleet/colab-store.js

@@ -207,6 +207,20 @@ export class FleetColabStore {
         this.writeTasks(file);
         return { ...task };
     }
+    /**
+     * Record a consumed goal-mode turn (persisted, so the budget survives daemon
+     * restarts) and remember the judge's reason for the next continuation nudge.
+     */
+    recordGoalTurn(taskId, reason) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        task.goalTurnsUsed = (task.goalTurnsUsed ?? 0) + 1;
+        task.goalLastReason = reason;
+        this.writeTasks(file);
+        return { ...task };
+    }
     /** Release a claimed task back to the open pool. */
     releaseTask(taskId) {
         const file = this.readTasks();
@@ -234,6 +248,8 @@ export class FleetColabStore {
             ...(input.acceptanceCriteria ? { acceptanceCriteria: input.acceptanceCriteria } : {}),
             ...(input.verifyCommand ? { verifyCommand: input.verifyCommand } : {}),
             ...(input.dependsOn && input.dependsOn.length > 0 ? { dependsOn: [...new Set(input.dependsOn)] } : {}),
+            ...(input.goalMode ? { goalMode: true } : {}),
+            ...(input.goalMaxTurns && input.goalMaxTurns > 0 ? { goalMaxTurns: Math.trunc(input.goalMaxTurns) } : {}),
             createdBy: input.createdBy ?? this.agentId,
             createdAt: this.isoNow(),
         };

package/dist/fleet/peer-session-bridge.d.ts

@@ -42,7 +42,7 @@ export type PeerChatClientGetter = () => CodeBuddyClient | null;
  * getter; un-wire first if you need to swap).
  */
 export declare function wirePeerSessionBridge(getClient: PeerChatClientGetter): Promise<void>;
-/** Detach all three methods. Idempotent. Does NOT clear in-memory sessions. */
+/** Detach all registered methods. Idempotent. Does NOT clear in-memory sessions. */
 export declare function unwirePeerSessionBridge(): void;
 /** Whether the bridge is currently registered on the peer-rpc registry. */
 export declare function isPeerSessionBridgeWired(): boolean;

package/dist/fleet/peer-session-bridge.js

@@ -31,7 +31,10 @@
  */
 import { beginFleetWork } from './fleet-load.js';
 import { registerPeerMethod, unregisterPeerMethod } from '../server/websocket/peer-rpc.js';
-import { broadcastChatSessionEnd, broadcastChatSessionStart, broadcastChatSessionTurn, } from '../server/websocket/fleet-bridge.js';
+import { broadcastChatSessionEnd, broadcastChatSessionGoal, broadcastChatSessionStart, broadcastChatSessionTurn, } from '../server/websocket/fleet-bridge.js';
+import { judgeGoal } from '../goals/goal-judge.js';
+import { resolveGoalsConfig } from '../goals/goal-manager.js';
+import { applyJudgeOutcome, createGoalState, formatGoalStatusLine, normalizeGoalState, renderSubgoalsBlock, } from '../goals/goal-state.js';
 import { logger } from '../utils/logger.js';
 import { getPeerSessionStore, } from './peer-session-store.js';
 import { DEFAULT_DISPATCH_POLICY_PREVIEW_TOOLS, FLEET_DISPATCH_PROFILES, buildDispatchSystemPrompt, buildHermesToolsetDescriptor, getDispatchToolPolicy, isFleetDispatchProfile, mergeDispatchSystemPrompt, normalizeDispatchProfile, } from './dispatch-profile.js';
@@ -144,10 +147,60 @@ function snapshot(session) {
         toolDecisions: session.toolDecisions,
         toolset: session.toolset,
         messages: [...session.messages],
+        ...(session.goal ? { goal: { ...session.goal, subgoals: [...session.goal.subgoals] } } : {}),
         createdAt: session.createdAt,
         lastUsedAt: session.lastUsedAt,
     };
 }
+/**
+ * Post-turn goal hook shared by `continue` and `continue-stream`. Judges the
+ * assistant's response against the session goal, applies the Hermes decision
+ * ladder, and returns the report embedded in the RPC response. The judge is
+ * fail-open; this never throws. The caller persists the session afterwards.
+ */
+async function evaluateSessionGoalAfterTurn(session, assistantText) {
+    const goal = session.goal;
+    if (!goal || goal.status !== 'active')
+        return null;
+    if (!assistantText.trim())
+        return null; // empty turn: don't burn budget
+    let report;
+    try {
+        const config = resolveGoalsConfig();
+        const outcome = await judgeGoal(cachedGetter?.() ?? null, {
+            goal: goal.goal,
+            lastResponse: assistantText,
+            ...(goal.subgoals.length ? { subgoals: goal.subgoals } : {}),
+            ...(config.judgeModel ? { model: config.judgeModel } : {}),
+            timeoutMs: config.judgeTimeoutMs,
+        });
+        const decision = applyJudgeOutcome(goal, outcome);
+        report = {
+            status: decision.status,
+            verdict: decision.verdict,
+            reason: decision.reason,
+            turnsUsed: goal.turnsUsed,
+            maxTurns: goal.maxTurns,
+            message: decision.message,
+            ...(decision.continuationPrompt ? { continuationPrompt: decision.continuationPrompt } : {}),
+        };
+    }
+    catch (err) {
+        logger.warn('[peer-session-bridge] goal evaluation failed — skipping this turn', {
+            sessionId: session.sessionId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+    broadcastChatSessionGoal({
+        sessionId: session.sessionId,
+        status: report.status,
+        verdict: report.verdict,
+        turnsUsed: report.turnsUsed,
+        maxTurns: report.maxTurns,
+    });
+    return report;
+}
 /**
  * Register the `peer.chat-session.*` methods. The `getClient` closure
  * is captured and called fresh on each invocation so the caller can
@@ -174,6 +227,7 @@ export async function wirePeerSessionBridge(getClient) {
         for (const p of persisted) {
             if (now - p.lastUsedAt > idleMs)
                 continue; // double-check vs the boundary
+            const goal = p.goal ? normalizeGoalState(p.goal) : null;
             sessions.set(p.sessionId, {
                 sessionId: p.sessionId,
                 systemPrompt: p.systemPrompt,
@@ -183,6 +237,7 @@ export async function wirePeerSessionBridge(getClient) {
                 toolDecisions: p.toolDecisions,
                 toolset: p.toolset,
                 messages: [...p.messages],
+                ...(goal && goal.status !== 'cleared' ? { goal } : {}),
                 createdAt: p.createdAt,
                 lastUsedAt: p.lastUsedAt,
                 pending: Promise.resolve(),
@@ -312,6 +367,11 @@ export async function wirePeerSessionBridge(getClient) {
             const text = response?.choices?.[0]?.message?.content ?? '';
             session.messages.push({ role: 'assistant', content: text });
             session.lastUsedAt = Date.now();
+            // Goal Ralph-loop (Hermes gateway parity): judge the turn server-side,
+            // mutate the session goal state, and report the verdict to the caller
+            // (who drives the continuation). Runs BEFORE the disk flush so the
+            // snapshot below persists the updated goal counters.
+            const goalReport = await evaluateSessionGoalAfterTurn(session, text);
             // V1.2-saga — flush the new turn to disk before returning so a
             // crash mid-conversation can be replayed on next boot. Failure
             // logs but doesn't fail the turn: the caller already got an
@@ -340,6 +400,7 @@ export async function wirePeerSessionBridge(getClient) {
                 finishReason: response?.choices?.[0]?.finish_reason,
                 usage: response?.usage,
                 traceId: ctx.traceId,
+                ...(goalReport ? { goal: goalReport } : {}),
                 ...sessionPolicyMetadata(session),
             };
         };
@@ -439,6 +500,8 @@ export async function wirePeerSessionBridge(getClient) {
             }
             session.messages.push({ role: 'assistant', content: aggregate });
             session.lastUsedAt = Date.now();
+            // Goal Ralph-loop — same server-side judge as the non-streaming path.
+            const goalReport = await evaluateSessionGoalAfterTurn(session, aggregate);
             try {
                 await getPeerSessionStore().save(snapshot(session));
             }
@@ -460,6 +523,7 @@ export async function wirePeerSessionBridge(getClient) {
                 finishReason,
                 usage,
                 traceId: ctx.traceId,
+                ...(goalReport ? { goal: goalReport } : {}),
                 ...sessionPolicyMetadata(session),
             };
         };
@@ -497,6 +561,143 @@ export async function wirePeerSessionBridge(getClient) {
             traceId: ctx.traceId,
         };
     });
+    // Goal Ralph-loop controls (Hermes gateway parity). One method, action-
+    // dispatched: set | status | pause | resume | clear | subgoal-add |
+    // subgoal-list | subgoal-remove | subgoal-clear. Mirrors the /goal +
+    // /subgoal slash surface. Setting a NEW goal while one is active is
+    // rejected (Hermes mid-run rule) — pause/clear first. status/pause/
+    // resume/clear are safe mid-turn: they only touch goal metadata.
+    registerPeerMethod('peer.chat-session.goal', async (params, ctx) => {
+        const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+        const action = typeof params.action === 'string' ? params.action : 'status';
+        if (!sessionId) {
+            throw new Error('peer.chat-session.goal: sessionId is required (string)');
+        }
+        const session = sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`SESSION_NOT_FOUND: no session with id "${sessionId}"`);
+        }
+        const persist = async () => {
+            try {
+                await getPeerSessionStore().save(snapshot(session));
+            }
+            catch (err) {
+                logger.warn('[peer-session-bridge] save on goal mutation failed', {
+                    sessionId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        };
+        const emitGoal = (status) => {
+            broadcastChatSessionGoal({
+                sessionId,
+                status,
+                ...(session.goal ? { turnsUsed: session.goal.turnsUsed, maxTurns: session.goal.maxTurns } : {}),
+            });
+        };
+        const goalView = () => session.goal
+            ? {
+                goal: session.goal.goal,
+                status: session.goal.status,
+                turnsUsed: session.goal.turnsUsed,
+                maxTurns: session.goal.maxTurns,
+                subgoals: [...session.goal.subgoals],
+                ...(session.goal.lastVerdict ? { lastVerdict: session.goal.lastVerdict } : {}),
+                ...(session.goal.lastReason ? { lastReason: session.goal.lastReason } : {}),
+                ...(session.goal.pausedReason ? { pausedReason: session.goal.pausedReason } : {}),
+                statusLine: formatGoalStatusLine(session.goal),
+            }
+            : { status: 'none', statusLine: formatGoalStatusLine(null) };
+        switch (action) {
+            case 'set': {
+                const text = typeof params.goal === 'string' ? params.goal.trim() : '';
+                if (!text) {
+                    throw new Error('peer.chat-session.goal: action "set" requires goal text (string)');
+                }
+                if (session.goal?.status === 'active') {
+                    throw new Error('GOAL_ACTIVE: a goal is already active on this session. ' +
+                        'Use action "status"/"pause"/"clear" mid-run; clear it before setting a new goal.');
+                }
+                const maxTurns = typeof params.maxTurns === 'number' && params.maxTurns > 0
+                    ? Math.trunc(params.maxTurns)
+                    : resolveGoalsConfig().maxTurns;
+                session.goal = createGoalState(text, maxTurns);
+                await persist();
+                emitGoal('active');
+                return { ...goalView(), traceId: ctx.traceId };
+            }
+            case 'status':
+                return { ...goalView(), traceId: ctx.traceId };
+            case 'pause': {
+                if (!session.goal)
+                    return { ...goalView(), traceId: ctx.traceId };
+                session.goal.status = 'paused';
+                session.goal.pausedReason = 'user-paused';
+                await persist();
+                emitGoal('paused');
+                return { ...goalView(), traceId: ctx.traceId };
+            }
+            case 'resume': {
+                if (!session.goal)
+                    return { ...goalView(), traceId: ctx.traceId };
+                session.goal.status = 'active';
+                delete session.goal.pausedReason;
+                session.goal.turnsUsed = 0; // Hermes resume semantics: budget reset
+                await persist();
+                emitGoal('active');
+                return { ...goalView(), traceId: ctx.traceId };
+            }
+            case 'clear': {
+                const had = Boolean(session.goal);
+                delete session.goal;
+                await persist();
+                if (had)
+                    emitGoal('cleared');
+                return { cleared: had, ...goalView(), traceId: ctx.traceId };
+            }
+            case 'subgoal-add': {
+                const text = typeof params.text === 'string' ? params.text.trim() : '';
+                if (!text) {
+                    throw new Error('peer.chat-session.goal: action "subgoal-add" requires text (string)');
+                }
+                if (!session.goal || !['active', 'paused'].includes(session.goal.status)) {
+                    throw new Error('NO_ACTIVE_GOAL: set a goal before adding subgoals');
+                }
+                session.goal.subgoals.push(text);
+                await persist();
+                return { ...goalView(), traceId: ctx.traceId };
+            }
+            case 'subgoal-list':
+                return {
+                    ...goalView(),
+                    rendered: session.goal ? renderSubgoalsBlock(session.goal.subgoals) : '',
+                    traceId: ctx.traceId,
+                };
+            case 'subgoal-remove': {
+                const index = typeof params.index === 'number' ? Math.trunc(params.index) : NaN;
+                if (!session.goal || !['active', 'paused'].includes(session.goal.status)) {
+                    throw new Error('NO_ACTIVE_GOAL: set a goal before removing subgoals');
+                }
+                if (!Number.isInteger(index) || index < 1 || index > session.goal.subgoals.length) {
+                    throw new Error(`peer.chat-session.goal: subgoal index out of range (1..${session.goal.subgoals.length})`);
+                }
+                const [removed] = session.goal.subgoals.splice(index - 1, 1);
+                await persist();
+                return { removed, ...goalView(), traceId: ctx.traceId };
+            }
+            case 'subgoal-clear': {
+                if (!session.goal || !['active', 'paused'].includes(session.goal.status)) {
+                    throw new Error('NO_ACTIVE_GOAL: set a goal before clearing subgoals');
+                }
+                const previous = session.goal.subgoals.length;
+                session.goal.subgoals = [];
+                await persist();
+                return { cleared: previous, ...goalView(), traceId: ctx.traceId };
+            }
+            default:
+                throw new Error(`peer.chat-session.goal: unknown action "${action}" (expected set | status | pause | resume | clear | subgoal-add | subgoal-list | subgoal-remove | subgoal-clear)`);
+        }
+    });
     registerPeerMethod('peer.chat-session.end', async (params, ctx) => {
         const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
         if (!sessionId) {
@@ -520,13 +721,14 @@ export async function wirePeerSessionBridge(getClient) {
     wired = true;
     logger.debug('[peer-session-bridge] wired');
 }
-/** Detach all three methods. Idempotent. Does NOT clear in-memory sessions. */
+/** Detach all registered methods. Idempotent. Does NOT clear in-memory sessions. */
 export function unwirePeerSessionBridge() {
     if (!wired)
         return;
     unregisterPeerMethod('peer.chat-session.start');
     unregisterPeerMethod('peer.chat-session.continue');
     unregisterPeerMethod('peer.chat-session.continue-stream');
+    unregisterPeerMethod('peer.chat-session.goal');
     unregisterPeerMethod('peer.chat-session.end');
     cachedGetter = null;
     wired = false;
@@ -546,6 +748,7 @@ export function _unwireForTests() {
         unregisterPeerMethod('peer.chat-session.start');
         unregisterPeerMethod('peer.chat-session.continue');
         unregisterPeerMethod('peer.chat-session.continue-stream');
+        unregisterPeerMethod('peer.chat-session.goal');
         unregisterPeerMethod('peer.chat-session.list');
         unregisterPeerMethod('peer.chat-session.end');
     }

package/dist/fleet/peer-session-store.d.ts

@@ -27,6 +27,7 @@
  *
  * @module fleet/peer-session-store
  */
+import type { GoalState } from '../goals/goal-state.js';
 import type { FleetDispatchProfile, FleetHermesToolsetDescriptor, FleetDispatchToolDecision, FleetDispatchToolPolicy } from './dispatch-profile.js';
 export interface PersistedChatMessage {
     role: 'system' | 'user' | 'assistant';
@@ -42,6 +43,8 @@ export interface PersistedChatSession {
     toolset?: FleetHermesToolsetDescriptor;
     /** User/assistant turns (system prompt is held separately). */
     messages: PersistedChatMessage[];
+    /** Standing goal attached via `peer.chat-session.goal` (Hermes gateway parity). */
+    goal?: GoalState;
     createdAt: number;
     lastUsedAt: number;
 }

package/dist/fleet/privacy-lint.d.ts

@@ -35,3 +35,11 @@ export interface PrivacyLintResult {
  * Scan a prompt for secrets. Returns matches with previews.
  */
 export declare function scanForSecrets(prompt: string): PrivacyLintResult;
+/**
+ * Replace every secret/PII match with a `[REDACTED:<kind>]` marker.
+ *
+ * Run this on FULL text before any truncation — cutting a PEM block (or
+ * any multi-line secret) in half can hide it from the patterns above.
+ * Used by every memory-persistence path (WS3 guard-rail).
+ */
+export declare function redactSecrets(text: string): string;

package/dist/fleet/privacy-lint.js

@@ -164,4 +164,26 @@ function redactPreview(text, start, end) {
         : matched.slice(0, 4) + '…[redacted]…' + matched.slice(-4);
     return `${before}${redacted}${after}`.replace(/\s+/g, ' ').trim();
 }
+/**
+ * Replace every secret/PII match with a `[REDACTED:<kind>]` marker.
+ *
+ * Run this on FULL text before any truncation — cutting a PEM block (or
+ * any multi-line secret) in half can hide it from the patterns above.
+ * Used by every memory-persistence path (WS3 guard-rail).
+ */
+export function redactSecrets(text) {
+    const lint = scanForSecrets(text);
+    if (!lint.hasSecrets)
+        return text;
+    let out = '';
+    let cursor = 0;
+    for (const match of [...lint.matches].sort((a, b) => a.start - b.start)) {
+        if (match.start < cursor)
+            continue; // overlapping match already covered
+        out += text.slice(cursor, match.start) + `[REDACTED:${match.kind}]`;
+        cursor = match.end;
+    }
+    out += text.slice(cursor);
+    return out;
+}
 //# sourceMappingURL=privacy-lint.js.map