deepline 0.3.356 → 0.3.358

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.356',
+  version: '0.3.358',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/monitors/deactivation-reasons.ts

@@ -20,7 +20,7 @@ import { monitorBillingRequiresExplicitReactivation } from './billing/state';
  * this off" and "we did, and here is why" must not be the same state.
  */
 
-export type MonitorDeactivationOwner = 'policy' | 'fleet';
+export type MonitorDeactivationOwner = 'policy' | 'fleet' | 'admin';
 
 /**
  * The delivery window, in days, that `monitors health` reports against.
@@ -43,6 +43,13 @@ export type MonitorDeactivationReasonDefinition = {
 
 export const MONITOR_DEACTIVATION_REASONS: readonly MonitorDeactivationReasonDefinition[] =
   [
+    {
+      id: 'workspace_archived',
+      owner: 'admin',
+      summary: 'Deactivated because the workspace is archived.',
+      resolution:
+        'Contact a platform administrator. Credit changes never reactivate an archived workspace.',
+    },
     {
       id: 'insufficient_balance',
       owner: 'policy',
@@ -122,6 +129,12 @@ export function isPolicyDeactivation(id: string | undefined | null): boolean {
   return monitorDeactivationReason(id)?.owner === 'policy';
 }
 
+/** Both policy and admin shutdown retain the definition; only policy owns recovery. */
+export function isMonitorSuspension(id: string | undefined | null): boolean {
+  const owner = monitorDeactivationReason(id)?.owner;
+  return owner === 'policy' || owner === 'admin';
+}
+
 // ---------------------------------------------------------------------------
 // The balance policy
 // ---------------------------------------------------------------------------

package/dist/bundling-sources/shared_libs/play-runtime/async-operation.ts

