clementine-agent 1.18.186 → 1.18.187

package/dist/agent/background-tasks.d.ts

@@ -48,7 +48,18 @@ export declare function markRunning(id: string, opts?: BackgroundTaskOptions, me
 }): BackgroundTask | null;
 /** Patch non-status metadata on a task. Used for notification bookkeeping. */
 export declare function updateBackgroundTask(id: string, patch: Partial<Omit<BackgroundTask, 'id'>>, opts?: BackgroundTaskOptions): BackgroundTask | null;
-/** Transition to 'done' with final result. */
+/** Transition to 'done' with final result.
+ *
+ * 1.18.187 — Before stamping `done`, run claim-verification: parse the
+ * result text for active-voice action claims ("I deployed X", "I sent
+ * the email") and check the run's event log for matching tool calls.
+ * If the claims have no evidence, stamp `done` but flag
+ * `verificationFlag: 'claimed-without-evidence'` so the dashboard +
+ * future recall surfaces can show the discrepancy. We DON'T refuse the
+ * `done` transition outright — the task did complete from the SDK's
+ * point of view, and refusing would leave it stuck. Instead the flag
+ * makes the hallucination visible and downstream recall blocks can
+ * downweight flagged items. */
 export declare function markDone(id: string, result: string, deliverableNote?: string, opts?: BackgroundTaskOptions): BackgroundTask | null;
 /** Transition to 'failed' or 'aborted' with error message. */
 export declare function markFailed(id: string, error: string, reason?: 'failed' | 'aborted' | 'interrupted', opts?: BackgroundTaskOptions): BackgroundTask | null;

package/dist/agent/background-tasks.js

@@ -138,7 +138,18 @@ function writeFullResultFile(id, result, opts) {
     writeFileSync(file, result);
     return file;
 }
-/** Transition to 'done' with final result. */
+/** Transition to 'done' with final result.
+ *
+ * 1.18.187 — Before stamping `done`, run claim-verification: parse the
+ * result text for active-voice action claims ("I deployed X", "I sent
+ * the email") and check the run's event log for matching tool calls.
+ * If the claims have no evidence, stamp `done` but flag
+ * `verificationFlag: 'claimed-without-evidence'` so the dashboard +
+ * future recall surfaces can show the discrepancy. We DON'T refuse the
+ * `done` transition outright — the task did complete from the SDK's
+ * point of view, and refusing would leave it stuck. Instead the flag
+ * makes the hallucination visible and downstream recall blocks can
+ * downweight flagged items. */
 export function markDone(id, result, deliverableNote, opts) {
     const task = loadBackgroundTask(id, opts);
     if (!task)
@@ -155,6 +166,24 @@ export function markDone(id, result, deliverableNote, opts) {
         task.deliverableNote = deliverableNote;
     else if (resultPath)
         task.deliverableNote = resultPath;
+    // 1.18.187 — claim verification (Part D). Best-effort: load the
+    // events file for this run, check whether the result's first-person
+    // action claims have matching tool calls. Failure to verify (e.g.,
+    // missing event log on older installs) is non-fatal — we just skip
+    // the flag.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
+        const { verifyTaskClaims } = require('./claim-verification.js');
+        const verdict = verifyTaskClaims(result, task.runId);
+        if (verdict && verdict.ok === false) {
+            task.verificationFlag = 'claimed-without-evidence';
+            task.verificationDetails = verdict.missingEvidence
+                .map((m) => `${m.label}: expected any of {${m.expectedAnyOf.join(', ')}} — none found`)
+                .join('; ')
+                .slice(0, 1000);
+        }
+    }
+    catch { /* claim verification is best-effort */ }
     safeWrite(pathFor(id, opts), task);
     return task;
 }

package/dist/agent/claim-verification.d.ts

