@phuetz/code-buddy 1.0.0-rc.8 → 1.1.0

package/README.md

@@ -193,7 +193,7 @@ From source, Cowork requires Node.js `>=22` in `cowork/`; the root CLI still sup
 |:---------|:-----------|:-----|
 | **AI Providers** | 15 providers (Grok, Claude, GPT, Gemini, Ollama, LM Studio, AWS Bedrock, Azure, Groq, Together, Fireworks, OpenRouter, vLLM, Copilot, Mistral), circuit breaker, model pairs | [providers.md](docs/providers.md) |
 | **Tools** | ~110 tools with RAG selection, multi-strategy edit matching, Codex-style apply_patch, streaming, BM25 tool search, code exec sandbox | [tools-reference.md](docs/tools-reference.md) |
-| **Commands** | 190+ slash commands, CLI subcommands (`/dev`, `/pr`, `/lint`, `/switch`, `/think`, `/batch`, `/watch`, `/conflicts`, `/vulns`, `/replace`) | [commands.md](docs/commands.md) |
+| **Commands** | 190+ slash commands, CLI subcommands (`/goal`, `/dev`, `/pr`, `/lint`, `/switch`, `/think`, `/batch`, `/watch`, `/conflicts`, `/vulns`, `/replace`) | [commands.md](docs/commands.md) |
 | **Cowork Desktop** | Electron cockpit, embedded Code Buddy engine, backend health/start controls, model settings, permission rules, visual workflows, traces, artifacts, MCP/skills/plugin management | [Cowork Desktop](docs/cowork.md), [cowork/readme.md](cowork/readme.md), [cowork/ARCHITECTURE.md](cowork/ARCHITECTURE.md) |
 | **Buddy Companion** | ChatGPT-backed identity, voice/TTS, proactive check-ins, self-evaluation, competitive radar, mission board, learned routines, safety ledger, local percept journal | [commands.md](docs/commands.md) |
 | **Vision & Presence** | Opt-in webcam snapshots, MediaPipe face/hand/pose/finger-tip analysis, local face enrollment, presence state for the agent | [cowork/ARCHITECTURE.md](cowork/ARCHITECTURE.md) |
@@ -202,7 +202,7 @@ From source, Cowork requires Node.js `>=22` in `cowork/`; the root CLI still sup
 | **Security** | Guardian Agent (AI risk scoring), OS/Docker/OpenShell sandbox, SSRF guard, secrets vault, write policy, exec policy, loop detection, omission detection, output sanitizer | [security.md](docs/security.md) |
 | **Channels** | 20+ messaging channels (Telegram, Discord, Slack, WhatsApp, Signal, Teams, Matrix, IRC, and more), DM pairing, send policy | [channels.md](docs/channels.md) |
 | **Context Engine** | Smart compression, tool output masking, image pruning, transcript repair, pre-compaction flush, restorable compression, JIT context, importance-weighted window | [context-engine.md](docs/context-engine.md) |
-| **Fleet & Autonomy** | Peer-to-peer hub (`peer.chat` / `peer.tool.invoke` / `peer_delegate`), A2A + ACP + MCP interop, 24/7 autonomous service (`buddy autonomy install`), event-driven daemon, claim TTL/lease, DAG task dependencies, workers→verifier→synthesizer swarm, free-first local→Tailscale→paid model tier | [fleet-guide.md](docs/fleet-guide.md) |
+| **Fleet & Autonomy** | Peer-to-peer hub (`peer.chat` / `peer.tool.invoke` / `peer_delegate`), A2A + ACP + MCP interop, 24/7 autonomous service (`buddy autonomy install`), event-driven daemon, claim TTL/lease, DAG task dependencies, workers→verifier→synthesizer swarm, free-first local→Tailscale→paid model tier, judge-gated goal loops (`/goal` Ralph loop, `buddy goal`, board goal-mode, peer-session goals) | [fleet-guide.md](docs/fleet-guide.md) |
 | **Infrastructure** | HTTP server (OpenAI-compatible), WebSocket gateway, daemon mode, cron, device nodes, canvas/A2UI, 6 cloud deploy configs, MCP, plugins | [infrastructure.md](docs/infrastructure.md) |
 | **Configuration** | Env vars, TOML config with profiles, model-aware limits, per-agent params, i18n (6 locales), personas | [configuration.md](docs/configuration.md) |
 | **Development** | TypeScript strict, Vitest (27,334 tests), ESM, middleware pipeline, facade architecture | [development.md](docs/development.md) |