@@ -954,6 +954,17 @@ function asyncOperationRateLimitPollDelayMs(input: {
   return Math.max(input.retryAfterMs ?? 0, localBackoffMs);
 }
 
+/** A paced read of an already accepted job must never restart its launch. */
+export class AsyncOperationCompanionPacingError extends Error {
+  constructor(
+    message: string,
+    readonly retryAfterMs: number,
+  ) {
+    super(message);
+    this.name = 'AsyncOperationCompanionPacingError';
+  }
+}
+
 /**
  * Runtime-neutral executor for a declared async lifecycle.
  *
@@ -1074,25 +1085,47 @@ export async function executeAsyncOperationLifecycle<Response>(input: {
   }): Promise<
     { kind: 'response'; response: Response } | { kind: 'timed_out' }
   > => {
-    const remainingTimeoutMs = Math.max(
-      0,
-      polling.timeoutMs - (now() - startedAt),
-    );
-    if (remainingTimeoutMs <= 0) return { kind: 'timed_out' };
-    const abortSignal = AbortSignal.timeout(Math.ceil(remainingTimeoutMs));
-    try {
-      const response = await input.executeAction({
-        ...request,
-        jobId,
-        timeoutMs: Math.ceil(remainingTimeoutMs),
-        abortSignal,
-      });
-      return now() - startedAt >= polling.timeoutMs || abortSignal.aborted
-        ? { kind: 'timed_out' }
-        : { kind: 'response', response };
-    } catch (error) {
-      if (abortSignal.aborted) return { kind: 'timed_out' };
-      throw error;
+    let pacingAttempt = 0;
+    while (true) {
+      const remainingTimeoutMs = Math.max(
+        0,
+        polling.timeoutMs - (now() - startedAt),
+      );
+      if (remainingTimeoutMs <= 0) return { kind: 'timed_out' };
+      const abortSignal = AbortSignal.timeout(Math.ceil(remainingTimeoutMs));
+      try {
+        const response = await input.executeAction({
+          ...request,
+          jobId,
+          timeoutMs: Math.ceil(remainingTimeoutMs),
+          abortSignal,
+        });
+        return now() - startedAt >= polling.timeoutMs || abortSignal.aborted
+          ? { kind: 'timed_out' }
+          : { kind: 'response', response };
+      } catch (error) {
+        if (abortSignal.aborted) return { kind: 'timed_out' };
+        if (!(error instanceof AsyncOperationCompanionPacingError)) throw error;
+        // This refusal applies only to the current companion read. The launch
+        // already owns its job and hold. Stay inside their original deadline
+        // and repeat this exact action/page, never the enclosing start request.
+        pacingAttempt += 1;
+        const delayMs = Math.max(
+          1,
+          asyncOperationRateLimitPollDelayMs({
+            contract: effectiveContract,
+            pollAttempt: request.pollAttempt,
+            rateLimitAttempt: pacingAttempt,
+            retryAfterMs: error.retryAfterMs,
+          }),
+        );
+        const remainingAfterRefusal = Math.max(
+          0,
+          polling.timeoutMs - (now() - startedAt),
+        );
+        if (remainingAfterRefusal <= 0) return { kind: 'timed_out' };
+        await sleep(Math.min(delayMs, remainingAfterRefusal));
+      }
     }
   };
   while (true) {

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -17609,6 +17609,22 @@ export async function readPostgresSchedulerObservationAdmissions(
   }));
 }
 
+/** Admission authority: includes live runs whose Convex projection has not landed. */
+export async function listPostgresSchedulerActiveRunsForOrg(
+  client: PostgresSchedulerQueryClient,
+  orgId: string,
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<string[]> {
+  if (!orgId.trim()) throw new Error('Workspace ID is required.');
+  const result = await client.query<{ run_id: string }>(
+    `SELECT run_id FROM ${tableName('runs', options)}
+     WHERE org_id = $1 AND status IN ('queued', 'running', 'waiting')
+     ORDER BY created_at, run_id LIMIT 5`,
+    [orgId],
+  );
+  return result.rows.map((row) => row.run_id);
+}
+
 export async function readPostgresSchedulerRunStatus(
   client: PostgresSchedulerQueryClient,
   runId: string,
@@ -18338,6 +18354,11 @@ async function claimPostgresSchedulerOutboxPrefix(
           ? `(head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})`
           : 'false';
     const findSearchBlockersOnce = seekRunHead && input.searchOnly === true;
+    const searchFactColumnsSql = (alias: string) =>
+      `${alias}.event_id, ${alias}.run_id, ${alias}.event_type,
+       ${alias}.created_at, ${alias}.failed_at, ${alias}.next_attempt_at,
+       ${alias}.lease_owner, ${alias}.lease_expires_at,
+       ${supportsTerminalBatchMarker ? `${alias}.delivery_batch_started_at` : 'NULL::timestamptz AS delivery_batch_started_at'}`;
     const blockingPredecessorSql = (alias: string) => `(
       (${alias}.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
        AND NOT (${ingressPrefixSql}))
@@ -18477,13 +18498,44 @@ async function claimPostgresSchedulerOutboxPrefix(
         LIMIT 1
       ), ${
         findSearchBlockersOnce
-          ? `first_blocker AS MATERIALIZED (
+          ? `search_prefix AS MATERIALIZED (
+        SELECT ${searchFactColumnsSql('pending')}
+        FROM ${tableName('outbox', options)} AS pending
+        JOIN head ON head.run_id = pending.run_id
+        WHERE pending.run_id = $2::text
+          AND ${pending('pending')}
+          AND ${searchLaneSql('pending')} = true
+        ORDER BY ${runLedgerOrderSql('pending')}
+        LIMIT $1
+      ), frozen_search_prefix AS MATERIALIZED (
+        SELECT EXISTS (
+          SELECT 1 FROM search_prefix AS fact
+          WHERE fact.delivery_batch_started_at IS NOT NULL
+            AND fact.event_type IN (
+              ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
+            )
+        ) AS has_terminal
+      ), search_facts AS MATERIALIZED (
+        -- Ordinary search claims examine only the existing batch's causal
+        -- window, including ineligible rows so a blocker cannot be skipped.
+        SELECT prefix.* FROM search_prefix AS prefix
+        WHERE NOT (SELECT has_terminal FROM frozen_search_prefix)
+        UNION ALL
+        -- A frozen terminal receipt can contain marked facts beyond newer
+        -- unmarked rows. Retain that full membership scan only for this case;
+        -- limiting its raw window would strand an already attempted receipt.
+        SELECT ${searchFactColumnsSql('pending')}
+        FROM ${tableName('outbox', options)} AS pending
+        JOIN head ON head.run_id = pending.run_id
+        WHERE (SELECT has_terminal FROM frozen_search_prefix)
+          AND pending.run_id = $2::text
+          AND ${pending('pending')}
+          AND ${searchLaneSql('pending')} = true
+      ), first_blocker AS MATERIALIZED (
         SELECT predecessor.event_type, predecessor.created_at, predecessor.event_id
-        FROM ${tableName('outbox', options)} AS predecessor
+        FROM search_facts AS predecessor
         JOIN head ON head.run_id = predecessor.run_id
         WHERE predecessor.run_id = $2::text
-          AND ${pending('predecessor')}
-          AND ${searchLaneSql('predecessor')} = true
           -- The oldest pending head passed eligibility above. Only later
           -- facts can introduce an ordinary blocker for this prefix.
           AND ${runLedgerPositionSql('predecessor')} > (
@@ -18496,11 +18548,9 @@ async function claimPostgresSchedulerOutboxPrefix(
         LIMIT 1
       ), first_started_terminal AS MATERIALIZED (
         SELECT terminal_predecessor.event_type, terminal_predecessor.created_at, terminal_predecessor.event_id
-        FROM ${tableName('outbox', options)} AS terminal_predecessor
+        FROM search_facts AS terminal_predecessor
         JOIN head ON head.run_id = terminal_predecessor.run_id
         WHERE terminal_predecessor.run_id = $2::text
-          AND ${pending('terminal_predecessor')}
-          AND ${searchLaneSql('terminal_predecessor')} = true
           AND ${supportsTerminalBatchMarker ? 'terminal_predecessor.delivery_batch_started_at IS NOT NULL' : 'false'}
           AND terminal_predecessor.event_type IN (
             ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
@@ -18515,6 +18565,7 @@ async function claimPostgresSchedulerOutboxPrefix(
         JOIN head ON head.run_id = outbox.run_id
         WHERE ${pending('outbox')}
           ${runId !== null ? 'AND outbox.run_id = $2::text' : ''}
+          ${findSearchBlockersOnce ? 'AND outbox.event_id = ANY(ARRAY(SELECT event_id FROM search_facts))' : ''}
           AND ${searchLaneSql('outbox')} = ${input.searchOnly === true ? 'true' : 'false'}
           AND outbox.failed_at IS NULL
           -- Admission is causally first and must be projected alone. A later
@@ -18735,26 +18786,25 @@ async function claimPostgresSchedulerOutboxPrefix(
  */
 export async function readPostgresSchedulerOutboxNextDueAt(
   client: PostgresSchedulerQueryClient,
-  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  options?: Pick<PostgresSchedulerOptions, 'schema'> & {
+    lane?: 'lifecycle' | 'observability';
+  },
 ): Promise<Date | null> {
+  const lanes =
+    options?.lane === 'lifecycle'
+      ? [false]
+      : options?.lane === 'observability'
+        ? [true]
+        : [false, true];
   const result = await client.query<{ due_at: Date | string | null }>(
     `
       -- Seek distinct run identities without reading their pending fact tails.
-      WITH RECURSIVE ${runLedgerPendingRunsSql(options)}, heads AS MATERIALIZED (
-        SELECT pending_run.run_id, false AS search_only, head.*
-        FROM pending_runs AS pending_run
-        CROSS JOIN LATERAL (
-          SELECT pending.created_at, pending.next_attempt_at,
-                 pending.failed_at, pending.lease_expires_at
-          FROM ${tableName('outbox', options)} AS pending
-          WHERE pending.run_id = pending_run.run_id
-            AND pending.delivered_at IS NULL
-            AND ${searchLaneSql('pending')} = false
-          ORDER BY ${runLedgerOrderSql('pending')}
-          LIMIT 1
-        ) AS head
-        UNION ALL
-        SELECT pending_run.run_id, true AS search_only, head.*
+      WITH RECURSIVE ${runLedgerPendingRunsSql(options, options?.lane === undefined ? undefined : lanes[0])}, heads AS MATERIALIZED (
+        ${lanes
+          .map(
+            (
+              searchOnly,
+            ) => `        SELECT pending_run.run_id, ${searchOnly} AS search_only, head.*
         FROM pending_runs AS pending_run
         CROSS JOIN LATERAL (
           SELECT pending.created_at, pending.next_attempt_at,
@@ -18762,10 +18812,12 @@ export async function readPostgresSchedulerOutboxNextDueAt(
           FROM ${tableName('outbox', options)} AS pending
           WHERE pending.run_id = pending_run.run_id
             AND pending.delivered_at IS NULL
-            AND ${searchLaneSql('pending')} = true
+            AND ${searchLaneSql('pending')} = ${searchOnly}
           ORDER BY ${runLedgerOrderSql('pending')}
           LIMIT 1
-        ) AS head
+        ) AS head`,
+          )
+          .join('\n        UNION ALL\n')}
       )
       SELECT min(greatest(
         CASE