@@ -0,0 +1,64 @@
+/**
+ * claim-verification — detect when an agent claims to have done
+ * something but the run's tool-call history shows no matching action.
+ *
+ * Why this exists (1.18.187)
+ * ──────────────────────────
+ * On 2026-05-11 a bg task was diagnosed where Clementine said "The
+ * site is live again at https://X.netlify.app — all 100 coaches with
+ * search/filter/sort intact" — but the live URL returned HTTP 404,
+ * and the run had zero tool calls matching a deploy. She had
+ * confabulated success from a recall summary of a PRIOR task.
+ *
+ * The bg-task framework's `markDone` had no verification: it accepted
+ * the agent's claim verbatim and stamped status='done'. Downstream,
+ * the "Recently completed background work" recall block then
+ * re-injected that hallucinated "done" claim into the next session's
+ * prompt, perpetuating the lie.
+ *
+ * This module breaks the cycle by inspecting the result text for
+ * active-voice action claims ("I deployed X", "I sent the email")
+ * and cross-referencing against the run's event log
+ * (~/.clementine/events/<runId>.jsonl). When a claim has no matching
+ * evidence, the task is flagged for owner review instead of stamped
+ * `done`.
+ *
+ * Pure functions where possible; one I/O call to read the event log.
+ */
+import type { RunEvent } from '../types.js';
+export type VerificationVerdict = {
+    ok: true;
+    reason: 'no-claims';
+} | {
+    ok: true;
+    reason: 'evidence-found';
+    matchedClaims: Array<{
+        label: string;
+        evidence: string;
+    }>;
+} | {
+    ok: false;
+    reason: 'claimed-without-evidence';
+    missingEvidence: Array<{
+        label: string;
+        expectedAnyOf: string[];
+    }>;
+};
+export interface VerifyOptions {
+    /** Path to the events directory. Defaults to ~/.clementine/events. */
+    eventsDir?: string;
+    /** Pre-loaded events (for tests). When set, eventsDir is ignored. */
+    events?: RunEvent[];
+}
+/**
+ * Verify that a bg-task's result text matches the tool calls actually
+ * made during the run.
+ *
+ * @param resultText   The text the agent produced as the final response.
+ * @param runId        The run id; used to find the event log on disk.
+ * @param opts         Test injection: pre-loaded events or alt directory.
+ * @returns            A verdict object the caller (markDone) can use to
+ *                     decide whether to stamp `done` or flag the task.
+ */
+export declare function verifyTaskClaims(resultText: string, runId: string | undefined, opts?: VerifyOptions): VerificationVerdict;
+//# sourceMappingURL=claim-verification.d.ts.map

package/dist/agent/claim-verification.js

