@inflexa-ai/harness 0.44.0 → 0.45.0

package/dist/tasks/data-profile.js

@@ -296,7 +296,7 @@ export async function runDataProfileBody(input, deps) {
     // ledger has no suspended state and the retry path takes a `failed` row again.
     const suspendProfile = async (suspension) => {
         logger.warn("profile suspended", { reason: suspension.reason });
-        settleTerminalWrite(logger, analysisId, unwrapOrThrow(await failDataProfile(deps.pool, analysisId, suspension.reason)), "failed");
+        await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await failDataProfile(deps.pool, analysisId, suspension.reason)), "failed", deps.notifyDataProfileSettled);
         await revoke("data-profile-suspended");
         unwrapOrThrow(await suspendAnalysis(deps.pool, analysisId));
         await activity.failed(suspension.reason);
@@ -310,7 +310,7 @@ export async function runDataProfileBody(input, deps) {
     // this capability, and a body that composed its own strings is a body they can drift from.
     // The frame is the workflow's synthetic one: both values are constants shared by every analysis,
     // so they identify nothing and consumers are required not to key on them.
-    const activity = createProfileActivityEmitter((part) => DBOS.writeStream("events", part), { runId: DATA_PROFILE_RUN_LITERAL, stepId: DATA_PROFILE_STEP_LITERAL }, logger);
+    const activity = createProfileActivityEmitter((part) => DBOS.writeStream("events", part), { runId: DATA_PROFILE_RUN_LITERAL, stepId: DATA_PROFILE_STEP_LITERAL }, logger, () => DBOS.now());
     try {
         // Record which workflow owns this profile before anything else, so a consumer that resolves
         // the id from the ledger can subscribe from the earliest possible moment. Guarded on a real
@@ -337,7 +337,7 @@ export async function runDataProfileBody(input, deps) {
             // catalogue's fit is measured, and a completion that emitted none would make the
             // empty-manifest path invisible to the same monitoring that watches every other.
             logProfileMonitoring(logger, { dimensions: [], probes: [], repairRounds: 0, absorb: "none" });
-            settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId)), "completed");
+            await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId)), "completed", deps.notifyDataProfileSettled);
             await revoke("data-profile-completed");
             // This is a terminal completion like any other, so it reports one — a consumer watching
             // an empty-manifest profile sees it settle rather than seeing the stream simply stop.
@@ -390,7 +390,7 @@ export async function runDataProfileBody(input, deps) {
             await activity.indexing();
             await indexProfile({ deps, analysisId, session: runSession, record, scan, logger });
             logProfileMonitoring(logger, { resolution, dimensions: [], probes: [], repairRounds: 0, absorb: "none" });
-            settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, record)), "completed");
+            await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, record)), "completed", deps.notifyDataProfileSettled);
             await revoke("data-profile-completed");
             await activity.complete();
             return;
@@ -416,7 +416,7 @@ export async function runDataProfileBody(input, deps) {
                 repairRounds: 0,
                 absorb: absorb.kind,
             });
-            settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, absorbed)), "completed");
+            await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, absorbed)), "completed", deps.notifyDataProfileSettled);
             await revoke("data-profile-completed");
             await activity.complete();
             return;
@@ -571,7 +571,7 @@ export async function runDataProfileBody(input, deps) {
             });
             // 6. Complete — store the FULL profiler finding plus the input signature for
             // staleness detection. The scratch tree is gone; this row is all that survives.
-            settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, profileRecord)), "completed");
+            await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, profileRecord)), "completed", deps.notifyDataProfileSettled);
             await revoke("data-profile-completed");
             // LAST statement of the success path, and that placement is the guarantee that exactly
             // one terminal activity is ever emitted. Everything that could still throw — the ledger
