deepline 0.1.143 → 0.1.145

package/README.md

@@ -65,8 +65,8 @@ Do not route the SDK CLI through `.env`, `.env.local`, or `.env.worktree`.
 Config resolution order:
 
 ```text
-host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> saved production auth -> https://code.deepline.com
-key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> saved auth for the resolved host
+host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> Cowork workspace .env.deepline -> saved production auth -> https://code.deepline.com
+key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> matching Cowork workspace .env.deepline -> saved auth for the resolved host
 ```
 
 ## CLI commands

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -640,6 +640,8 @@ type DynamicWorkflowMetadata = {
 const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
 const SUBMIT_INITIAL_STATE_POLL_MS = 50;
 const WORKFLOW_RETRY_STATE_TTL_MS = 60 * 60 * 1000;
+const COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE =
+  'Worker memory limit hit before the run could finish. For CSV enrich, use --output or --in-place for automatic batches; otherwise rerun smaller --rows ranges.';
 
 function buildDynamicWorkflowMetadata(
   params: PlayWorkflowParams,
@@ -1052,6 +1054,27 @@ function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
   return isRecord(payload.params) ? payload.params : payload;
 }
 
+function isCoordinatorWorkerMemoryLimitError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes('worker exceeded memory limit');
+}
+
+function normalizeCoordinatorWorkflowRuntimeFailure(
+  error: unknown,
+): ReturnType<typeof normalizePlayRunFailure> {
+  const failure = normalizePlayRunFailure(error);
+  if (!isCoordinatorWorkerMemoryLimitError(error)) {
+    return failure;
+  }
+  return {
+    ...failure,
+    code: 'WORKER_MEMORY_LIMIT_EXCEEDED',
+    message: COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE,
+    retryable: false,
+    cause: failure.message,
+  };
+}
+
 async function markWorkflowRuntimeFailure(input: {
   env: CoordinatorEnv;
   event: unknown;
@@ -1074,6 +1097,16 @@ async function markWorkflowRuntimeFailure(input: {
     input.error instanceof Error && typeof input.error.stack === 'string'
       ? input.error.stack.split('\n').slice(0, 12).join('\n')
       : null;
+  const failure = normalizeCoordinatorWorkflowRuntimeFailure(input.error);
+  const shouldPreserveRawError =
+    failure.code === 'RUN_FAILED' ||
+    (failure.cause !== undefined && failure.message === failure.cause);
+  const normalizedError =
+    shouldPreserveRawError
+      ? `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
+          errorStack ? `\n${errorStack}` : ''
+        }`
+      : `DynamicWorkflow runner failed: ${failure.message}`;
   const headers = new Headers({
     authorization: `Bearer ${executorToken}`,
     'content-type': 'application/json',
@@ -1089,9 +1122,7 @@ async function markWorkflowRuntimeFailure(input: {
         runId,
         source: 'coordinator',
         occurredAt: Date.now(),
-        error: `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
-          errorStack ? `\n${errorStack}` : ''
-        }`,
+        error: normalizedError,
       } satisfies PlayRunLedgerEvent,
     ],
   });
@@ -3062,7 +3093,8 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                 });
                 return result;
               } catch (innerError) {
-                const failure = normalizePlayRunFailure(innerError);
+                const failure =
+                  normalizeCoordinatorWorkflowRuntimeFailure(innerError);
                 console.error(
                   '[coordinator] DynamicWorkflow runner.run threw',
                   {

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -43,7 +43,10 @@ import {
   type ChunkExecutionResult,
 } from '../../../shared_libs/play-runtime/batch-runtime';
 import { getPlayRuntimeBatchStrategy } from '../../../shared_libs/play-runtime/play-runtime-batching-registry';
-import { STANDARD_PLAY_RUNTIME_LIMIT_SECONDS } from '../../../shared_libs/temporal/constants';
+import {
+  STANDARD_PLAY_RUNTIME_LIMIT_LABEL,
+  STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
+} from '../../../shared_libs/temporal/constants';
 import {
   createPlayExecutionGovernor,
   type GovernanceSnapshot,
@@ -6341,7 +6344,7 @@ async function executeRunRequest(
     runtimeLimitExceeded = true;
     if (!abortSignal.aborted) {
       abortController.abort(
-        `Play runtime limit exceeded after ${STANDARD_PLAY_RUNTIME_LIMIT_SECONDS}s.`,
+        `Based on this plan, max runtime is ${STANDARD_PLAY_RUNTIME_LIMIT_LABEL}. Use smaller batches; ask for runtime.`,
       );
     }
   }, STANDARD_PLAY_RUNTIME_LIMIT_SECONDS * 1000);

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

@@ -320,6 +320,7 @@ export type RunsNamespace = {
     runId?: string;
     limit?: number;
     offset?: number;
+    rowMode?: 'output' | 'all';
   }) => Promise<PlaySheetRowsResult>;
   /** Stop a running/waiting run. */
   stop: (
@@ -2434,6 +2435,7 @@ export class DeeplineClient {
     runId?: string;
     limit?: number;
     offset?: number;
+    rowMode?: 'output' | 'all';
   }): Promise<PlaySheetRowsResult> {
     const params = new URLSearchParams({
       tableNamespace: input.tableNamespace,
@@ -2443,6 +2445,9 @@ export class DeeplineClient {
     if (input.runId?.trim()) {
       params.set('runId', input.runId.trim());
     }
+    if (input.rowMode === 'all') {
+      params.set('rowMode', 'all');
+    }
     return await this.http.get<PlaySheetRowsResult>(
       `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet?${params.toString()}`,
     );

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

@@ -15,21 +15,31 @@
  * 1. `options.baseUrl`
  * 2. `DEEPLINE_HOST_URL`
  * 3. nearest project `.env.deepline`
- * 4. production host auth file
- * 5. production fallback: `https://code.deepline.com`
+ * 4. Cowork mounted workspace `.env.deepline`
+ * 5. production host auth file
+ * 6. production fallback: `https://code.deepline.com`
  *
  * API key:
  * 1. `options.apiKey`
  * 2. `DEEPLINE_API_KEY`
  * 3. nearest project `.env.deepline`
- * 4. host auth file for the resolved base URL
+ * 4. Cowork mounted workspace `.env.deepline`
+ * 5. host auth file for the resolved base URL
  *
  * App/runtime env files such as `.env`, `.env.local`, and `.env.worktree` do
  * not route the SDK CLI. Put CLI routing in `.env.deepline`.
  *
  * @module
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import type { DeeplineClientOptions, ResolvedConfig } from './types.js';
@@ -48,8 +58,41 @@ const DEFAULT_TIMEOUT = 60_000;
 const DEFAULT_MAX_RETRIES = 3;
 
 const PROJECT_DEEPLINE_ENV_FILE = '.env.deepline';
+const COWORK_IGNORED_WORKSPACE_DIRS = new Set([
+  '.auto-memory',
+  '.claude',
+  '.remote-plugins',
+  'outputs',
+  'plugins',
+  'uploads',
+]);
+const COWORK_PROJECT_MARKERS = [
+  '.deepline',
+  '.env.deepline',
+  '.git',
+  'AGENTS.md',
+  'package.json',
+  'pyproject.toml',
+];
 
 type EnvValues = Record<string, string>;
+type ProjectEnvCandidate = {
+  filePath: string;
+  env: EnvValues;
+  source: 'nearest' | 'cowork';
+};
+export type ProjectAuthSource = ProjectEnvCandidate;
+export type ProjectPinTarget =
+  | {
+      ok: true;
+      dir: string;
+      source: 'nearest' | 'cowork' | 'cwd';
+    }
+  | {
+      ok: false;
+      reason: 'ambiguous_cowork_project';
+      candidates: string[];
+    };
 
 /**
  * Convert a base URL to a filesystem-safe slug for per-host config storage.
@@ -119,9 +162,161 @@ function findNearestEnvFile(
   }
 }
 
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function canonicalPath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function isTruthy(value: string | undefined): boolean {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? '');
+}
+
+function sessionRootFromPath(path: string | undefined): string | null {
+  const trimmed = path?.trim();
+  if (!trimmed) return null;
+  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
+  return match?.[0] ?? null;
+}
+
+function coworkSessionRoot(): string | null {
+  const home = process.env.HOME?.trim();
+  const homeSessionRoot = sessionRootFromPath(home);
+  if (homeSessionRoot && isDirectory(join(homeSessionRoot, 'mnt'))) {
+    return homeSessionRoot;
+  }
+
+  const cwdSessionRoot = sessionRootFromPath(process.cwd());
+  if (cwdSessionRoot && isDirectory(join(cwdSessionRoot, 'mnt'))) {
+    return cwdSessionRoot;
+  }
+
+  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
+    const mountedRoot = join(home, 'mnt');
+    if (isDirectory(mountedRoot)) return resolve(home);
+  }
+
+  return null;
+}
+
+function isCoworkLikeSandbox(): boolean {
+  const home = process.env.HOME?.trim();
+  return (
+    isTruthy(process.env.CLAUDE_CODE_REMOTE) ||
+    sessionRootFromPath(home) !== null ||
+    sessionRootFromPath(process.cwd()) !== null
+  );
+}
+
+function coworkProjectScore(path: string): number {
+  let score = 0;
+  for (const marker of COWORK_PROJECT_MARKERS) {
+    if (existsSync(join(path, marker))) score += 1;
+  }
+  return score;
+}
+
+function listCoworkWorkspaceDirCandidates(): string[] {
+  if (!isCoworkLikeSandbox()) {
+    return [];
+  }
+
+  const explicitProjectDir = process.env.CLAUDE_PROJECT_DIR?.trim();
+  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
+    return [resolve(explicitProjectDir)];
+  }
+
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return [];
+
+  const mountedRoot = join(sessionRoot, 'mnt');
+  if (!isDirectory(mountedRoot)) return [];
+
+  let names: string[];
+  try {
+    names = readdirSync(mountedRoot).sort();
+  } catch {
+    return [];
+  }
+
+  const candidates: string[] = [];
+  for (const name of names) {
+    if (name.startsWith('.') || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
+      continue;
+    }
+    const candidate = join(mountedRoot, name);
+    if (isDirectory(candidate)) candidates.push(candidate);
+  }
+
+  if (candidates.length <= 1) return candidates;
+
+  const projectLike = candidates.filter(
+    (candidate) => coworkProjectScore(candidate) > 0,
+  );
+  return projectLike.length > 0 ? projectLike : candidates;
+}
+
+function isInIgnoredCoworkMount(path: string): boolean {
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return false;
+  const mountedRoot = canonicalPath(join(sessionRoot, 'mnt'));
+  const resolvedPath = canonicalPath(path);
+  const prefix = `${mountedRoot}/`;
+  if (!resolvedPath.startsWith(prefix)) return false;
+  const relativePath = resolvedPath.slice(prefix.length);
+  const mountName = relativePath.split('/')[0];
+  return (
+    mountName.startsWith('.') || COWORK_IGNORED_WORKSPACE_DIRS.has(mountName)
+  );
+}
+
+function detectCoworkWorkspaceDir(): string | null {
+  const candidates = listCoworkWorkspaceDirCandidates();
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+function loadProjectEnvCandidates(
+  startDir: string = process.cwd(),
+): ProjectEnvCandidate[] {
+  const filePaths: string[] = [];
+  const sources = new Map<string, ProjectEnvCandidate['source']>();
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    filePaths.push(nearestFile);
+    sources.set(resolve(nearestFile), 'nearest');
+  }
+
+  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
+  if (coworkWorkspaceDir) {
+    const coworkFile = join(coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
+    if (
+      existsSync(coworkFile) &&
+      !filePaths.some((filePath) => resolve(filePath) === resolve(coworkFile))
+    ) {
+      filePaths.push(coworkFile);
+      sources.set(resolve(coworkFile), 'cowork');
+    }
+  }
+
+  return filePaths.map((filePath) => ({
+    filePath,
+    env: parseEnvFile(filePath),
+    source: sources.get(resolve(filePath)) ?? 'nearest',
+  }));
+}
+
 function loadProjectDeeplineEnv(startDir = process.cwd()): EnvValues {
-  const filePath = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  return filePath ? parseEnvFile(filePath) : {};
+  return loadProjectEnvCandidates(startDir)[0]?.env ?? {};
 }
 
 function normalizeBaseUrl(baseUrl: string): string {
@@ -204,11 +399,13 @@ function loadGlobalCliEnv(): EnvValues {
  * Auto-detect the best base URL when none is explicitly provided.
  */
 function autoDetectBaseUrl(): string {
-  const projectEnv = loadProjectDeeplineEnv();
+  const projectEnvs = loadProjectEnvCandidates();
   const globalEnv = loadGlobalCliEnv();
   return (
     normalizeBaseUrl(process.env[HOST_URL_ENV] ?? '') ||
-    normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '') ||
+    firstNonEmpty(
+      ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV])),
+    ) ||
     normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? '') ||
     PROD_URL
   );
@@ -219,18 +416,38 @@ export function resolveApiKeyForBaseUrl(
   explicitApiKey?: string | null,
 ): string {
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const projectEnv = loadProjectDeeplineEnv();
+  const projectEnvs = loadProjectEnvCandidates();
   const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
-  const projectBaseUrl = normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '');
-  const projectKeyApplies = projectBaseUrl === normalizedBaseUrl;
   return firstNonEmpty(
     explicitApiKey,
     process.env[API_KEY_ENV],
-    projectKeyApplies ? projectEnv[API_KEY_ENV] : '',
+    ...projectEnvs.map(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? '');
+      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : '';
+    }),
     cliEnv[API_KEY_ENV],
   );
 }
 
