@inflexa-ai/harness 0.5.0 → 0.6.0

package/dist/agents/conversation-agent.d.ts

@@ -34,6 +34,7 @@ import type { ResourcePolicy } from "../config/resource-limits.js";
 import type { ChromeConfig } from "../lib/chrome.js";
 import type { AgentDefinition } from "../loop/types.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
+import type { Tool } from "../tools/define-tool.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type BioToolKeys } from "../tools/bio/keys.js";
@@ -104,6 +105,13 @@ export interface ConversationAgentDeps {
      * planning guidance and scheduling keep their legacy behavior.
      */
     readonly resourcePolicy?: ResourcePolicy;
+    /**
+     * Embedder-contributed conversation-tool seam — additional tools the host
+     * supplies, appended after the built-in roster. The harness stays agnostic to
+     * what they do; each receives the same `ToolContext` (including `ask`) as any
+     * built-in tool.
+     */
+    readonly hostTools?: readonly Tool[];
 }
 /** Build the conversation `AgentDefinition` with every tool fully dep-bound. */
 export declare function createConversationAgent(deps: ConversationAgentDeps): AgentDefinition;

package/dist/agents/conversation-agent.js

@@ -48,7 +48,7 @@ export const CONVERSATION_AGENT_ID = "conversation-agent";
 const CONVERSATION_MAX_ITERATIONS = 50;
 /** Build the conversation `AgentDefinition` with every tool fully dep-bound. */
 export function createConversationAgent(deps) {
-    const { provider, pool, embedding, workspaceFs, model, executeAnalysisWorkflow, ephemeralWorkflow, resolveWorkspaceRoot, runAuthorizer, runLauncher, createPreviewPublisher, bioKeys, templatesDir, skillsDir, chrome, resourcePolicy, } = deps;
+    const { provider, pool, embedding, workspaceFs, model, executeAnalysisWorkflow, ephemeralWorkflow, resolveWorkspaceRoot, runAuthorizer, runLauncher, createPreviewPublisher, bioKeys, templatesDir, skillsDir, chrome, resourcePolicy, hostTools, } = deps;
     const workingMemory = createWorkingMemory(pool);
     const ncbi = createNcbiTools(bioKeys);
     const chemDb = createChemDbTools(bioKeys);
@@ -126,6 +126,9 @@ export function createConversationAgent(deps) {
         createGrepTool(workspaceFs),
         // Working memory.
         createUpdateWorkingMemoryTool(workingMemory, pool),
+        // Host-contributed tools ride the same context and dispatch path as the
+        // built-ins; appended last so the built-in roster order stays fixed.
+        ...(hostTools ?? []),
     ];
     return {
         id: CONVERSATION_AGENT_ID,

package/dist/state/init.js

@@ -260,6 +260,11 @@ CREATE TABLE IF NOT EXISTS cortex_asks (
   title        TEXT NOT NULL,
   command      TEXT NOT NULL,
   detail       TEXT,
+  -- The key the standing grant behind an 'always' is recorded under: the displayed
+  -- command unless the tool supplied a broader grant key. Written on every insert,
+  -- defaulting to the command when absent. Nullable only so the additive migration
+  -- can add it to an already-created table without a per-row backfill.
+  grant_key    TEXT,
   status       TEXT NOT NULL,
   reply        JSONB,
   created_at   TEXT NOT NULL,
@@ -275,14 +280,15 @@ CREATE INDEX IF NOT EXISTS idx_cortex_asks_pending
   ON cortex_asks(status) WHERE status = 'pending';
 
 -- Standing approval grants behind an 'always' reply — keyed by the analysis and
--- the exact command string the user approved, so a later matching ask
--- auto-approves without pausing. Lives for the analysis lifecycle, surviving
--- process restarts, and never applies to another analysis.
+-- the ask's grant key (the displayed command when the tool supplied no broader
+-- key), so a later matching ask auto-approves without pausing. Lives for the
+-- analysis lifecycle, surviving process restarts, and never applies to another
+-- analysis.
 CREATE TABLE IF NOT EXISTS cortex_ask_grants (
   analysis_id  TEXT NOT NULL,
-  command      TEXT NOT NULL,
+  grant_key    TEXT NOT NULL,
   created_at   TEXT NOT NULL,
-  PRIMARY KEY (analysis_id, command)
+  PRIMARY KEY (analysis_id, grant_key)
 );
 `;
 /**
@@ -406,6 +412,26 @@ export async function initCortexState(pool, injected) {
                 // dropping an absent NOT NULL no-ops, so this is a no-op on fresh DBs.
                 "ALTER TABLE cortex_analysis_state ALTER COLUMN data_profile_status DROP NOT NULL",
                 "ALTER TABLE messages ADD COLUMN IF NOT EXISTS message_envelope JSONB",
+                // Grant key an 'always' records the standing grant under. Nullable
+                // and unbackfilled: every new row writes it (command when absent), and
+                // orphaned legacy pending rows are swept to 'expired' before any answer
+                // reads it, so no existing row is left needing a value.
+                "ALTER TABLE cortex_asks ADD COLUMN IF NOT EXISTS grant_key TEXT",
+                // The grants table's key column is named for what it stores. A table
+                // created when the column was `command` is renamed in place — its
+                // values carry over unchanged, because a grant recorded without a
+                // grant key is keyed on its exact command. Guarded via
+                // information_schema (Postgres has no RENAME COLUMN IF EXISTS) and
+                // scoped to current_schema() so parallel test schemas in the same
+                // database never trigger each other's rename.
+                `DO $$ BEGIN
+                  IF EXISTS (
+                    SELECT 1 FROM information_schema.columns
+                    WHERE table_schema = current_schema() AND table_name = 'cortex_ask_grants' AND column_name = 'command'
+                  ) THEN
+                    ALTER TABLE cortex_ask_grants RENAME COLUMN command TO grant_key;
+                  END IF;
+                END $$`,
             ];
             for (const sql of addMigrations) {
                 await client.query(sql);

package/dist/tools/approval/contract.d.ts

@@ -21,6 +21,14 @@ export interface AskRequest {
     readonly title: string;
     readonly command: string;
     readonly detail?: string;
+    /**
+     * Keys the standing grant an `always` records when the class being blessed is
+     * broader than the displayed `command` — a tool that grants a whole family of
+     * operations passes the family's key here while still showing one concrete
+     * command. It is a generic, opaque key string, not a tool- or domain-specific
+     * field, and the surface never renders it. Absent, the grant keys on `command`.
+     */
+    readonly grantKey?: string;
 }
 /**
  * A user's decision on an approval request — three distinct outcomes, never a

package/dist/tools/approval/gateway.js

@@ -27,11 +27,13 @@ export function createAskGateway(deps) {
             title: request.title,
             command: request.command,
             detail: request.detail ?? null,
+            grantKey: request.grantKey ?? null,
             createdAt: now,
         };
-        // A standing grant for this exact command short-circuits the prompt: record
-        // the invocation as `resolved` for the audit trail and return without pausing.
-        if (unwrapOrThrow(await selectGrant(pool, ctx.analysisId, request.command))) {
+        // A standing grant for this ask's grant key — the command unless the tool
+        // supplied a broader key — short-circuits the prompt: record the invocation as
+        // `resolved` for the audit trail and return without pausing.
+        if (unwrapOrThrow(await selectGrant(pool, ctx.analysisId, request.grantKey ?? request.command))) {
             unwrapOrThrow(await insertGrantedAsk(pool, row, now));
             return { kind: "always" };
         }

package/dist/tools/approval/queries.d.ts

@@ -40,6 +40,8 @@ export interface AskRow {
     readonly title: string;
     readonly command: string;
     readonly detail: string | null;
+    /** Grant key an `always` keys its standing grant under; `null` falls back to `command`. */
+    readonly grantKey: string | null;
     readonly createdAt: string;
 }
 /** Insert a fresh `pending` ask before its decision is awaited. */
@@ -50,8 +52,8 @@ export declare function insertPendingAsk(querier: Querier, row: AskRow): ResultA
  * every approval-gated action. The recorded reply is `{ kind: "always" }`.
  */
 export declare function insertGrantedAsk(querier: Querier, row: AskRow, resolvedAt: string): ResultAsync<void, DbError>;
-/** Does a standing grant cover `(analysisId, command)` in this analysis? */
-export declare function selectGrant(querier: Querier, analysisId: string, command: string): ResultAsync<boolean, DbError>;
+/** Does a standing grant cover `(analysisId, grantKey)` in this analysis? */
+export declare function selectGrant(querier: Querier, analysisId: string, grantKey: string): ResultAsync<boolean, DbError>;
 /** Read a row's current status + recorded reply. `null` when no such row exists. */
 export declare function selectAskResolution(querier: Querier, id: string): ResultAsync<AskResolution | null, DbError>;
 /**

package/dist/tools/approval/queries.js

@@ -15,9 +15,9 @@ export function insertPendingAsk(querier, row) {
     return tryMutation("asks.insertPending", async () => {
         await querier.query({
             text: `INSERT INTO cortex_asks
-              (id, analysis_id, thread_id, title, command, detail, status, created_at)
-              VALUES ($1, $2, $3, $4, $5, $6, 'pending', $7)`,
-            values: [row.id, row.analysisId, row.threadId, row.title, row.command, row.detail, row.createdAt],
+              (id, analysis_id, thread_id, title, command, detail, grant_key, status, created_at)
+              VALUES ($1, $2, $3, $4, $5, $6, $7, 'pending', $8)`,
+            values: [row.id, row.analysisId, row.threadId, row.title, row.command, row.detail, row.grantKey ?? row.command, row.createdAt],
         });
     });
 }