@@ -598,7 +598,7 @@ export async function runDataProfileBody(input, deps) {
             return await suspendProfile(suspension);
         logger.error("profile failed", logger.errorFields(err));
         const reason = profileFailureReason(err);
-        settleTerminalWrite(logger, analysisId, unwrapOrThrow(await failDataProfile(deps.pool, analysisId, reason)), "failed");
+        await settleTerminalWrite(logger, analysisId, unwrapOrThrow(await failDataProfile(deps.pool, analysisId, reason)), "failed", deps.notifyDataProfileSettled);
         await revoke("data-profile-failed");
         // The same bounded, user-safe line the ledger receives — never the raw error, whose paths and
         // stack frames stay in the log record above. This is the only other terminal emission, so
@@ -617,18 +617,23 @@ function logTerminalNoop(logger, analysisId, write) {
 }
 /**
  * Settle one terminal write of the profile ledger. A refused stamp is logged
- * (see `logTerminalNoop`). An accepted stamp records the profile's run outcome:
- * the CAS admits one write per `running` claim, so this is the exactly-once
+ * (see `logTerminalNoop`) and sends no notice. An accepted stamp records the
+ * profile's run outcome and then delivers the settle notice when the deps bind
+ * one: the CAS admits one write per `running` claim, so this is the exactly-once
  * point of the transition — a recovery replay of the body finds the row no
- * longer `running`, and records nothing again. The duration runs from the
+ * longer `running`, and does neither again. The duration runs from the
  * `data_profile_started_at` the claim stamped, never from a body-local clock.
+ * A crash between the stamp and the notice loses that one notice.
  */
-function settleTerminalWrite(logger, analysisId, write, status) {
+async function settleTerminalWrite(logger, analysisId, write, status, notify) {
     if (!write.stamped) {
         logTerminalNoop(logger, analysisId, status === "completed" ? "completion" : "failure");
         return;
     }
     recordRunCompleted({ workflow: "data_profile", status, durationMs: elapsedSinceIso(write.startedAt) });
+    if (notify === undefined)
+        return;
+    await deliverNotice(logger, "notifyDataProfileSettled", notify({ analysisId, status, completedAt: write.completedAt }));
 }
 /** A one-line, user-facing description of a `DataProfileStartError`. */
 export function describeDataProfileStartError(e) {

package/dist/tools/approval/gateway.js

@@ -40,8 +40,11 @@ export function createAskGateway(deps) {
         // A standing grant this user holds 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.
+        // The one part it emits is already settled, so no surface prompts, and the
+        // transcript still shows that a standing grant approved the call.
         if (unwrapOrThrow(await selectGrant(pool, ctx.analysisId, ctx.userId, request.grantKey ?? request.command))) {
             unwrapOrThrow(await insertGrantedAsk(pool, row, now));
+            await emitAskPart(ctx.emit, id, request, "resolved", "always");
             return { kind: "always" };
         }
         unwrapOrThrow(await insertPendingAsk(pool, row));
@@ -69,7 +72,7 @@ export function createAskGateway(deps) {
                 throw new AskRejectedError("approval request is no longer available");
             }
             if (resolution.status !== "pending") {
-                await emitAskPart(ctx.emit, id, request, resolution.status);
+                await emitAskPart(ctx.emit, id, request, resolution.status, replyKindOf(resolution.status, resolution.reply));
                 return settle(resolution.status, resolution.reply, ctx.signal);
             }
             await sleepUntil(POLL_INTERVAL_MS, ctx.signal);
@@ -88,7 +91,7 @@ export function createAskGateway(deps) {
     return { ask, answer, pending, sweepExpired };
 }
 /** Emit (or reconcile, under the same id) the ask's `data-ask` chat part. */
-function emitAskPart(emit, id, request, status) {
+function emitAskPart(emit, id, request, status, reply) {
     return emit({
         type: "data-ask",
         data: {
@@ -97,16 +100,36 @@ function emitAskPart(emit, id, request, status) {
             command: request.command,
             ...(request.detail !== undefined ? { detail: request.detail } : {}),
             status,
+            ...(reply !== undefined ? { reply } : {}),
         },
     });
 }
+/**
+ * The kind of reply the terminal part shows: the kind that `settle` acts on for a `resolved` or `rejected` row,
+ * and none for any other status. It never reads the feedback of a rejection, which is for the model.
+ */
+function replyKindOf(status, reply) {
+    switch (status) {
+        case "resolved":
+            return approvalOf(reply).kind;
+        case "rejected":
+            return "reject";
+        case "expired":
+        case "aborted":
+            return undefined;
+    }
+}
+/** The approval that a `resolved` row grants. */
+function approvalOf(reply) {
+    // Only `once` / `always` reach `resolved`; guard the JSONB round-trip and
+    // default to the narrowest approval if a malformed reply ever slipped in.
+    return reply && (reply.kind === "once" || reply.kind === "always") ? reply : { kind: "once" };
+}
 /** Resolve an approval or throw the terminal denial the ledger recorded. */
 function settle(status, reply, signal) {
     switch (status) {
         case "resolved":
-            // Only `once` / `always` reach `resolved`; guard the JSONB round-trip and
-            // default to the narrowest approval if a malformed reply ever slipped in.
-            return reply && (reply.kind === "once" || reply.kind === "always") ? reply : { kind: "once" };
+            return approvalOf(reply);
         case "rejected":
             throw new AskRejectedError(reply && reply.kind === "reject" ? reply.feedback : undefined);
         case "expired":

package/dist/tools/display/show-user.d.ts

@@ -26,7 +26,7 @@ type ShowUserOutput = {
     id: string;
 };
 export declare const showUserTool: import("../define-tool.js").Tool<{
-    kind: "code" | "markdown" | "echart" | "svg" | "table" | "structure";
+    kind: "code" | "echart" | "markdown" | "svg" | "table" | "structure";
     title?: string | undefined;
     spec?: Record<string, unknown> | undefined;
     dataPath?: string | undefined;

package/dist/tools/execute-analysis.d.ts

@@ -2,7 +2,9 @@
  * Unified async edge for approved plans and explicitly requested one-step ad
  * hoc analyses. Both modes launch the ordinary executeAnalysis workflow.
  */
+import { ResultAsync } from "neverthrow";
 import type { Pool } from "pg";
+import type { AgentSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { EnvironmentStorePaths } from "../config/environment-stores.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -54,7 +56,56 @@ export declare class PlanPackagesMissingError extends Error {
     readonly unavailable?: string | undefined;
     constructor(missing: string[], collisions: string[], unavailable?: string | undefined);
 }
+/** The deps that start the run of a stored plan. */
+export type LaunchPlanRunDeps = Pick<ExecuteAnalysisToolDeps, "pool" | "executeAnalysisWorkflow" | "runAuthorizer" | "runLauncher" | "resourcePolicy" | "extendAnalysisFarm" | "logger">;
+/** The run of a stored plan. `started` is false when a run of the plan was already active. */
+export type PlanLaunch = {
+    runId: string;
+    started: boolean;
+};
+/**
+ * Why a stored plan did not start a run. `store_failed.cause` and `launch_failed.cause` are the
+ * values as the failing call gave them, thus a caller that must throw them keeps their class.
+ */
+export type LaunchPlanRunRefusal = {
+    type: "plan_not_found";
+    planId: string;
+} | {
+    type: "plan_invalid";
+    planId: string;
+    malformed: boolean;
+    errors: string[];
+} | {
+    type: "packages_missing";
+    missing: string[];
+    collisions: string[];
+    unavailable?: string;
+} | {
+    type: "not_authorized";
+    reason: string;
+} | {
+    type: "suspended";
+    reason: string;
+} | {
+    type: "store_failed";
+    cause: unknown;
+} | {
+    type: "launch_failed";
+    cause: unknown;
+};
 export declare function buildAdHocPlan(request: string, route: AdHocRoute, createdAt?: string): AnalysisPlan;
+/**
+ * Start the run of a stored plan. It reads the plan under the analysis of the session, validates it,
+ * links its packages, reserves a run, authorizes it, and starts the workflow. It gives the run id, or
+ * the refusal, and it emits no chat part. `started` is false when a run of the plan was already active.
+ *
+ * This is an API boundary: a host calls it outside a tool body, thus no outcome above rejects the
+ * promise.
+ */
+export declare function launchPlanRun(deps: LaunchPlanRunDeps, input: {
+    session: AgentSession;
+    planId: string;
+}): ResultAsync<PlanLaunch, LaunchPlanRunRefusal>;
 export declare function createExecuteAnalysisTool(deps: ExecuteAnalysisToolDeps): import("./define-tool.js").Tool<{
     mode: "plan" | "adhoc";
     planId?: string | undefined;