@@ -214,6 +214,7 @@ From source, Cowork requires Node.js `>=22` in `cowork/`; the root CLI still sup
 - **Vision**: local camera snapshots, MediaPipe face/hand/pose/finger-tip percepts, face enrollment, and presence state for context-aware collaboration
 - **Memory**: Persistent + semantic + prospective + decision + coding style memory, ICM cross-session memory
 - **Knowledge**: Knowledge base injection, 40 bundled skills, self-authoring skills at runtime
+- **Goal Loops (Ralph loop)**: `/goal <text>` + `/subgoal` — a judge model re-checks completion after every turn and auto-continues until done (turn budget, pause/resume, fail-open judge); also headless (`buddy goal`), on fleet board tasks (`--goal-mode`, blocks for human review when the budget is spent), and on peer sessions (`peer.chat-session.goal`)
 - **Git Workflow**: Auto-commit (Aider-style), `/pr` creation, merge conflict resolver, ghost snapshots
 - **Code Intelligence**: LSP rename/refactor, auto-import, bug finder (25+ patterns, 6 langs), OpenAPI generator, log analyzer
 - **IDE Integration**: VS Code extension (diff view, inline edit, model switch), JetBrains plugin, LSP server
@@ -241,6 +242,7 @@ From source, Cowork requires Node.js `>=22` in `cowork/`; the root CLI still sup
 | [Channels](docs/channels.md) | 20+ messaging channels, DM pairing, send policy |
 | [Context Engine](docs/context-engine.md) | Compression, tool output masking, JIT context, pre-compaction flush |
 | [Infrastructure](docs/infrastructure.md) | HTTP server, WebSocket gateway, daemon, cron, deploy, plugins |
+| [Deployment](docs/deployment.md) | Production deployment — systemd, Docker, Kubernetes, reverse proxy, env vars, upgrades |
 | [PdfCommander MCP Integration](docs/mcp-pdfcommander-integration.md) | Register the PdfCommander headless MCP server in `mcp.json`, verify with `buddy mcp test`, drive PDF ops from the agent |
 | [Fleet Guide](docs/fleet-guide.md) | **Multi-AI hub** — `/fleet listen` + `/fleet send peer.chat`, env-driven multi-provider auto-detect, Tailscale lab examples, autonomous fleet protocol |
 | [Hermes / OpenClaw Parity](docs/hermes-openclaw-parity.md) | Where Code Buddy stands vs Hermes Agent & OpenClaw — shipped capabilities, externally-gated features, and the one open code gap |

package/dist/agent/codebuddy-agent.js

@@ -121,6 +121,11 @@ export class CodeBuddyAgent extends BaseAgent {
         // This is safe because the singletons returned by getters are the concrete implementations
         this.tokenCounter = this.infrastructure.tokenCounter;
         this.contextManager = this.infrastructure.contextManager;
+        // WS3-T2 — periodic memory snapshot for very long sessions. Interval from
+        // CODEBUDDY_SNAPSHOT_INTERVAL_MIN (default 45 min, 0 disables); the timer
+        // is unref'd so it never keeps a finished process alive. Optional call:
+        // test doubles and custom context engines may not implement snapshots.
+        this.contextManager.startPeriodicSnapshot?.(() => this.historyManager.getMessagesRef());
         this.checkpointManager = this.infrastructure.checkpoints;
         this.sessionStore = this.infrastructure.sessions;
         this.modeManager = this.infrastructure.modeManager;
@@ -295,6 +300,20 @@ export class CodeBuddyAgent extends BaseAgent {
                 catch (err) {
                     logger.debug('Failed to register ContextWarningMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
                 }
+                // Session duration middleware (priority 35) — suggests a clean pause
+                // with a fresh resume point past CODEBUDDY_SESSION_PAUSE_HOURS (12 h)
+                try {
+                    const { SessionDurationMiddleware } = await import('./middleware/session-duration.js');
+                    pipeline.use(new SessionDurationMiddleware({
+                        takeSnapshot: () => {
+                            this.contextManager.takeSnapshot?.(this.historyManager.getMessagesRef());
+                        },
+                    }));
+                    logger.debug('SessionDurationMiddleware registered in pipeline (priority 35)');
+                }
+                catch (err) {
+                    logger.debug('Failed to register SessionDurationMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
+                }
                 // Reasoning middleware (priority 42) — auto-detects complex queries
                 try {
                     const { createReasoningMiddleware } = await import('./middleware/reasoning-middleware.js');
@@ -1637,6 +1656,19 @@ Look at the screenshot and find the element matching the user's intent. Output o
                 });
             }
         }
+        // WS3-T1 — session-end flush: handoff + review-gated lesson candidates.
+        // Fire-and-forget like the dialectic above; callers that need the flush
+        // to complete before process exit await runSessionEndFlush directly.
+        {
+            const chatHistory = this.historyManager.getChatHistory();
+            if (chatHistory && chatHistory.length > 0) {
+                import('./session-end-flush.js')
+                    .then(({ runSessionEndFlush }) => runSessionEndFlush({ chatHistory, client: this.codebuddyClient }))
+                    .catch((err) => {
+                    logger.debug('[session-end-flush] dispose-path flush failed', { error: String(err) });
+                });
+            }
+        }
         // Remove only the forwarding listeners we attached (not other listeners)
         const { start, success, failed, error } = this.repairListeners;
         if (start) {
@@ -1661,6 +1693,7 @@ Look at the screenshot and find the element matching the user's intent. Output o
                 error: err instanceof Error ? err.message : String(err),
             });
         });