+function getResolvedProjectAuthSource(
+  baseUrl: string,
+  apiKey: string,
+  startDir: string = process.cwd(),
+): ProjectAuthSource | null {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const normalizedApiKey = apiKey.trim();
+  if (!normalizedBaseUrl || !normalizedApiKey) return null;
+  return (
+    loadProjectEnvCandidates(startDir).find(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? '');
+      return (
+        projectBaseUrl === normalizedBaseUrl &&
+        (env[API_KEY_ENV] ?? '').trim() === normalizedApiKey
+      );
+    }) ?? null
+  );
+}
+
 /**
  * Resolve SDK configuration from the public SDK CLI env contract.
  */
@@ -265,6 +482,7 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   const merged = { ...existing, ...values };
   const dir = dirname(filePath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  ensureProjectEnvIsIgnored(dir);
   const allowedKeys = new Set([HOST_URL_ENV, API_KEY_ENV]);
   const lines = Object.entries(merged)
     .filter(([key, value]) => allowedKeys.has(key) && value !== '')
@@ -272,20 +490,99 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   writeFileSync(filePath, `${lines.join('\n')}\n`, 'utf-8');
 }
 
+function ensureProjectEnvIsIgnored(dir: string): void {
+  const gitignorePath = join(dir, '.gitignore');
+  const entry = PROJECT_DEEPLINE_ENV_FILE;
+  const existing = existsSync(gitignorePath)
+    ? readFileSync(gitignorePath, 'utf-8')
+    : '';
+  const alreadyIgnored = existing
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .some((line) => line === entry || line === `/${entry}`);
+  if (alreadyIgnored) return;
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  writeFileSync(gitignorePath, `${existing}${prefix}${entry}\n`, 'utf-8');
+}
+
 export function saveProjectDeeplineEnvValues(
   values: EnvValues,
   startDir: string = process.cwd(),
 ): string[] {
-  const filePath = join(resolve(startDir), PROJECT_DEEPLINE_ENV_FILE);
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok) {
+    throw new ConfigError(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ', ',
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`,
+    );
+  }
+  const filePath = join(target.dir, PROJECT_DEEPLINE_ENV_FILE);
   mergeProjectEnvFile(filePath, values);
   return [filePath];
 }
 
+export function resolveProjectPinDir(startDir: string = process.cwd()): string {
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok) {
+    throw new ConfigError(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ', ',
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`,
+    );
+  }
+  return target.dir;
+}
+
+export function resolveProjectPinTarget(
+  startDir: string = process.cwd(),
+): ProjectPinTarget {
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    return { ok: true, dir: dirname(nearestFile), source: 'nearest' };
+  }
+
+  const coworkCandidates = listCoworkWorkspaceDirCandidates();
+  if (coworkCandidates.length === 1) {
+    return { ok: true, dir: coworkCandidates[0], source: 'cowork' };
+  }
+  if (coworkCandidates.length > 1) {
+    const resolvedStartDir = canonicalPath(startDir);
+    const cwdCandidate = coworkCandidates.find((candidate) => {
+      const resolvedCandidate = canonicalPath(candidate);
+      return (
+        resolvedStartDir === resolvedCandidate ||
+        resolvedStartDir.startsWith(`${resolvedCandidate}/`)
+      );
+    });
+    if (cwdCandidate) {
+      return { ok: true, dir: cwdCandidate, source: 'cowork' };
+    }
+    return {
+      ok: false,
+      reason: 'ambiguous_cowork_project',
+      candidates: coworkCandidates,
+    };
+  }
+
+  return { ok: true, dir: resolve(startDir), source: 'cwd' };
+}
+
+export function getActiveProjectAuthSource(
+  startDir: string = process.cwd(),
+): ProjectAuthSource | null {
+  return loadProjectEnvCandidates(startDir)[0] ?? null;
+}
+
 export {
   baseUrlSlug,
   loadCliEnv,
   loadGlobalCliEnv,
+  loadProjectDeeplineEnv,
+  getResolvedProjectAuthSource,
+  listCoworkWorkspaceDirCandidates,
   parseEnvFile,
+  detectCoworkWorkspaceDir,
   autoDetectBaseUrl,
   PROD_URL,
 };

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

