deepline 0.2.53 → 0.2.55

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -14,6 +14,8 @@ import {
   normalizePlayRunLifecycleStatus,
   type PlayRunLifecycleStatus,
 } from './run-lifecycle-policy';
+import type { PlayDocflowNodeIoState } from './docflow-node-io';
+import type { PlayVisualNodeUsageSnapshot } from './live-state-contract';
 import {
   projectPlayRunActivity,
   type PlayActivityObservation,
@@ -46,6 +48,7 @@ export type PlayRunStreamNodeProgress = {
   startedAt?: number | null;
   completedAt?: number | null;
   artifactTableNamespace?: string | null;
+  nodeIo?: PlayDocflowNodeIoState;
 };
 
 export type PlayRunStreamNodeState = {
@@ -57,6 +60,13 @@ export type PlayRunStreamNodeState = {
   startedAt?: number | null;
   completedAt?: number | null;
   updatedAt?: number | null;
+  nodeIo?: PlayDocflowNodeIoState;
+  /**
+   * Observed provider usage (ADR 0018). Attached by the read path, not by the
+   * ledger projection — settlement lags finalize, so this is always computed
+   * at read time.
+   */
+  usage?: PlayVisualNodeUsageSnapshot;
 };
 
 export type PlayRunLiveSnapshot = {
@@ -202,11 +212,13 @@ function buildSnapshotFromLedger(
             startedAt: step.startedAt ?? null,
             completedAt: step.completedAt ?? null,
             updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null,
+            nodeIo: step.progress.nodeIo,
           }
         : null,
       startedAt: step.startedAt ?? null,
       completedAt: step.completedAt ?? null,
       updatedAt: step.updatedAt ?? null,
+      ...(step.progress?.nodeIo ? { nodeIo: step.progress.nodeIo } : {}),
     }));
   const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
   // Only surface the row-outcome aggregate once the run is terminal and it

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/local-process.ts

@@ -91,11 +91,29 @@ async function runCommand(
       return;
     }
 
+    // POSIX: run the command as its own process-group leader so cancellation
+    // can signal the entire tree. The watchdog child spawns the runner (which
+    // may spawn further descendants) with inherited stdio; killing only the
+    // direct child leaves orphans holding our pipes and 'close' never fires.
+    const useProcessGroup = process.platform !== 'win32';
     const child = spawn(command, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
+      detached: useProcessGroup,
       ...options,
     });
 
+    const killTree = (signal: NodeJS.Signals) => {
+      if (useProcessGroup && child.pid) {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+          // Group already gone or not yet created — fall through.
+        }
+      }
+      child.kill(signal);
+    };
+
     let stderr = '';
     let stdoutBuffer = '';
     let stdoutLineCount = 0;
@@ -142,11 +160,15 @@ async function runCommand(
         typeof reason === 'string' && reason.trim()
           ? reason.trim()
           : LOCAL_PROCESS_CANCELLED_ERROR;
-      child.kill('SIGTERM');
+      killTree('SIGTERM');
       cancelKillTimer = setTimeout(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-          child.kill('SIGKILL');
-        }
+        // Kill the whole group even if the direct child already exited: a
+        // descendant may have survived it and still hold our stdio pipes.
+        killTree('SIGKILL');
+        // Backstop: release our read ends so 'close' can fire even if some
+        // descendant escaped the group (e.g. via setsid) and never dies.
+        child.stdout?.destroy();
+        child.stderr?.destroy();
       }, LOCAL_PROCESS_CANCEL_GRACE_MS);
       cancelKillTimer.unref?.();
     }

package/dist/bundling-sources/shared_libs/play-runtime/runtime-actions.ts

@@ -5,6 +5,7 @@ import type { PlaySheetContract } from '../plays/static-pipeline';
 import type { PlayRunLedgerEvent } from './run-ledger';
 import type { WorkReceiptFailureKind } from './work-receipts';
 import type { ToolExecutionFailureV1 } from '../tool-execution-error';