@@ -30,18 +30,29 @@ export function insertGrantedAsk(querier, row, resolvedAt) {
     return tryMutation("asks.insertGranted", async () => {
         await querier.query({
             text: `INSERT INTO cortex_asks
-              (id, analysis_id, thread_id, title, command, detail, status, reply, created_at, resolved_at)
-              VALUES ($1, $2, $3, $4, $5, $6, 'resolved', $7::jsonb, $8, $9)`,
-            values: [row.id, row.analysisId, row.threadId, row.title, row.command, row.detail, JSON.stringify({ kind: "always" }), row.createdAt, resolvedAt],
+              (id, analysis_id, thread_id, title, command, detail, grant_key, status, reply, created_at, resolved_at)
+              VALUES ($1, $2, $3, $4, $5, $6, $7, 'resolved', $8::jsonb, $9, $10)`,
+            values: [
+                row.id,
+                row.analysisId,
+                row.threadId,
+                row.title,
+                row.command,
+                row.detail,
+                row.grantKey ?? row.command,
+                JSON.stringify({ kind: "always" }),
+                row.createdAt,
+                resolvedAt,
+            ],
         });
     });
 }
-/** Does a standing grant cover `(analysisId, command)` in this analysis? */
-export function selectGrant(querier, analysisId, command) {
+/** Does a standing grant cover `(analysisId, grantKey)` in this analysis? */
+export function selectGrant(querier, analysisId, grantKey) {
     return tryQuery("asks.selectGrant", async () => {
         const result = await querier.query({
-            text: `SELECT 1 FROM cortex_ask_grants WHERE analysis_id = $1 AND command = $2`,
-            values: [analysisId, command],
+            text: `SELECT 1 FROM cortex_ask_grants WHERE analysis_id = $1 AND grant_key = $2`,
+            values: [analysisId, grantKey],
         });
         return (result.rowCount ?? 0) > 0;
     });
@@ -114,19 +125,23 @@ export function answerAsk(pool, id, reply, now) {
     return withTransaction(pool, "asks.answer", (client) => tryMutation("asks.answer:update", () => client.query({
         text: `UPDATE cortex_asks SET status = $1, reply = $2::jsonb, resolved_at = $3
                   WHERE id = $4 AND status = 'pending'
-                  RETURNING analysis_id, command`,
+                  RETURNING analysis_id, COALESCE(grant_key, command) AS grant_key`,
         values: [status, JSON.stringify(reply), now, id],
     })).andThen((updated) => {
         if ((updated.rowCount ?? 0) === 0)
             return discriminateMiss(client, id);
         if (reply.kind !== "always")
             return okAsync("applied");
+        // The cast's non-null `grant_key` is sound without any boot-order
+        // caveat: every insert writes grant_key (command when the tool supplied
+        // none), and the COALESCE above covers any pending row that predates
+        // the column — `command` is NOT NULL, so the key can never be null.
         const granted = updated.rows[0];
         return tryMutation("asks.answer:grant", async () => {
             await client.query({
-                text: `INSERT INTO cortex_ask_grants (analysis_id, command, created_at)
-                      VALUES ($1, $2, $3) ON CONFLICT (analysis_id, command) DO NOTHING`,
-                values: [granted.analysis_id, granted.command, now],
+                text: `INSERT INTO cortex_ask_grants (analysis_id, grant_key, created_at)
+                      VALUES ($1, $2, $3) ON CONFLICT (analysis_id, grant_key) DO NOTHING`,
+                values: [granted.analysis_id, granted.grant_key, now],
             });
         }).map(() => "applied");
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.5.0",
+    "version": "0.6.0",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",