@@ -101,10 +101,10 @@ export const SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: '0.1.143',
+  version: '0.1.145',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.143',
+    latest: '0.1.145',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/temporal/constants.ts

@@ -18,13 +18,14 @@ export const LOCAL_TEMPORAL_ADDRESS = `127.0.0.1:${LOCAL_TEMPORAL_FRONTEND_PORT}
 export const LOCAL_TEMPORAL_UI_URL = `http://127.0.0.1:${LOCAL_TEMPORAL_UI_PORT}`;
 
 /** Maximum active user-code runtime for a standard play, in seconds. */
-export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 10 * 60; // 10 minutes
+export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60; // 20 minutes
+export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
 
 /**
- * Activity timeout includes cleanup/billing headroom after the 10 minute
+ * Activity timeout includes setup, cleanup, and billing headroom after the 20 minute
  * user-code runtime cap. Keep this higher than STANDARD_PLAY_RUNTIME_LIMIT_SECONDS.
  */
-export const PLAY_ACTIVITY_TIMEOUT_SECONDS = 12 * 60; // 12 minutes
+export const PLAY_ACTIVITY_TIMEOUT_SECONDS = 30 * 60; // 30 minutes
 
 /** Heartbeat cadence for the long-running play execution activity. */
 export const PLAY_EXECUTE_ACTIVITY_HEARTBEAT_INTERVAL_SECONDS = 15;