+        this.contextManager.stopPeriodicSnapshot?.();
         this.peerRoutingConfig = null;
         super.dispose();
     }

package/dist/agent/hermes-browser-backends.d.ts

@@ -63,6 +63,11 @@ export interface HermesBrowserBackendSmokeResult {
     status: HermesBrowserSmokeStatus;
     stdout: string;
     stderr: string;
+    session?: {
+        debugUrl?: string;
+        id?: string;
+        url?: string;
+    };
 }
 /** One backend attempt made while resolving an `auto` hybrid-routed smoke. */
 export interface HermesBrowserSmokeRouteAttempt {

package/dist/agent/hermes-browser-backends.js

@@ -112,6 +112,7 @@ function browserbaseBackend(env) {
     const credentialSources = presentEnvKeys(env, ['BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID']);
     const configured = credentialSources.includes('BROWSERBASE_API_KEY') &&
         credentialSources.includes('BROWSERBASE_PROJECT_ID');
+    const runnable = Boolean(stagehandVersion && configured);
     return {
         id: 'browserbase',
         label: 'Browserbase / Stagehand',
@@ -119,13 +120,19 @@ function browserbaseBackend(env) {
         status: configured ? 'configured' : stagehandVersion ? 'available' : 'missing',
         installed: Boolean(stagehandVersion),
         configured,
-        runnable: false,
+        runnable,
         command: null,
         version: stagehandVersion,
         credentialSources,
-        smokeCommand: null,
-        notes: ['Stagehand is installed locally; managed Browserbase execution still requires project credentials.'],
-        remediation: configured ? [] : ['Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID for managed browser sessions.'],
+        smokeCommand: runnable ? 'buddy hermes browser-smoke browserbase --json' : null,
+        notes: [
+            'Stagehand is installed locally; managed Browserbase execution uses a real opt-in smoke runner when project credentials are present.',
+        ],
+        remediation: runnable
+            ? []
+            : configured
+                ? ['Install @browserbasehq/stagehand before selecting Browserbase smoke runs.']
+                : ['Set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID for managed browser sessions.'],
     };
 }
 function browserUseBackend(env) {
@@ -261,7 +268,7 @@ function browserRouteGateReason(backend) {
         return null;
     }
     if (backend.id === 'browserbase' && backend.configured) {
-        return 'Browserbase is configured but excluded from auto browser routing until Code Buddy wires a first-class managed runner.';
+        return 'Browserbase is configured but excluded from auto browser routing; use the explicit smoke runner for managed sessions.';
     }
     if (backend.id === 'browser-use' && backend.configured) {
         return 'Browser Use is configured but excluded from auto browser routing until the Nous Tool Gateway runner is wired.';
@@ -415,6 +422,122 @@ async function runRemoteCdpSmoke(now, env) {
         await browser?.close().catch(() => undefined);
     }
 }
+function resolveStagehandActivePage(stagehand) {
+    if (stagehand.page) {
+        return stagehand.page;
+    }
+    const context = stagehand.context;
+    if (!context)
+        return null;
+    if (typeof context.activePage === 'function') {
+        const activePage = context.activePage();
+        if (activePage)
+            return activePage;
+    }
+    if (typeof context.pages === 'function') {
+        return context.pages()[0] ?? null;
+    }
+    if (Array.isArray(context.pages)) {
+        return context.pages[0] ?? null;
+    }
+    return null;
+}
+async function runBrowserbaseSmoke(now, env) {
+    const started = now();
+    const startedAtMs = Date.now();
+    const apiKey = env.BROWSERBASE_API_KEY?.trim();
+    const projectId = env.BROWSERBASE_PROJECT_ID?.trim();
+    if (!apiKey || !projectId) {
+        return {
+            backendId: 'browserbase',
+            command: null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Browserbase / Stagehand',
+            ok: false,
+            output: 'BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID are required for browserbase smoke.',
+            startedAt: started.toISOString(),
+            status: 'not-runnable',
+            stdout: '',
+            stderr: 'BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID are required for browserbase smoke.',
+        };
+    }
+    let stagehand = null;
+    try {
+        const { Stagehand } = await import('@browserbasehq/stagehand');
+        stagehand = new Stagehand({
+            env: 'BROWSERBASE',
+            apiKey,
+            projectId,
+            verbose: 0,
+            localBrowserLaunchOptions: {
+                headless: true,
+            },
+        });
+        await stagehand.init();
+        const page = resolveStagehandActivePage(stagehand);
+        if (!page) {
+            throw new Error('Stagehand did not expose a browser page instance.');
+        }
+        const browserPage = page;
+        if (!browserPage.goto || !browserPage.locator || !browserPage.title) {
+            throw new Error('Stagehand browser page is missing the browser APIs required for smoke validation.');
+        }
+        await browserPage.goto('data:text/html,<title>OK-HERMES-BROWSERBASE</title><h1>OK-HERMES-BROWSERBASE</h1>', {
+            waitUntil: 'domcontentloaded',
+        });
+        const title = await browserPage.title();
+        const heading = await browserPage.locator('h1').textContent?.();
+        const ok = title === 'OK-HERMES-BROWSERBASE' && heading === 'OK-HERMES-BROWSERBASE';
+        const output = `title=${title}; heading=${heading ?? ''}`;
+        return {
+            backendId: 'browserbase',
+            command: null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Browserbase / Stagehand',
+            ok,
+            output,
+            startedAt: started.toISOString(),
+            status: ok ? 'passed' : 'failed',
+            stdout: output,
+            stderr: ok ? '' : 'Unexpected Browserbase page content.',
+            session: {
+                debugUrl: stagehand.browserbaseDebugURL,
+                id: stagehand.browserbaseSessionID,
+                url: stagehand.browserbaseSessionURL,
+            },
+        };
+    }
+    catch (error) {
+        const message = errorMessage(error);
+        return {
+            backendId: 'browserbase',
+            command: null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Browserbase / Stagehand',
+            ok: false,
+            output: message,
+            startedAt: started.toISOString(),
+            status: 'failed',
+            stdout: '',
+            stderr: message,
+            session: stagehand
+                ? {
+                    debugUrl: stagehand.browserbaseDebugURL,
+                    id: stagehand.browserbaseSessionID,
+                    url: stagehand.browserbaseSessionURL,
+                }
+                : undefined,
+        };
+    }
+    finally {
+        if (stagehand?.close) {
+            await stagehand.close().catch(() => undefined);
+        }
+    }
+}
 async function runLocalPlaywrightSmoke(now, options = {}) {
     const started = now();
     const startedAtMs = Date.now();
@@ -574,6 +697,9 @@ export async function runHermesBrowserBackendSmoke(options) {
     if (backend.id === 'remote-cdp') {
         return runRemoteCdpSmoke(now, env);
     }
+    if (backend.id === 'browserbase') {
+        return runBrowserbaseSmoke(now, env);
+    }
     if (!backend.runnable) {
         return blockedSmokeResult(backend.id, 'not-runnable', `${backend.label} is not runnable on this host.`, {
             backend,
@@ -636,6 +762,9 @@ export function renderHermesBrowserSmoke(result) {
     if (result.artifacts?.length) {
         lines.push('Artifacts:', ...result.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path} (${artifact.sizeBytes} bytes)`));
     }
+    if (result.session) {
+        lines.push('Session:', `- id: ${result.session.id ?? 'unknown'}`, `- url: ${result.session.url ?? 'unknown'}`, `${result.session.debugUrl ? `- debug: ${result.session.debugUrl}` : '- debug: unknown'}`);
+    }
     return lines.join('\n');
 }
 //# sourceMappingURL=hermes-browser-backends.js.map

package/dist/agent/hermes-parity-manifest.js

@@ -193,8 +193,8 @@ const FEATURES = [
             'npx tsx src/index.ts tools browser-operator draft "open example.com" --json',
             'npm test -- tests/tools/vision-analyze-real.test.ts --run',
         ],
-        notes: 'Strong local browser work exists, including exact browser_vision and browser_dialog prompt-tool surfaces plus machine-readable backend readiness for local Playwright, CDP, Browserbase/Stagehand, Browser Use gateway, Firecrawl, Camofox, and session recording. A real local Playwright smoke launches Chromium, verifies page content, and writes a trace.zip recording artifact; a real remote CDP smoke attaches to a live Chrome DevTools endpoint without leaking the endpoint. Hybrid routing is now executed, not just planned: an `auto` browser smoke tries the primary safe backend and falls back through the remaining runnable safe backends in order, returning the first that passes plus a machine-readable route (servedBy/usedFallback/attempts) — proven by a real test where an unreachable CDP primary falls back to local Playwright. Complete backend parity for Camofox, Browser Use gateway mode, and managed replay is still not proven.',
-        nextWork: 'Wire first-class managed backend runners (Browserbase/Browser Use) into the executed hybrid route before claiming full Hermes browser backend parity.',
+        notes: 'Strong local browser work exists, including exact browser_vision and browser_dialog prompt-tool surfaces plus machine-readable backend readiness for local Playwright, CDP, Browserbase/Stagehand, Browser Use gateway, Firecrawl, Camofox, and session recording. A real local Playwright smoke launches Chromium, verifies page content, and writes a trace.zip recording artifact; a real remote CDP smoke attaches to a live Chrome DevTools endpoint without leaking the endpoint. Browserbase now also has an opt-in Stagehand smoke runner that can open a real page when project credentials are configured and surfaces the Browserbase session/debug URLs for replay. Hybrid routing is still executed locally and remains safe-by-default: an `auto` browser smoke tries the primary safe backend and falls back through the remaining runnable safe backends in order, returning the first that passes plus a machine-readable route (servedBy/usedFallback/attempts) — proven by a real test where an unreachable CDP primary falls back to local Playwright. Complete backend parity for Camofox, Browser Use gateway mode, and managed replay is still not proven.',
+        nextWork: 'Wire Browser Use gateway mode and managed replay into first-class runners only if those upstream contracts become available and product-relevant.',
     },
     {
         id: 'nous-portal',
@@ -259,6 +259,7 @@ const FEATURES = [
         officialSurface: 'Agentskills.io-compatible skills, hub/taps, URL install, trust/update lifecycle, curator, agent-managed skills',
         codeBuddyEvidence: [
             'src/skills/',
+            'src/skills/hub-signing.ts',
             'src/agent/research-script-skill-candidate.ts',
             'src/agent/hermes-skill-package-summary.ts',
             'src/tools/registry/skills-inspection-tools.ts',
@@ -278,6 +279,7 @@ const FEATURES = [
             'npx tsx src/index.ts skills tap list --json',
             'npx tsx src/index.ts skills update-preview <name> --json',
             'npx tsx src/index.ts skills reset <name> --approved-by <reviewer> --json',
+            'npm test -- tests/skills/hub-signing.test.ts tests/skills/hub.test.ts --run',
             'npm test -- tests/agent/research-script-skill-candidate.test.ts --run',
             'npm test -- tests/agent/hermes-skill-package-summary-real.test.ts --run',
             'npm test -- tests/tools/skills-inspection-real.test.ts --run',
@@ -285,7 +287,7 @@ const FEATURES = [
             '(cd cowork && npm test -- tests/skill-package-manager-bridge.test.ts tests/skill-package-manager-strip.test.ts tests/skills-manager-page.test.tsx --run)',
             'npm test -- tests/skills/hub.test.ts tests/commands/skills-command-real.test.ts --run',
         ],
-        notes: 'Native skill coverage is good and the exact skill_manage prompt-tool action surface now covers official create(content), edit(content), patch(old_string/new_string/file_path/replace_all), write_file, and remove_file semantics with Code Buddy review gates. `buddy hermes skills status --json` now exposes read-only SkillsHub health, missing-file/integrity status, rollback availability, and next review/repair commands from the real workspace lockfile without printing SKILL.md body previews. Candidate review plus Cowork also surface installed package state, current SKILL.md previews, candidate install-state comparisons, bounded unified and expanded side-by-side candidate diffs, reviewer-gated candidate install/overwrite, and reviewer-gated enable/disable/deprecate/rollback/reset/delete/update/patch from the real SkillsHub lockfile. Repository tap/trust management persists owner/repo taps with path and trust metadata through buddy skills tap list/add/remove/trust/refresh, direct .well-known skill catalogs are cached through buddy skills well-known <url>, remote update diff previews are available through buddy skills update-preview plus skill_manage action=preview_update, and Code Buddy reset restores tampered or missing installed skills from real hub/cache content after reviewer approval. Reset is a Code Buddy repair extension because official Hermes skill_manage does not expose a reset action. Cowork now also ships a full-page Skills Manager (cowork/src/renderer/components/skills-manager-page.tsx) reachable via Cmd/Ctrl+Shift+L and the command palette: it aggregates the installed-skill list (status/integrity + inline SKILL.md preview + all lifecycle actions) and the candidate review queue (side-by-side diffs + reviewer-gated install/overwrite) in one page over the existing IPC bridges, for daily skill operations beyond the compact cockpit strips.',
+        notes: 'Native skill coverage is good and the exact skill_manage prompt-tool action surface now covers official create(content), edit(content), patch(old_string/new_string/file_path/replace_all), write_file, and remove_file semantics with Code Buddy review gates. `buddy hermes skills status --json` now exposes read-only SkillsHub health, missing-file/integrity status, rollback availability, and next review/repair commands from the real workspace lockfile without printing SKILL.md body previews. Candidate review plus Cowork also surface installed package state, current SKILL.md previews, candidate install-state comparisons, bounded unified and expanded side-by-side candidate diffs, reviewer-gated candidate install/overwrite, and reviewer-gated enable/disable/deprecate/rollback/reset/delete/update/patch from the real SkillsHub lockfile. Repository tap/trust management persists owner/repo taps with path and trust metadata through buddy skills tap list/add/remove/trust/refresh, direct .well-known skill catalogs are cached through buddy skills well-known <url>, and their registry index can now carry an Ed25519 `signature`/`indexSignature` verified over canonical JSON against the trusted keyring. The keyring is seeded with a read-only official Code Buddy publisher public key while preserving user-added keys. Remote update diff previews are available through buddy skills update-preview plus skill_manage action=preview_update, and Code Buddy reset restores tampered or missing installed skills from real hub/cache content after reviewer approval. Reset is a Code Buddy repair extension because official Hermes skill_manage does not expose a reset action. Cowork now also ships a full-page Skills Manager (cowork/src/renderer/components/skills-manager-page.tsx) reachable via Cmd/Ctrl+Shift+L and the command palette: it aggregates the installed-skill list (status/integrity + inline SKILL.md preview + all lifecycle actions) and the candidate review queue (side-by-side diffs + reviewer-gated install/overwrite) in one page over the existing IPC bridges, for daily skill operations beyond the compact cockpit strips.',
         nextWork: 'Optional polish: live-refresh the manager list after a lifecycle action (currently a manual Refresh) via an onLifecycleComplete callback.',
     },
     {

package/dist/agent/lesson-auto-proposer.js

@@ -15,6 +15,7 @@
 import { CodeBuddyClient } from '../codebuddy/client.js';
 import { detectProviderFromEnv } from '../utils/provider-detector.js';
 import { getLessonCandidateQueue, } from './lesson-candidate-queue.js';
+import { scanForSecrets } from '../fleet/privacy-lint.js';
 import { logger } from '../utils/logger.js';
 const VALID = ['PATTERN', 'RULE', 'CONTEXT', 'INSIGHT'];
 const SYSTEM_PROMPT = `You extract REUSABLE PROCEDURAL LESSONS from a coding session that just completed.
@@ -98,6 +99,15 @@ export async function proposeLessonsFromSession(chatHistory, workDir = process.c
         const content = (cand.content || '').trim();
         if (!content || !VALID.includes(category))
             continue;
+        // WS3 guard-rail: never persist secrets/PII into memory — even into the
+        // review queue, where a reviewer could approve them into lessons.md.
+        const lint = scanForSecrets(`${content}\n${cand.context ?? ''}`);
+        if (lint.hasSecrets) {
+            logger.warn('[lesson-auto-proposer] candidate dropped: contains secret/PII material', {
+                kinds: lint.matches.map((m) => m.kind),
+            });
+            continue;
+        }
         try {
             const { candidate } = queue.propose({
                 category,

package/dist/agent/middleware/session-duration.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Session Duration Middleware (WS3-T3 — auto-pause & resume)
+ *
+ * Very long sessions (12 h+) degrade context quality and pile up risk.
+ * Past a configurable threshold this middleware suggests a clean pause,
+ * takes a fresh context snapshot as the resume point (WS3-T2), and
+ * reminds periodically instead of nagging every turn.
+ *
+ * It never stops the loop — pausing stays the operator's decision; the
+ * autonomous runner has its own bounded budgets (WS1).
+ *
+ * @module agent/middleware
+ */
+import { ConversationMiddleware, MiddlewareContext, MiddlewareResult } from './types.js';
+export interface SessionDurationOptions {
+    /** Pause-suggestion threshold in ms. Default: CODEBUDDY_SESSION_PAUSE_HOURS (12 h); 0 disables. */
+    maxSessionMs?: number;
+    /** Re-warn cadence once past the threshold. Default 60 min. */
+    remindEveryMs?: number;
+    /** Injectable clock for tests. */
+    now?: () => number;
+    /** Take a fresh context snapshot when the pause is suggested (WS3-T2 hook). */
+    takeSnapshot?: () => void;
+}
+export declare class SessionDurationMiddleware implements ConversationMiddleware {
+    readonly name = "session-duration";
+    readonly priority = 35;
+    private readonly startedAt;
+    private readonly thresholdMs;
+    private readonly remindEveryMs;
+    private readonly now;
+    private readonly takeSnapshot;
+    private lastWarnedAt;
+    constructor(options?: SessionDurationOptions);
+    beforeTurn(_context: MiddlewareContext): MiddlewareResult;
+}

package/dist/agent/middleware/session-duration.js

@@ -0,0 +1,78 @@
+/**
+ * Session Duration Middleware (WS3-T3 — auto-pause & resume)
+ *
+ * Very long sessions (12 h+) degrade context quality and pile up risk.
+ * Past a configurable threshold this middleware suggests a clean pause,
+ * takes a fresh context snapshot as the resume point (WS3-T2), and
+ * reminds periodically instead of nagging every turn.
+ *
+ * It never stops the loop — pausing stays the operator's decision; the
+ * autonomous runner has its own bounded budgets (WS1).
+ *
+ * @module agent/middleware
+ */
+import { RunStore } from '../../observability/run-store.js';
+import { logger } from '../../utils/logger.js';
+const HOUR_MS = 3_600_000;
+function defaultThresholdMs() {
+    const hours = parseFloat(process.env.CODEBUDDY_SESSION_PAUSE_HOURS || '12');
+    if (!Number.isFinite(hours) || hours <= 0)
+        return 0; // 0/invalid → disabled
+    return hours * HOUR_MS;
+}
+export class SessionDurationMiddleware {
+    name = 'session-duration';
+    priority = 35;
+    startedAt;
+    thresholdMs;
+    remindEveryMs;
+    now;
+    takeSnapshot;
+    lastWarnedAt = null;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.startedAt = this.now();
+        this.thresholdMs = options.maxSessionMs ?? defaultThresholdMs();
+        this.remindEveryMs = options.remindEveryMs ?? HOUR_MS;
+        this.takeSnapshot = options.takeSnapshot;
+    }
+    beforeTurn(_context) {
+        if (this.thresholdMs <= 0)
+            return { action: 'continue' };
+        const elapsed = this.now() - this.startedAt;
+        if (elapsed < this.thresholdMs)
+            return { action: 'continue' };
+        if (this.lastWarnedAt !== null && this.now() - this.lastWarnedAt < this.remindEveryMs) {
+            return { action: 'continue' };
+        }
+        this.lastWarnedAt = this.now();
+        // Fresh resume point right when the pause is suggested.
+        try {
+            this.takeSnapshot?.();
+        }
+        catch (err) {
+            logger.debug('[session-duration] snapshot on pause suggestion failed', { error: String(err) });
+        }
+        try {
+            const runStore = RunStore.getInstance();
+            if (runStore.getCurrentRunId()) {
+                runStore.appendEvent('pause_suggested', {
+                    elapsedMs: elapsed,
+                    thresholdMs: this.thresholdMs,
+                });
+            }
+        }
+        catch {
+            // Observability must never break the loop.
+        }
+        const hours = (elapsed / HOUR_MS).toFixed(1);
+        return {
+            action: 'warn',
+            message: `⏸️ Session running for ${hours} h. Consider a clean pause: a fresh context ` +
+                `snapshot was just written (.codebuddy/context-snapshot.json), a handoff is ` +
+                `written on exit (.codebuddy/HANDOFF.md), and \`buddy --continue\` reloads the ` +
+                `session. Long sessions degrade context quality — \`/compact\` also helps.`,
+        };
+    }
+}
+//# sourceMappingURL=session-duration.js.map

package/dist/agent/session-end-flush.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Session-end flush (WS3-T1 — Mémoire & continuité du run).
+ *
+ * When a session ends, persist what the next run needs to not start from
+ * zero:
+ *  1. a short HANDOFF file (`.codebuddy/HANDOFF.md`) — last goal, last
+ *     state, files touched, open risks — written synchronously so it also
+ *     works from process `exit` handlers;
+ *  2. reusable lesson candidates via the existing review-gated
+ *     auto-proposer (PENDING only — a human approves them into lessons.md,
+ *     which the per-turn `<lessons_context>` injection then re-injects on
+ *     future runs).
+ *
+ * Guard-rails: trivial sessions are skipped (no LLM call, no file), and
+ * everything written here passes the privacy lint first (PII/secret spans
+ * are redacted from the handoff; tainted lesson candidates are dropped by
+ * the proposer itself).
+ *
+ * @module agent/session-end-flush
+ */
+import type { CodeBuddyClient } from '../codebuddy/client.js';
+import type { ChatEntry } from './types.js';
+export interface SessionEndFlushInput {
+    chatHistory: ChatEntry[];
+    workDir?: string;
+    /** Reuse the session's LLM client for the lesson proposal (no re-auth). */
+    client?: CodeBuddyClient;
+    sessionId?: string;
+    /** Session start (ms epoch) — used for the duration line of the handoff. */
+    startedAt?: number;
+}
+export interface SessionEndFlushResult {
+    /** Lesson candidates enqueued for review (`buddy lessons` to approve). */
+    proposedLessons: number;
+    /** Absolute path of the handoff file, when one was (re)written. */
+    handoffPath?: string;
+    openRisks: string[];
+    skipped?: 'disabled' | 'trivial';
+}
+/**
+ * Heuristic open-risk extraction: error-ish tool results, deduped per tool,
+ * newest kept. No LLM involved — deterministic and free.
+ */
+export declare function extractOpenRisks(history: ChatEntry[]): string[];
+/** Files touched through write-ish tool calls, for the handoff. */
+export declare function extractTouchedFiles(history: ChatEntry[]): string[];
+export interface HandoffOptions {
+    sessionId?: string;
+    startedAt?: number;
+    /** Force a write even below the size threshold (used by tests). */
+    force?: boolean;
+}
+/**
+ * Write `.codebuddy/HANDOFF.md` synchronously. Returns the path when
+ * written, undefined when the session didn't warrant one. Idempotent per
+ * history array so the async flush and a process-exit fallback don't both
+ * write.
+ */
+export declare function writeHandoffSync(history: ChatEntry[], workDir?: string, options?: HandoffOptions): string | undefined;
+/**
+ * Run the complete session-end flush. Safe to call from any exit path:
+ * no-ops on trivial sessions, never throws.
+ */
+export declare function runSessionEndFlush(input: SessionEndFlushInput): Promise<SessionEndFlushResult>;
+/** Test hook: reset the per-history idempotence latch. */
+export declare function resetSessionEndFlushState(): void;