+import type { DocflowObservationUpsert } from './docflow-observation';
 
 export type RuntimeAppendRunEventsAction = {
   action: 'append_run_events';
@@ -218,7 +219,11 @@ export type RuntimeReceiptAction =
       leaseId?: string;
       leaseIds?: string[];
       keys: string[];
-    };
+    }
+  | ({
+      action: 'observe_docflow_node';
+      playName: string;
+    } & DocflowObservationUpsert);
 
 export type RuntimeReceiptLease = {
   key: string;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -8118,6 +8118,89 @@ export async function readRuntimeSheetDatasetRowKeys(
   return { keys: rows.map((row) => row._key) };
 }
 
+export type RuntimeSheetRowOutcomeCounts = {
+  completed: number;
+  failed: number;
+  total: number;
+};
+
+/**
+ * Count settled row outcomes for one physical runtime sheet (ADR 0016 rule 3).
+ *
+ * The sheet rows ARE the data plane: `_status = 'enriched'` is a durably
+ * persisted success, `'failed'` a settled row failure, and everything except
+ * `'stale'` counts toward the denominator. Split from the session wrapper so
+ * the counting SQL runs identically against a test PGlite client and a
+ * production tenant runtime Postgres.
+ */
+export async function countRuntimeSheetRowOutcomes(
+  client: {
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(
+      sql: string,
+      params?: unknown[],
+    ): Promise<{ rows: Row[] }>;
+  },
+  input: { schema: string; table: string; runId: string },
+): Promise<RuntimeSheetRowOutcomeCounts> {
+  const { rows } = await client.query<{
+    completed: number | string;
+    failed: number | string;
+    total: number | string;
+  }>(
+    `SELECT
+       count(*) FILTER (WHERE _status = 'enriched')::int AS completed,
+       count(*) FILTER (WHERE _status = 'failed')::int AS failed,
+       count(*) FILTER (WHERE _status <> 'stale')::int AS total
+     FROM ${quoteIdentifier(input.schema)}.${quoteIdentifier(input.table)}
+     WHERE _run_id = $1::text`,
+    [input.runId],
+  );
+  const row = rows[0];
+  return {
+    completed: Math.max(0, Number(row?.completed ?? 0) || 0),
+    failed: Math.max(0, Number(row?.failed ?? 0) || 0),
+    total: Math.max(0, Number(row?.total ?? 0) || 0),
+  };
+}
+
+/**
+ * Read the settled row-outcome counts for a dataset's runtime sheet through the
+ * run's preloaded DB session. Used by the scheduler worker at terminal finalize
+ * as the reconciliation of record for per-map progress: sheet counts exist
+ * regardless of runner mode (in-worker, detached Daytona push), unlike
+ * checkpoint map frames or streamed events. Requires a direct session strategy
+ * (`preloaded`/`trusted_dynamic`); there is deliberately no gateway action —
+ * the worker holds the launch's preloaded sessions itself.
+ */
+export async function readRuntimeSheetRowOutcomeCounts(
+  context: RuntimeApiContext & { playName: string; runId: string },
+  input: { tableNamespace: string },
+): Promise<RuntimeSheetRowOutcomeCounts> {
+  if (context.dbSessionStrategy === 'gateway_only') {
+    throw new Error(
+      'readRuntimeSheetRowOutcomeCounts requires a direct DB session strategy.',
+    );
+  }
+  const session = requireRuntimePostgresSession(
+    await getRuntimeDbSession(
+      { ...context, playName: context.playName },
+      {
+        tableNamespace: input.tableNamespace,
+        logicalTable: 'sheet_rows',
+        operations: ['rows.read'],
+        limits: { maxRows: runtimeDbSessionRowLimit(1) },
+      },
+    ),
+  );
+  return await withRuntimePostgres(session, (client) =>
+    countRuntimeSheetRowOutcomes(client, {
+      schema: session.postgres.schema,
+      table: session.postgres.sheetTable,
+      runId: context.runId,
+    }),
+  );
+}
+
 export async function persistRuntimeCsvDataset(
   context: RuntimeApiContext & { playName: string },
   input: {

package/dist/bundling-sources/shared_libs/play-runtime/worker-api-types.ts

@@ -1,3 +1,5 @@
+import type { PlayDocflowNodeIoState } from './docflow-node-io';
+
 export type PlayStagedFileRef = {
   storageKind: 'r2';
   storageKey: string;
@@ -21,6 +23,7 @@ export type PlayVisualNodeProgress = {
   startedAt?: number;
   completedAt?: number;
   artifactTableNamespace?: string | null;
+  nodeIo?: PlayDocflowNodeIoState;
 };
 
 export type PlayVisualNodeProgressMap = Record<string, PlayVisualNodeProgress>;

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -71,6 +71,28 @@ export const PLAY_AUTHORING_CONTRACT_ISSUE_CODES = [
   'play_authoring_fetch_key_reused_in_loop',
   'play_authoring_binding_invalid',
   'play_authoring_input_schema_unresolved',
+  'check_error',
+  'docflow_compile_error',
+  'docflow_binding_drift',
+  'docflow_branch_labels_required',
+  'docflow_branch_requires_decision',
+  'docflow_direction_not_top_down',
+  'docflow_directive_ignored',
+  'docflow_dataset_unrepresented',
+  'docflow_loop_ambiguous',
+  'docflow_loop_foreign_step',
+  'docflow_loop_incomplete',
+  'docflow_dataset_column_undrawn',
+  'docflow_undrawn_declaration_invalid',
+  'docflow_layout_complexity',
+  'docflow_topology_invalid',
+  'docflow_io_ambiguous',
+  'docflow_input_not_found',
+  'docflow_output_not_found',
+  'docflow_label_counts_rows',
+  'docflow_node_kind_unsupported',
+  'docflow_child_play_undrawn',
+  'docflow_waterfall_region_invalid',
 ] as const;
 
 export type PlayAuthoringContractIssueCode =
@@ -572,6 +594,13 @@ export type PlayAuthoringDatasetRunOptions<InputRow extends object> = {
   key?: PlayAuthoringDatasetRowKey<InputRow>;
   onRowError?: 'isolate' | 'fail';
   mode?: 'upsert' | 'net_new';
+  /**
+   * Computed columns this dataset produces that the authored `@mermaid`
+   * diagram deliberately does not draw. A diagrammed Play must account for
+   * every column it computes: draw it inside the dataset's `subgraph` loop
+   * region, or name it here. Nothing else opts a column out.
+   */
+  undrawnColumns?: readonly string[];
 };
 
 export const PLAY_AUTHORING_DATASET_RUN_OPTION_FIELDS = [
@@ -579,6 +608,7 @@ export const PLAY_AUTHORING_DATASET_RUN_OPTION_FIELDS = [
   'key',
   'onRowError',
   'mode',
+  'undrawnColumns',
 ] as const;
 
 export type PlayAuthoringDatasetBuilder<
@@ -1711,6 +1741,24 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
       'Whether the dataset returns all rows or only newly admitted rows.',
     errorMessage: 'ctx.dataset run mode must be "upsert" or "net_new".',
   },
+  'ctx.dataset.run.undrawnColumns': {
+    schema: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    fixtures: {
+      valid: ['miss_reason'],
+      invalid: [],
+      absent: undefined,
+      unresolved: { expression: 'undrawnColumns' },
+      edition1: ['miss_reason'],
+    },
+    referenceType: 'readonly string[]',
+    required: false,
+    resolution: 'static-when-present',
+    issueCode: 'play_authoring_dataset_option_invalid',
+    description:
+      'Computed columns deliberately left out of the authored @mermaid diagram.',
+    errorMessage:
+      'ctx.dataset run undrawnColumns must be a non-empty array of static column-name strings.',
+  },
   'ctx.step.id': {
     schema: Type.String({ minLength: 1 }),
     fixtures: {
@@ -2339,7 +2387,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   'export type StepProgramOutput<TProgram> = TProgram extends StepProgram<unknown, infer Output, unknown> ? Output : never;',
   'export type DatasetRowKey<InputRow extends object> = (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);',
   'export type DatasetDefinitionOptions<InputRow extends object> = { key?: DatasetRowKey<InputRow> };',
-  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType('ctx.dataset.run.description')}; key?: DatasetRowKey<InputRow>; onRowError?: ${cloudReferenceType('ctx.dataset.run.onRowError')}; mode?: ${cloudReferenceType('ctx.dataset.run.mode')} };`,
+  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType('ctx.dataset.run.description')}; key?: DatasetRowKey<InputRow>; onRowError?: ${cloudReferenceType('ctx.dataset.run.onRowError')}; mode?: ${cloudReferenceType('ctx.dataset.run.mode')}; undrawnColumns?: ${cloudReferenceType('ctx.dataset.run.undrawnColumns')} };`,
   'export type DatasetBuilder<InputRow extends object, OutputRow extends object> = {',
   '  withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;',
   '  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & { readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean> }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;',