@@ -0,0 +1,197 @@
+/**
+ * claim-verification — detect when an agent claims to have done
+ * something but the run's tool-call history shows no matching action.
+ *
+ * Why this exists (1.18.187)
+ * ──────────────────────────
+ * On 2026-05-11 a bg task was diagnosed where Clementine said "The
+ * site is live again at https://X.netlify.app — all 100 coaches with
+ * search/filter/sort intact" — but the live URL returned HTTP 404,
+ * and the run had zero tool calls matching a deploy. She had
+ * confabulated success from a recall summary of a PRIOR task.
+ *
+ * The bg-task framework's `markDone` had no verification: it accepted
+ * the agent's claim verbatim and stamped status='done'. Downstream,
+ * the "Recently completed background work" recall block then
+ * re-injected that hallucinated "done" claim into the next session's
+ * prompt, perpetuating the lie.
+ *
+ * This module breaks the cycle by inspecting the result text for
+ * active-voice action claims ("I deployed X", "I sent the email")
+ * and cross-referencing against the run's event log
+ * (~/.clementine/events/<runId>.jsonl). When a claim has no matching
+ * evidence, the task is flagged for owner review instead of stamped
+ * `done`.
+ *
+ * Pure functions where possible; one I/O call to read the event log.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { BASE_DIR } from '../config.js';
+/**
+ * Claim rules ordered by specificity. Each rule has a verb pattern
+ * (first-person active voice with optional adverbs/modifiers) and
+ * the set of tool-call shapes that count as evidence for it.
+ *
+ * Pattern shape: `\bI\s+(have\s+)?(verb-tensed)\b`
+ *
+ * Active voice + first person is required — "X is deployed" or
+ * "the site has been deployed" don't trigger (those are status
+ * references, not action claims).
+ */
+const CLAIM_RULES = [
+    {
+        label: 'deploy',
+        pattern: /\bI\s+(?:have\s+)?(?:just\s+|now\s+)?(?:deployed|published|pushed|launched|uploaded)\b/i,
+        evidenceMatchers: [
+            { kind: 'bashCommand', pattern: /\bnetlify\s+deploy\b/i, describe: 'netlify deploy' },
+            { kind: 'bashCommand', pattern: /\bvercel\s+(?:--prod|deploy)\b/i, describe: 'vercel deploy' },
+            { kind: 'bashCommand', pattern: /\bgh-pages\b/i, describe: 'gh-pages publish' },
+            { kind: 'bashCommand', pattern: /\bgit\s+push\b/i, describe: 'git push' },
+            { kind: 'bashCommand', pattern: /\brsync\b/i, describe: 'rsync upload' },
+            { kind: 'bashCommand', pattern: /\baws\s+s3\s+(?:cp|sync)\b/i, describe: 'aws s3 upload' },
+            { kind: 'bashCommand', pattern: /\bcurl\s+.*-X\s+(?:POST|PUT)\b/i, describe: 'curl POST/PUT (API deploy)' },
+            { kind: 'toolName', pattern: /^mcp__.*__(?:deploy|publish|upload)/i, describe: 'MCP deploy tool' },
+            { kind: 'toolName', pattern: /^project_deploy$/i, describe: 'project_deploy tool' },
+        ],
+    },
+    {
+        label: 'send',
+        pattern: /\bI\s+(?:have\s+)?(?:just\s+)?(?:sent|emailed|messaged|posted|notified)\b/i,
+        evidenceMatchers: [
+            { kind: 'toolName', pattern: /^mcp__.*__(?:send|reply|create_message|post|notify)/i, describe: 'integration send tool' },
+            { kind: 'toolName', pattern: /^discord_(?:channel_send|send_dm|reply)/i, describe: 'discord send' },
+            { kind: 'toolName', pattern: /^outlook_(?:send|reply)/i, describe: 'outlook send' },
+            { kind: 'toolName', pattern: /^gmail_send/i, describe: 'gmail send' },
+            { kind: 'toolName', pattern: /^slack_(?:send|post)/i, describe: 'slack post' },
+            { kind: 'bashCommand', pattern: /\bcurl\s+.*-X\s+POST\b/i, describe: 'curl POST (webhook)' },
+        ],
+    },
+    {
+        label: 'write/create',
+        pattern: /\bI\s+(?:have\s+)?(?:just\s+)?(?:created|wrote|saved|built|generated)\s+(?:the|a|an|new)\b/i,
+        evidenceMatchers: [
+            { kind: 'toolName', pattern: /^Write$/i, describe: 'Write tool' },
+            { kind: 'toolName', pattern: /^Edit$/i, describe: 'Edit tool' },
+            { kind: 'toolName', pattern: /^NotebookEdit$/i, describe: 'NotebookEdit tool' },
+            { kind: 'bashCommand', pattern: />\s*[^\s|;&]+/, describe: 'shell write redirect' },
+            { kind: 'bashCommand', pattern: /\bmkdir\b/i, describe: 'mkdir' },
+            { kind: 'bashCommand', pattern: /\bcp\b|\bmv\b/i, describe: 'cp/mv' },
+            { kind: 'toolName', pattern: /^note_create$/i, describe: 'note_create' },
+            { kind: 'toolName', pattern: /^memory_write$/i, describe: 'memory_write' },
+        ],
+    },
+    {
+        label: 'merge',
+        pattern: /\bI\s+(?:have\s+)?(?:just\s+)?(?:merged|combined|consolidated|joined)\s+(?:the|a|two|all|both)\b/i,
+        evidenceMatchers: [
+            { kind: 'toolName', pattern: /^Write$/i, describe: 'Write tool (output file)' },
+            { kind: 'toolName', pattern: /^Edit$/i, describe: 'Edit tool' },
+            { kind: 'bashCommand', pattern: /\b(?:cat|paste|jq|awk)\b.*>\s*[^\s|;&]+/, describe: 'shell merge into file' },
+            { kind: 'bashCommand', pattern: /\bgit\s+merge\b/i, describe: 'git merge' },
+        ],
+    },
+];
+/**
+ * Verify that a bg-task's result text matches the tool calls actually
+ * made during the run.
+ *
+ * @param resultText   The text the agent produced as the final response.
+ * @param runId        The run id; used to find the event log on disk.
+ * @param opts         Test injection: pre-loaded events or alt directory.
+ * @returns            A verdict object the caller (markDone) can use to
+ *                     decide whether to stamp `done` or flag the task.
+ */
+export function verifyTaskClaims(resultText, runId, opts = {}) {
+    const text = String(resultText ?? '');
+    if (!text.trim())
+        return { ok: true, reason: 'no-claims' };
+    // 1. Find all claim rules whose pattern matches the result text.
+    const triggeredRules = CLAIM_RULES.filter((r) => r.pattern.test(text));
+    if (triggeredRules.length === 0) {
+        // No first-person active-voice action claims — nothing to verify.
+        // (Pure status reports like "the file is at /x/y/z" pass through.)
+        return { ok: true, reason: 'no-claims' };
+    }
+    // 2. Load the run's event log to inspect tool calls.
+    const events = opts.events ?? loadEvents(runId, opts.eventsDir);
+    // 3. For each triggered rule, check whether ANY matching evidence
+    // exists in the event log. If at least one rule has zero evidence,
+    // the verdict is claimed-without-evidence.
+    const matched = [];
+    const missing = [];
+    for (const rule of triggeredRules) {
+        const hit = findEvidence(events, rule);
+        if (hit) {
+            matched.push({ label: rule.label, evidence: hit });
+        }
+        else {
+            missing.push({
+                label: rule.label,
+                expectedAnyOf: rule.evidenceMatchers.map((m) => m.describe),
+            });
+        }
+    }
+    if (missing.length > 0) {
+        return { ok: false, reason: 'claimed-without-evidence', missingEvidence: missing };
+    }
+    return { ok: true, reason: 'evidence-found', matchedClaims: matched };
+}
+// ── Internals ────────────────────────────────────────────────────────
+function loadEvents(runId, eventsDir) {
+    if (!runId)
+        return [];
+    const dir = eventsDir ?? path.join(BASE_DIR, 'events');
+    const safe = String(runId).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 128);
+    const file = path.join(dir, `${safe}.jsonl`);
+    if (!fs.existsSync(file))
+        return [];
+    try {
+        const lines = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+        const out = [];
+        for (const line of lines) {
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch { /* skip malformed */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function findEvidence(events, rule) {
+    for (const event of events) {
+        if (event.kind !== 'tool_call')
+            continue;
+        const toolName = String(event.toolName ?? '');
+        // Match against tool name patterns.
+        for (const m of rule.evidenceMatchers) {
+            if (m.kind === 'toolName' && m.pattern.test(toolName)) {
+                return `${m.describe} (tool: ${toolName})`;
+            }
+        }
+        // For Bash tool calls, inspect the command argument.
+        if (toolName === 'Bash' && event.toolInput) {
+            const cmd = extractBashCommand(event.toolInput);
+            if (cmd) {
+                for (const m of rule.evidenceMatchers) {
+                    if (m.kind === 'bashCommand' && m.pattern.test(cmd)) {
+                        return `${m.describe} (Bash: ${cmd.slice(0, 80)})`;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+function extractBashCommand(toolInput) {
+    if (!toolInput || typeof toolInput !== 'object')
+        return null;
+    const obj = toolInput;
+    if (typeof obj.command === 'string')
+        return obj.command;
+    return null;
+}
+//# sourceMappingURL=claim-verification.js.map

package/dist/agent/clementine-turn-context.d.ts

@@ -41,6 +41,7 @@
  * note on prompt caching boundaries.
  */
 import type { BackgroundTask } from '../types.js';
+import type { ProjectMeta } from './assistant.js';
 export interface BuildTurnContextOptions {
     /** The user's current message — used as the query for retrieved memory. */
     userMessage: string;
@@ -79,6 +80,11 @@ export interface BuildTurnContextOptions {
     }) => BackgroundTask[];
     /** Clock injection for tests. Defaults to Date.now(). */
     now?: () => number;
+    /** 1.18.187 — active project for this turn. When set, the
+     *  "Active project" section renders with path, STATUS.md preview,
+     *  source/output file inventory, and deploy.json summary (if any).
+     *  Set by the router's resolver before the chat call. */
+    activeProject?: ProjectMeta | null;
 }
 export interface BuildTurnContextResult {
     /** The full ready-to-prepend context block, INCLUDING outer
@@ -93,6 +99,10 @@ export interface BuildTurnContextResult {
         recentBgTasks: number;
         liveState: boolean;
         identityFrame: boolean;
+        /** 1.18.187 — whether the active-project block rendered. */
+        activeProject: boolean;
+        /** 1.18.187 — whether the dispute gate fired (suppressed past-success recall). */
+        disputeDetected: boolean;
     };
     /** Final character count of the block. Useful for logging + the
      *  Anthropic prompt-cache-health analysis. */

package/dist/agent/clementine-turn-context.js

@@ -40,7 +40,10 @@
  * in the USER message, NOT in the system prompt. See the SDK reference
  * note on prompt caching boundaries.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import pino from 'pino';
+import { detectDisputePattern } from './project-resolver.js';
 const logger = pino({ name: 'clementine.turn-context' });
 // ── Tunables ──────────────────────────────────────────────────────────
 /** Hard cap on the entire block. Keep volatile content small so the
@@ -59,10 +62,42 @@ export function buildClementineTurnContext(opts) {
         recentBgTasks: 0,
         liveState: false,
         identityFrame: false,
+        activeProject: false,
+        disputeDetected: false,
     };
     const parts = [];
     const nowMs = (opts.now ?? Date.now)();
     const nowDate = new Date(nowMs);
+    // 1.18.187 — detect dispute pattern (Part E). When the owner is
+    // reporting a failure of prior work, we want to suppress "past
+    // success" recall items (they bias the model toward defending its
+    // memory instead of verifying reality) and add a verification
+    // directive at the top of the block.
+    const disputeDetected = detectDisputePattern(opts.userMessage);
+    sections.disputeDetected = disputeDetected;
+    if (disputeDetected) {
+        parts.push('### Dispute mode — verification posture\n' +
+            'The owner is disputing prior work. **Treat recalled `done` claims as suspect.** ' +
+            'Before defending a past success in memory, verify reality with tools — ' +
+            'curl any URLs you previously claimed, check files that should exist, run status commands. ' +
+            'Honest "I claimed X but on re-check it failed because Y" is better than " I deployed it, see memory."');
+    }
+    // 1.18.187 — active project block (Part B). Renders when the
+    // session has a linked project resolved for this turn. Includes
+    // path, STATUS.md preview, source/output inventory, and deploy.json
+    // summary so the model knows where to read, write, and deploy.
+    if (opts.activeProject?.path && fs.existsSync(opts.activeProject.path)) {
+        try {
+            const projectBlock = buildActiveProjectBlock(opts.activeProject);
+            if (projectBlock) {
+                parts.push(projectBlock);
+                sections.activeProject = true;
+            }
+        }
+        catch (err) {
+            logger.debug({ err, project: opts.activeProject.path }, 'turn-context: active project block failed (non-fatal)');
+        }
+    }
     // ── 1. Retrieved memory hits ──────────────────────────────────────
     // The single most important section. Pulls the top semantic + FTS
     // hits from the SQLite memory store, scored against the user's
@@ -98,9 +133,17 @@ export function buildClementineTurnContext(opts) {
     // ── 2. Recent background task headlines ───────────────────────────
     // Last 24h of terminal-state bg tasks. So when the owner asks "what
     // happened with that job?" she knows without re-asking.
+    //
+    // 1.18.187 dispute gate (Part E): when the owner is disputing prior
+    // work, exclude `done`-status tasks — those are exactly the entries
+    // that bias the model toward "but my memory says it succeeded."
+    // Failed/aborted/interrupted tasks STAY because they're useful
+    // signal for the verification posture.
     if (opts.listBackgroundTasks) {
         try {
-            const TERMINAL = ['done', 'failed', 'interrupted', 'aborted'];
+            const TERMINAL = disputeDetected
+                ? ['failed', 'interrupted', 'aborted']
+                : ['done', 'failed', 'interrupted', 'aborted'];
             const recent = [];
             for (const status of TERMINAL) {
                 const tasks = opts.listBackgroundTasks({ status });
@@ -123,10 +166,18 @@ export function buildClementineTurnContext(opts) {
                 const lines = ['### Recently completed background work (last 24h)'];
                 for (const task of recent.slice(0, MAX_BG_TASKS)) {
                     const promptPreview = (task.prompt ?? '').slice(0, 80).replace(/\s+/g, ' ').trim();
+                    // 1.18.187 — flagged tasks get an explicit "claim not
+                    // verified" warning so the model doesn't read them as
+                    // authoritative. The verificationFlag is set by markDone
+                    // when the result text claimed actions the event log can't
+                    // back up. See agent/claim-verification.ts.
+                    const flag = task.verificationFlag === 'claimed-without-evidence'
+                        ? ' ⚠ CLAIM NOT VERIFIED'
+                        : '';
                     const tail = task.status === 'done'
                         ? (task.result ?? task.deliverableNote ?? 'done').slice(0, 100).replace(/\s+/g, ' ').trim()
                         : (task.error ?? task.status).slice(0, 100).replace(/\s+/g, ' ').trim();
-                    const line = `- **${task.status}**: ${promptPreview} → ${tail}`;
+                    const line = `- **${task.status}**${flag}: ${promptPreview} → ${tail}`;
                     lines.push(line.slice(0, MAX_BG_TASK_LINE_CHARS));
                     sections.recentBgTasks += 1;
                 }
@@ -191,6 +242,121 @@ export function buildClementineTurnContext(opts) {
     };
 }
 // ── Helpers ───────────────────────────────────────────────────────────
+// ── Active project block (1.18.187) ──────────────────────────────────
+const STATUS_PREVIEW_CHARS = 800;
+const MAX_FILES_LISTED = 8;
+/**
+ * Render an "Active project" block summarizing the project's name,
+ * path, current STATUS.md content (capped), source/output file
+ * inventory, and deploy.json config (if present).
+ *
+ * Designed to give the model everything it needs to continue work on
+ * the project in one shot: WHERE the data lives, WHAT'S been done,
+ * HOW to deploy.
+ *
+ * Returns empty string when the project folder is missing or
+ * unreadable — caller treats empty as "no project block this turn."
+ */
+function buildActiveProjectBlock(project) {
+    const projectPath = project.path;
+    const basename = path.basename(projectPath);
+    const displayName = project.description ? `${basename} (${project.description})` : basename;
+    const lines = [];
+    lines.push(`### Active project: ${displayName}`);
+    lines.push(`Path: \`${projectPath}\``);
+    // Inventory the top-level (and a sources/ + output/ if they exist).
+    try {
+        const inventory = inventoryProject(projectPath);
+        if (inventory.length > 0) {
+            lines.push('');
+            lines.push('**Layout:**');
+            for (const item of inventory) {
+                lines.push(`  - ${item}`);
+            }
+        }
+    }
+    catch { /* inventory failure is non-fatal */ }
+    // STATUS.md preview.
+    const statusPath = path.join(projectPath, '.clementine', 'STATUS.md');
+    if (fs.existsSync(statusPath)) {
+        try {
+            const status = fs.readFileSync(statusPath, 'utf-8').trim();
+            if (status) {
+                const preview = status.length > STATUS_PREVIEW_CHARS
+                    ? status.slice(0, STATUS_PREVIEW_CHARS - 3) + '...'
+                    : status;
+                lines.push('');
+                lines.push('**STATUS.md:**');
+                lines.push(preview);
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Deploy config summary.
+    const deployPath = path.join(projectPath, '.clementine', 'deploy.json');
+    if (fs.existsSync(deployPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(deployPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object') {
+                const kind = parsed.kind ?? 'unknown';
+                const site = parsed.site ?? '?';
+                const dir = parsed.dir ?? 'output';
+                const verifyUrl = parsed.verifyUrl ?? '?';
+                lines.push('');
+                lines.push(`**Deploy config:** ${kind} → ${site} (deploy dir: \`${dir}\`, verifies at ${verifyUrl}).`);
+                lines.push('Use the \`project_deploy\` tool when ready — it runs the command AND curls the URL to verify before reporting success.');
+            }
+        }
+        catch { /* skip */ }
+    }
+    else {
+        lines.push('');
+        lines.push('**No deploy config yet.** If this project should deploy somewhere, ask the owner where and ' +
+            'write `.clementine/deploy.json` with shape: `{kind: "netlify", site: "...", dir: "output", verifyUrl: "..."}`.');
+    }
+    return lines.join('\n');
+}
+function inventoryProject(projectPath) {
+    const out = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(projectPath, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    // Highlight the conventional folders first.
+    const conventional = ['sources', 'output', '.clementine'];
+    for (const name of conventional) {
+        const entry = entries.find((e) => e.name === name && e.isDirectory());
+        if (!entry)
+            continue;
+        const inside = path.join(projectPath, name);
+        try {
+            const items = fs.readdirSync(inside).filter((n) => !n.startsWith('.'));
+            const summary = items.length === 0
+                ? '(empty)'
+                : items.length > MAX_FILES_LISTED
+                    ? `${items.slice(0, MAX_FILES_LISTED).join(', ')}, +${items.length - MAX_FILES_LISTED} more`
+                    : items.join(', ');
+            out.push(`\`${name}/\` — ${summary}`);
+        }
+        catch {
+            out.push(`\`${name}/\``);
+        }
+    }
+    // Then top-level files (data + code) up to MAX_FILES_LISTED.
+    const topFiles = entries
+        .filter((e) => e.isFile() && !e.name.startsWith('.'))
+        .map((e) => e.name);
+    if (topFiles.length > 0) {
+        const summary = topFiles.length > MAX_FILES_LISTED
+            ? `${topFiles.slice(0, MAX_FILES_LISTED).join(', ')}, +${topFiles.length - MAX_FILES_LISTED} more`
+            : topFiles.join(', ');
+        out.push(`top-level files: ${summary}`);
+    }
+    return out;
+}
 function buildIdentityLine(opts) {
     const parts = [];
     if (opts.ownerName) {