deepline 0.1.129 → 0.1.131

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

@@ -2,6 +2,7 @@ import { SDK_API_CONTRACT, SDK_VERSION } from './version.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { sdkCliStateDirPath } from './config.js';
 
 export type SdkCompatibilityStatus =
   | 'current'
@@ -34,10 +35,21 @@ export type SdkCompatibilityResponse = {
     action: 'force_python';
     reason: 'rollback_forced';
   };
+  skills?: SdkCompatibilitySkillsUpdate;
+};
+
+export type SdkCompatibilitySkillsUpdate = {
+  needs_update: boolean;
+  local: {
+    version: string | null;
+  };
+  remote: {
+    version: string;
+  };
 };
 
 const CHECK_TIMEOUT_MS = 2_000;
-const COMPAT_CACHE_TTL_MS = 5 * 60 * 1000;
+export const SDK_COMPATIBILITY_CACHE_TTL_MS = 5 * 60 * 1000;
 
 type CompatCacheFile = {
   entries?: Record<
@@ -55,13 +67,34 @@ function shouldSkipCompatibilityCheck(): boolean {
   return value === '1' || value === 'true' || value === 'yes';
 }
 
-function compatibilityCachePath(): string {
-  return join(homedir(), '.cache', 'deepline', 'sdk-compat-cache.json');
+export function sdkCompatibilityCachePath(
+  baseUrl: string,
+  homeDir = homedir(),
+): string {
+  return join(sdkCliStateDirPath(baseUrl, homeDir), 'compat-cache.json');
+}
+
+function legacySdkCompatibilityCachePath(homeDir = homedir()): string {
+  return join(homeDir, '.cache', 'deepline', 'sdk-compat-cache.json');
 }
 
 function compatibilityCacheKey(
   baseUrl: string,
   command: string | null | undefined,
+  skillsVersion: string | null | undefined,
+): string {
+  return JSON.stringify({
+    baseUrl: baseUrl.replace(/\/$/, ''),
+    version: SDK_VERSION,
+    apiContract: SDK_API_CONTRACT,
+    command: command?.trim() || null,
+    skillsVersion: skillsVersion ?? null,
+  });
+}
+
+function legacyCompatibilityCacheKey(
+  baseUrl: string,
+  command: string | null | undefined,
 ): string {
   return JSON.stringify({
     baseUrl: baseUrl.replace(/\/$/, ''),
@@ -74,15 +107,27 @@ function compatibilityCacheKey(
 function readCachedCompatibility(
   baseUrl: string,
   command: string | null | undefined,
+  skillsVersion: string | null | undefined,
 ): SdkCompatibilityResponse | null {
   try {
-    const path = compatibilityCachePath();
-    if (!existsSync(path)) {
+    const path = sdkCompatibilityCachePath(baseUrl);
+    const legacyPath = legacySdkCompatibilityCachePath();
+    const useLegacyCache = !existsSync(path) && existsSync(legacyPath);
+    const cachePath = useLegacyCache ? legacyPath : path;
+    if (!existsSync(cachePath)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as CompatCacheFile;
-    const entry = parsed.entries?.[compatibilityCacheKey(baseUrl, command)];
-    if (!entry || Date.now() - entry.savedAt > COMPAT_CACHE_TTL_MS) {
+    const parsed = JSON.parse(
+      readFileSync(cachePath, 'utf8'),
+    ) as CompatCacheFile;
+    const entry =
+      parsed.entries?.[
+        compatibilityCacheKey(baseUrl, command, skillsVersion)
+      ] ??
+      (useLegacyCache
+        ? parsed.entries?.[legacyCompatibilityCacheKey(baseUrl, command)]
+        : undefined);
+    if (!entry || Date.now() - entry.savedAt > SDK_COMPATIBILITY_CACHE_TTL_MS) {
       return null;
     }
     return entry.response;
@@ -94,15 +139,16 @@ function readCachedCompatibility(
 function writeCachedCompatibility(
   baseUrl: string,
   command: string | null | undefined,
+  skillsVersion: string | null | undefined,
   response: SdkCompatibilityResponse,
 ): void {
   try {
-    const path = compatibilityCachePath();
+    const path = sdkCompatibilityCachePath(baseUrl);
     const existing = existsSync(path)
       ? (JSON.parse(readFileSync(path, 'utf8')) as CompatCacheFile)
       : {};
     const entries = existing.entries ?? {};
-    entries[compatibilityCacheKey(baseUrl, command)] = {
+    entries[compatibilityCacheKey(baseUrl, command, skillsVersion)] = {
       savedAt: Date.now(),
       response,
     };
@@ -116,7 +162,7 @@ function writeCachedCompatibility(
 
 export async function checkSdkCompatibility(
   baseUrl: string,
-  options: { command?: string | null } = {},
+  options: { command?: string | null; skillsVersion?: string | null } = {},
 ): Promise<{
   response: SdkCompatibilityResponse | null;
   error: Error | null;
@@ -132,6 +178,9 @@ export async function checkSdkCompatibility(
     if (options.command?.trim()) {
       url.searchParams.set('command', options.command.trim());
     }
+    if (options.skillsVersion !== undefined) {
+      url.searchParams.set('skills_version', options.skillsVersion ?? '');
+    }
     const response = await fetch(url, {
       method: 'GET',
       headers: {
@@ -145,12 +194,24 @@ export async function checkSdkCompatibility(
       .json()
       .catch(() => null)) as SdkCompatibilityResponse | null;
     if (data) {
-      writeCachedCompatibility(baseUrl, options.command, data);
+      writeCachedCompatibility(
+        baseUrl,
+        options.command,
+        options.skillsVersion,
+        data,
+      );
     }
     return { response: data, error: null };
   } catch (error) {
-    const cached = readCachedCompatibility(baseUrl, options.command);
-    if (cached?.ok === false || cached?.status === 'unsupported') {
+    // Live compat policy must win when the server is reachable: rollback and
+    // support-floor changes are blocking controls. The cache is only a
+    // resilience fallback for transient network failures.
+    const cached = readCachedCompatibility(
+      baseUrl,
+      options.command,
+      options.skillsVersion,
+    );
+    if (cached) {
       return { response: cached, error: null };
     }
     return {

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

@@ -151,6 +151,19 @@ function sdkCliConfigDir(baseUrl: string): string {
   return join(home, '.local', 'deepline', baseUrlSlug(baseUrl || PROD_URL));
 }
 
+export function sdkCliStateDirPath(
+  baseUrl: string,
+  homeDir: string = process.env.HOME?.trim() || homedir(),
+): string {
+  return join(
+    homeDir,
+    '.local',
+    'deepline',
+    baseUrlSlug(baseUrl || PROD_URL),
+    'sdk-cli',
+  );
+}
+
 function sdkCliEnvFilePath(baseUrl: string): string {
   return join(sdkCliConfigDir(baseUrl), '.env');
 }

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

@@ -25,7 +25,7 @@ import type { ResolvedConfig } from './types.js';
 import { AuthError, DeeplineError, RateLimitError } from './errors.js';
 import { SDK_API_CONTRACT, SDK_VERSION } from './version.js';
 import type { LiveEventEnvelope } from './types.js';
-import { baseUrlSlug } from './config.js';
+import { baseUrlSlug, sdkCliStateDirPath } from './config.js';
 import { detectAgentRuntime, isCoworkLikeSandbox } from './agent-runtime.js';
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
@@ -102,6 +102,10 @@ export class HttpClient {
     if (explicit) return explicit;
     try {
       const versionPath = join(
+        sdkCliStateDirPath(this.config.baseUrl),
+        'skills-version',
+      );
+      const legacyVersionPath = join(
         process.env.HOME?.trim() || homedir(),
         '.local',
         'deepline',
@@ -109,8 +113,11 @@ export class HttpClient {
         'sdk-skills',
         '.version',
       );
-      if (!existsSync(versionPath)) return null;
-      return this.cleanDiagnosticHeader(readFileSync(versionPath, 'utf-8'));
+      const resolvedPath = existsSync(versionPath)
+        ? versionPath
+        : legacyVersionPath;
+      if (!existsSync(resolvedPath)) return null;
+      return this.cleanDiagnosticHeader(readFileSync(resolvedPath, 'utf-8'));
     } catch {
       return null;
     }

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.129',
+  version: '0.1.131',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.129',
+    latest: '0.1.131',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [