agent-nuvira 3.3.11 → 3.3.13

package/dist/tools/registry.js

@@ -29,6 +29,7 @@ import { ACTION_BY_INTENT } from '../nlu/actions.js';
 import { detectPermissionSeeking, IRREVERSIBLE_ACTION_RE } from '../learning/autonomy-policy.js';
 import { createFindingTool } from './finding-tool.js';
 import { recordArtifact } from './artifact-append.js';
+import { checkStepArtifacts } from './step-artifact.js';
 // ─── Tool definitions ───────────────────────────────────────────────────────
 // ─── Shared auto-delivery helper ─────────────────────────────────────────
 // Tools that produce artifact files (generate_image, speak, video_generate)
@@ -197,6 +198,10 @@ export const planTodoSchema = z.object({
         .describe('Ordered steps (required for action=create)'),
     id: z.string().optional().describe('The step id to update (required for action=update)'),
     status: z.enum(['pending', 'running', 'done', 'blocked']).optional().describe('New status for the step (required for action=update)'),
+    note: z
+        .string()
+        .optional()
+        .describe('Optional plain-English note for this step, recorded with the update (e.g. "reproduced with a minimal test", "blocked on the missing API key"). Shown in the progress table and the completion summary.'),
 });
 /** H2 — delegate tool args: a focused subtask for a specialized sub-agent. */
 const delegateSchema = z.object({
@@ -527,7 +532,13 @@ registerTool({
         // Narrow on purpose — both conditions must hold, and any question naming an
         // irreversible action (overwrite, delete, publish, deploy, send, pay…) is
         // passed straight through, because that decision IS the user's.
-        if ((ctx.writesAuthorized?.authorized === true || Boolean(ctx.envelope)) &&
+        // A confirmation the TOOL ITSELF demanded (run_terminal's "call ask_user")
+        // must not be swallowed by this gate — that is the deadlock fixed in
+        // ToolContext.pendingConfirmation. Consume the flag and fall through so the
+        // question reaches the user once.
+        const pending = ctx.pendingConfirmation;
+        if (!pending &&
+            (ctx.writesAuthorized?.authorized === true || Boolean(ctx.envelope)) &&
             detectPermissionSeeking(question) &&
             !IRREVERSIBLE_ACTION_RE.test(question)) {
             const recommended = choices[0]?.label ?? '';
@@ -551,6 +562,9 @@ registerTool({
                 'high-impact and irreversible, and has no sensible default — re-call ask_user naming ' +
                 'that specific irreversible choice (e.g. whether to overwrite an existing file).');
         }
+        // One confirmation refusal buys exactly ONE ask — clear it before rendering.
+        if (pending)
+            ctx.pendingConfirmation = undefined;
         const render = ctx.askUser || (await import('./ask-user.js')).renderAskUser;
         const answer = await render(question, choices, multi_select);
         const picked = Array.isArray(answer.answer) ? answer.answer.join(', ') : answer.answer;
@@ -668,12 +682,12 @@ registerTool({
 // cards show tool calls; this shows the plan itself).
 registerTool({
     name: 'plan_todo',
-    description: 'Declare and track a multi-step plan: create ordered steps with descriptions, then mark each as running/done/blocked as you work through them. Use for any job with 2+ steps — the checklist persists across the whole conversation, so a later turn can reference "step N is done". Call create once at the start, then update per step as each completes.',
+    description: 'Declare and track a multi-step plan as a live progress table: create ordered steps with descriptions, then update each step (running → done/blocked) as you work, ideally with a short note saying what happened. Use for any job with 2+ steps — the table persists across the whole conversation AND across sessions, so a later turn can reference "step N is done", and the plan closes out with an achieved summary. Call create once at the start, then update each step as it starts and again as it finishes.',
     category: 'workflow',
     inputSchema: planTodoSchema,
     endsAgentStep: false,
     run: async (args, ctx) => {
-        const { action, goal, steps, id, status } = planTodoSchema.parse(args);
+        const { action, goal, steps, id, status, note } = planTodoSchema.parse(args);
         const { defaultPlanStore } = await import('./plan-store.js');
         const store = ctx.planStore ?? defaultPlanStore();
         if (action === 'create') {
@@ -683,7 +697,30 @@ registerTool({
             store.create(goal, steps);
         }
         else if (id && status) {
-            store.update(id, status);
+            // A1 — never accept an update that matched nothing. Silently returning
+            // the unchanged plan reads as success to the model (and as tracking to
+            // the user) while the counter stays frozen; observed live on the `cal`
+            // Android run, where the checklist sat at `1/7` across four successful
+            // steps. Resolve the reference first and, when it names no step, say so
+            // with the ids that DO exist so the model can re-send it and move on.
+            const resolved = store.resolveStepId ? store.resolveStepId(id) : id;
+            if (!resolved) {
+                const valid = (store.snapshot?.()?.steps ?? []).map((s) => s.id);
+                return `Error: plan_todo found no step "${id}" — valid step ids: ${valid.length > 0 ? valid.join(', ') : '(none — declare the plan with action "create" first)'}. Re-send this update with one of those ids.`;
+            }
+            // A6 — a step that NAMES an artifact is done only once that artifact
+            // exists. The plan can otherwise advance past undelivered work (the `cal`
+            // run kept going after its APK step never produced an APK). Checked
+            // against the workspace; a step with no file-like token is unaffected.
+            if (status === 'done' && ctx.cwd) {
+                const step = store.snapshot?.()?.steps.find((s) => s.id === resolved);
+                const { missing } = checkStepArtifacts(step?.description ?? '', ctx.cwd);
+                if (missing.length > 0) {
+                    return (`Error: step "${resolved}" names artifact(s) that do not exist yet: ${missing.join(', ')}. ` +
+                        `Create them in ${ctx.cwd}, then mark the step done — a step is not done while its artifact is missing.`);
+                }
+            }
+            store.update(resolved, status, note);
         }
         else {
             return 'Error: plan_todo update needs id + status (pending|running|done|blocked).';
@@ -1880,6 +1917,53 @@ registerTool({
         return JSON.stringify(m.getSecurityScorer().score(filePath));
     }),
 });
+// Secret scan tool — LOCAL, dependency-free, on-demand.
+//
+// `security_score`/`ast_audit` scan ONE named file and report a score. This is
+// the other question an agent that writes and commits code actually has to
+// answer before it commits: "is anything secret-shaped anywhere in here?". It
+// walks the tree with bounded coverage, needs no `gitleaks`/`ggshield` binary
+// and no network, and reports masked values only — see src/security/secret-scan.ts.
+registerTool({
+    name: 'secret_scan',
+    description: 'Scan the workspace for secret-shaped strings (API keys, tokens, private keys, credentials in URLs) before committing or publishing. Fully local — no network and no external scanner binary — and every reported value is masked. Returns findings with path:line and severity, plus a summary. Set history:true to scan git HISTORY as well (every committed version of every file) — a key deleted in a later commit is STILL committed and must be rotated. A clean result means "nothing matched a known shape", NOT "no secrets": report it as a lint, never as a guarantee.',
+    category: 'workflow',
+    inputSchema: z.object({
+        path: z.string().optional().describe('Directory to scan (relative to the workspace, or absolute). Default: the workspace root.'),
+        subdir: z.string().optional().describe('Narrow the scan to one subtree, e.g. "src" or "docs".'),
+        maxFiles: z.number().optional().describe('Cap on files visited (default 5000) — a huge repo does not hang the turn.'),
+        history: z.boolean().optional().describe('Also scan git history (reachable blobs) for secrets ever committed. Default false. Use before publishing or when auditing an existing repo.'),
+        maxBlobs: z.number().optional().describe('With history:true, cap on distinct historical blobs read (default 2000).'),
+    }),
+    endsAgentStep: false,
+    run: async (args, ctx) => {
+        const { join } = await import('node:path');
+        const m = await import('../security/secret-scan.js');
+        const { path: target, subdir, maxFiles, history, maxBlobs } = args;
+        const cwd = ctx?.cwd ?? process.cwd();
+        const root = target
+            ? (target.startsWith('/') || /^[A-Za-z]:[\\/]/.test(target) ? target : join(cwd, target))
+            : cwd;
+        if (history) {
+            // History only: the tree scan runs first (fast, no git), then history is
+            // appended as its own section so a reader can tell the two apart.
+            const tree = m.scanDirectory(root, {
+                ...(subdir ? { subdir } : {}),
+                ...(maxFiles ? { maxFiles } : {}),
+            });
+            const hist = m.scanGitHistory(root, {
+                ...(subdir ? { subdir } : {}),
+                ...(maxBlobs ? { maxBlobs } : {}),
+            });
+            return [m.formatSecretScan(tree), '', '── git history ──', m.formatSecretHistoryScan(hist)].join('\n');
+        }
+        const result = m.scanDirectory(root, {
+            ...(subdir ? { subdir } : {}),
+            ...(maxFiles ? { maxFiles } : {}),
+        });
+        return m.formatSecretScan(result);
+    },
+});
 // ─── Batch 5: Infrastructure ──────────────────────────────────────────────
 // Tool search tool — the tiered-exposure discovery surface. Two actions:
 // - search (default): fuzzy-find tools by query (the pre-existing behavior).
@@ -2901,6 +2985,83 @@ registerTool({
         return mgr.extract(filePath, { ocr: Boolean(ocr) }).then((r) => JSON.stringify(r));
     }),
 });
+// Knowledge — tag-scoped, vectorized retrieval over the user's own documents
+//
+// WHY A TOOL. The user's flow is "bring documents, tag them, ask questions scoped
+// to that tag." Retrieval must be something the AGENT can drive mid-task without
+// a CLI round-trip, and it must pay the read+embed cost ONCE per document rather
+// than re-reading the file into context every turn. This tool is that surface:
+// `add` ingests under a tag (documents are extracted, chunked, embedded once),
+// `query` returns the tag's top-k chunks with their source files so the model can
+// answer the data half from the user's data and the generic half from its own
+// knowledge / web-research.
+registerTool({
+    name: 'knowledge',
+    description: 'Answer questions from the USER\'S OWN tagged documents. `add` ingests files/folders under a tag '
+        + '(extract → chunk → embed, done once); `query` retrieves the tag\'s most relevant passages, labeled '
+        + 'with their source file, so the data part of an answer comes from the user\'s data and the general '
+        + 'part from model knowledge or web-research. Use this instead of re-reading a large document on every '
+        + 'turn. Actions: add | query | list | forget | stats. Tags are normalized (spaces/capitals/underscores '
+        + 'become lowercase-hyphen), e.g. "Dheeraj health report" → "dheeraj-health-report".',
+    category: 'workflow',
+    inputSchema: z.object({
+        action: z.enum(['add', 'query', 'list', 'forget', 'stats']).describe('Action'),
+        tag: z.string().optional().describe('Tag/hashtag scoping the data (e.g. "dheeraj-health-report")'),
+        paths: z.array(z.string()).optional().describe('Files or folders to ingest (action: add)'),
+        question: z.string().optional().describe('Question to answer from the tagged data (action: query)'),
+        topK: z.number().optional().describe('Chunks to retrieve (action: query, default 6)'),
+    }),
+    endsAgentStep: false,
+    run: (args) => import('../learning/knowledge-base.js').then(async (m) => {
+        const { action, tag, paths, question, topK } = args;
+        switch (action) {
+            case 'add': {
+                if (!tag)
+                    return 'tag is required for action: add';
+                if (!paths || paths.length === 0)
+                    return 'paths is required for action: add';
+                const result = await m.ingestKnowledge(tag, paths);
+                const skipped = result.skipped.length
+                    ? `\nSkipped: ${result.skipped.map((s) => `${s.path} (${s.reason})`).join('; ')}`
+                    : '';
+                return `✅ Ingested ${result.files} document(s) / ${result.chunks} chunk(s) under tag '${result.tag}'.`
+                    + `\nQuery it with action: query, tag: '${result.tag}'.${skipped}`;
+            }
+            case 'query': {
+                if (!tag)
+                    return 'tag is required for action: query';
+                if (!question)
+                    return 'question is required for action: query';
+                const hits = await m.queryKnowledge(tag, question, { topK });
+                return m.formatKnowledgeContext(tag, hits);
+            }
+            case 'list': {
+                const tags = m.listKnowledgeTags();
+                if (tags.length === 0)
+                    return 'No knowledge tags yet. Ingest documents with action: add.';
+                return tags
+                    .map((t) => `  • ${t.tag} — ${t.chunkCount} chunk(s) across ${t.documents.length} document(s)`)
+                    .join('\n');
+            }
+            case 'forget': {
+                if (!tag)
+                    return 'tag is required for action: forget';
+                const removed = await m.forgetKnowledgeTag(tag);
+                return removed ? `🗑️ Removed knowledge tag '${m.normalizeKnowledgeTag(tag)}'.` : `No knowledge tag '${tag}' found.`;
+            }
+            case 'stats': {
+                if (!tag)
+                    return 'tag is required for action: stats';
+                const entry = m.getKnowledgeTag(tag);
+                if (!entry)
+                    return `No knowledge tag '${tag}' found.`;
+                return JSON.stringify(entry);
+            }
+            default:
+                return `Unknown action '${action}'`;
+        }
+    }),
+});
 // Credential Files — Credential file management
 registerTool({
     name: 'credential_files',