chainlesschain 0.166.106 → 0.166.108

package/src/lib/evolution/rrsi-tenant-index-anchor-history.js

@@ -133,6 +133,10 @@ export function verifyRrsiTenantIndexAnchorHistory(input) {
           snapshot.artifactStoreDirectoryBoundaryDigest,
         artifactStoreDirectoryBoundaryRechecked: true,
         artifactStoreBoundaryScope: "root-and-files-directories",
+        sourceJournalDirectoryBoundaryDigest:
+          snapshot.sourceJournalDirectoryBoundaryDigest,
+        sourceJournalDirectoryBoundaryRechecked: true,
+        sourceJournalBoundaryScope: "source-journal-four-directories",
         previous: snapshot.prefixes[0],
         current: snapshot.current,
         signaturesVerifiedRelativeToExplicitKey: true,
@@ -141,6 +145,7 @@ export function verifyRrsiTenantIndexAnchorHistory(input) {
         localRetainedHistoryReplayed: true,
         selectedContextOnly: true,
         storageGraphDigestVerified: false,
+        fullPhysicalStorageGraphVerified: false,
         rootAuthorityVerified: false,
         installationBindingSignatureVerified: false,
         routingPinVerified: false,

package/src/lib/execution-location-failure-site.js

@@ -22,7 +22,7 @@ export function readExecutionLocationStorageFailure(stderr) {
   const match = String(stderr || "")
     .slice(0, MAX_DIAGNOSTIC_CHARS)
     .match(
-      /\[windows-acl:(initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|timeout(?:-(?:startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify))?|spawn|output)(:0x[0-9a-f]{8})?\]/u,
+      /\[windows-acl:(initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|verify-read|verify-rules|serialize|output-complete|timeout(?:-(?:startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|verify-read|verify-rules|serialize|output-complete))?|spawn|output)(:0x[0-9a-f]{8})?\]/u,
     );
   return match ? `${match[1]}${match[2] || ""}` : null;
 }
@@ -31,7 +31,7 @@ export function readExecutionLocationStorageLaunchFailure(stderr) {
   const match = String(stderr || "")
     .slice(0, MAX_DIAGNOSTIC_CHARS)
     .match(
-      /\[windows-acl-launch:(inspect|repair|preflight):(spawn|timeout):(startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify):(EACCES|EPERM|ENOENT|ETIMEDOUT|EINVAL|ENOSYS|ENOMEM|EMFILE|ENFILE|ENOBUFS|EBUSY|UNKNOWN):(unknown|-?(?:0|[1-9][0-9]{0,4})):(spawnSync|spawn|unknown)\]/u,
+      /\[windows-acl-launch:(inspect|repair|preflight):(spawn|timeout):(startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|verify-read|verify-rules|serialize|output-complete):(EACCES|EPERM|ENOENT|ETIMEDOUT|EINVAL|ENOSYS|ENOMEM|EMFILE|ENFILE|ENOBUFS|EBUSY|UNKNOWN):(unknown|-?(?:0|[1-9][0-9]{0,4})):(spawnSync|spawn|unknown)\]/u,
     );
   if (!match) return null;
   const [, operation, failureStage, progressStage, code, rawErrno, syscall] =
@@ -42,7 +42,24 @@ export function readExecutionLocationStorageLaunchFailure(stderr) {
     (failureStage === "timeout") !== (code === "ETIMEDOUT")
   )
     return null;
-  return { operation, failureStage, progressStage, code, errno, syscall };
+  const timing = String(stderr || "")
+    .slice(0, MAX_DIAGNOSTIC_CHARS)
+    .match(
+      /\[windows-acl-elapsed:(initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|verify-read|verify-rules|serialize|output-complete):(0|[1-9][0-9]{0,5})\]/u,
+    );
+  const elapsedMs =
+    timing?.[1] === progressStage && Number(timing[2]) <= 300000
+      ? Number(timing[2])
+      : null;
+  return {
+    operation,
+    failureStage,
+    progressStage,
+    code,
+    errno,
+    syscall,
+    ...(elapsedMs === null ? {} : { elapsedMs }),
+  };
 }
 
 export function executionLocationFailureSite(error) {

package/src/lib/goal-store.js

@@ -51,6 +51,8 @@ export function goalFileStoreId(root = defaultRoot()) {
 }
 
 function fileRecord(value, root) {
+  if (value?.ownerRef != null || value?.projectRef != null)
+    throw goalError("GOAL_PROJECT_STORE_REQUIRED");
   const record = upgradeLegacyGoal(value, goalFileStoreId(root));
   if (record.storeId !== goalFileStoreId(root))
     throw goalError("GOAL_STORE_MISMATCH");
@@ -537,13 +539,18 @@ export function resolveActiveGoal(sel = {}, opts = {}) {
 export function createGoalFileAdapter(opts = {}) {
   const root = opts.root || defaultRoot();
   const storeId = goalFileStoreId(root);
+  const readJson =
+    opts.readJson === undefined
+      ? (file) => JSON.parse(fs.readFileSync(file, "utf8"))
+      : opts.readJson;
+  if (typeof readJson !== "function") throw goalError("GOAL_INVALID_ADAPTER");
   function read(id) {
     if (isUnsafeGoalId(id)) throw goalError("GOAL_INVALID_ID");
     const file = goalFile(root, id);
     if (!fs.existsSync(file)) return null;
     let value;
     try {
-      value = JSON.parse(fs.readFileSync(file, "utf8"));
+      value = readJson(file);
     } catch {
       throw goalError("GOAL_RECORD_CORRUPT");
     }

package/src/lib/image-input.js

@@ -174,14 +174,15 @@ export function detectImagePaths(text, deps = {}) {
  * (the REPL itself forces a terminal and can't be driven headlessly).
  *
  * @param {string} text     the user's typed message
- * @param {object} llm      { provider, baseUrl, apiKey, visionModel } current LLM
+ * @param {object} llm      { provider, model, baseUrl, apiKey, visionModel } current LLM
  * @param {object} deps     { existsSync, fs } injected for tests
+ * @param {object} flags    explicit per-run model overrides
  * @returns {{ content, images: string[], visionLlm: object|null, text: string }}
  *   content is a plain string when no image is detected, else a multimodal
  *   array; visionLlm is the per-turn provider/model/baseUrl/apiKey override
  *   (null when there are no images); text is the path-stripped prompt.
  */
-export function prepareVisionTurn(text, llm = {}, deps = {}) {
+export function prepareVisionTurn(text, llm = {}, deps = {}, flags = {}) {
   const detected = detectImagePaths(text, deps);
   if (!detected.images.length) {
     return { content: text, images: [], visionLlm: null, text };
@@ -191,7 +192,7 @@ export function prepareVisionTurn(text, llm = {}, deps = {}) {
   return {
     content: buildUserContent(finalText, resolved),
     images: detected.images,
-    visionLlm: resolveVisionLlm({ hasImage: true, flags: {}, llm }),
+    visionLlm: resolveVisionLlm({ hasImage: true, flags, llm }),
     text: finalText,
   };
 }
@@ -276,13 +277,38 @@ export function imageUrlBlockToAnthropic(block) {
  */
 export const DEFAULT_VISION_MODEL = "doubao-seed-2-0-lite-260215";
 
+// Recognize image-input families, including dated snapshots and local tags.
+// Unknown models keep using the configured vision fallback. Do not infer
+// vision from the provider alone or from text-only siblings (e.g. o1-mini,
+// DeepSeek V3/V4, MiniMax-Text, Qwen Coder, or GPT audio/transcription SKUs).
+const VISION_MODEL_PATTERNS = [
+  /^deepseek-v4[.-]1-(?:flash|pro)(?:-\d{6})?$/i,
+  /^gpt-(?:4o(?:-mini)?|4\.1(?:-mini|-nano)?|[56](?:\.\d+)?(?:-(?:sol|astra|luna|mini|nano|pro|chat|codex)(?:-(?:mini|max))?)*)(?:-(?:\d{4}-\d{2}-\d{2}|latest))?$/i,
+  /^gpt-4-(?:turbo(?:-\d{4}-\d{2}-\d{2})?|vision-preview)$/i,
+  /^(?:o1|o3(?:-pro)?|o4-mini)(?:-\d{4}-\d{2}-\d{2})?$/i,
+  /^claude-(?:3(?:[.-][57])?-(?:opus|sonnet|haiku)|(?:opus|sonnet|haiku)-[345](?:[.-]\d+)?)(?:-\d{8}|-latest)?$/i,
+  /^gemini-(?:(?:1\.5|[23](?:\.\d+)?)-(?:pro|flash)(?!.*(?:tts|audio))[\w.-]*|pro-vision)$/i,
+  /^doubao-(?:seed-(?:1[.-][68]|2[.-][01])(?:-(?:pro|lite|flash|thinking))?(?:-\d{6})?|(?:1[.-]5-)?vision[\w.-]*)$/i,
+  /^(?:qwen-vl-(?:max|plus)|qwen(?:2(?:[.-]5)?|3)[.-]?vl|qwen[23](?:[.-]5)?-omni|qvq)(?:[-:.][\w.-]+)?$/i,
+  /^qwen3[.-]5(?:[-:.][\w.-]+)?$/i,
+  /^glm-4(?:[.-]\d+)?v(?:-[\w.-]+)?$/i,
+  /^(?:kimi-k2[.-]5|moonshot-v1-(?:8k|32k|128k)-vision)(?:-[\w.-]+)?$/i,
+  /^(?:pixtral-(?:12b|large)|mistral-small-(?:3[.-][12]|250[36])|minimax-vl-01)(?:[-:.][\w.-]+)?$/i,
+  /^(?:llava|bakllava|llama3\.2-vision|minicpm-v|moondream)(?:[-:.][\w.-]+)?$/i,
+  /^gemma3(?::(?:4b|12b|27b)(?:-[\w.-]+)?)?$/i,
+];
+
+export function supportsVisionModel(model) {
+  if (typeof model !== "string") return false;
+  const id = model.trim().split("/").at(-1);
+  return VISION_MODEL_PATTERNS.some((pattern) => pattern.test(id));
+}
+
 /**
- * Resolve the effective LLM config for a run. When an image is attached, default
- * the provider/model/baseUrl/apiKey to the configured vision LLM so
- * `cc agent --image foo.png` works without extra flags — using `llm.visionModel`
- * (a separate, configurable vision model) and falling back to DEFAULT_VISION_MODEL.
- * Explicit flags always win; with no image, behaviour is unchanged (vision config
- * is ignored). `--vision-model` overrides the configured/default vision model.
+ * Resolve image input using the main model when it supports vision. Only
+ * text-only/unknown main models use llm.visionModel or DEFAULT_VISION_MODEL.
+ * Explicit --model/--vision-model choices take precedence over saved settings.
+ * Without an image, no override is applied.
  *
  * @param {object} p
  * @param {boolean} p.hasImage  true when the run carries an attached image
@@ -301,13 +327,16 @@ export function resolveVisionLlm({ hasImage, flags = {}, llm = {} } = {}) {
       apiKey: undefined,
     };
   }
-  const visionModel =
-    flags.visionModel || llm.visionModel || DEFAULT_VISION_MODEL;
-  // `flags.model` must be the EXPLICIT `--model` (not a settings/default), so an
-  // attached image uses the vision model unless the user deliberately picked one.
+  const mainModel =
+    !flags.provider || !llm.provider || flags.provider === llm.provider
+      ? llm.model
+      : undefined;
+  const visionModel = supportsVisionModel(mainModel)
+    ? mainModel
+    : llm.visionModel || DEFAULT_VISION_MODEL;
   return {
     provider: flags.provider || llm.provider,
-    model: flags.model || visionModel,
+    model: flags.model || flags.visionModel || visionModel,
     baseUrl: flags.baseUrl || llm.baseUrl,
     apiKey: flags.apiKey || llm.apiKey,
   };

package/src/lib/llm-providers.js

@@ -86,6 +86,7 @@ export const BUILT_IN_PROVIDERS = {
     baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
     apiKeyEnv: "VOLCENGINE_API_KEY",
     models: [
+      "deepseek-v4-1-flash-260910",
       "deepseek-v4-flash-ga-260731",
       "deepseek-v4-flash-260425",
       "doubao-seed-2-1-pro-260628",

package/src/lib/plugin-runtime/capabilities.js

@@ -32,6 +32,7 @@ export const CAPABILITY_KINDS = Object.freeze([
   "mcp",
   "monitor",
   "credential",
+  "goalExtension",
 ]);
 
 function toBool(v) {
@@ -92,6 +93,10 @@ export function normalizeCapabilities(raw) {
     mcp: toBool(r.mcp),
     monitor: toBool(r.monitor ?? r.monitors),
     credential: { names: toList(r.credential ?? r.credentials) },
+    // Keep old normalized records unchanged; missing goal grants are deny-all.
+    ...(Object.hasOwn(r, "goalExtension")
+      ? { goalExtension: toList(r.goalExtension) }
+      : {}),
   };
 }
 
@@ -137,6 +142,7 @@ export function diffCapabilities(prev, next) {
   };
   listCap("filesystem", "filesystem", (c) => c.filesystem.roots);
   listCap("credential", "credential", (c) => c.credential.names);
+  listCap("goalExtension", "goalExtension", (c) => c.goalExtension || []);
 
   return { added, removed, widened: added.length > 0 };
 }
@@ -168,6 +174,10 @@ export function describeCapabilities(caps) {
   if (c.monitor) lines.push("monitor: may run background monitors");
   if (c.credential.names.length)
     lines.push(`credential: ${c.credential.names.join(", ")}`);
+  if (c.goalExtension?.length)
+    lines.push(
+      `goalExtension: ${c.goalExtension.join(", ")} (host authorization required)`,
+    );
   return lines;
 }
 

package/src/lib/plugin-runtime/cli-goal-draft-request.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import path from "node:path";
+import { VERSION } from "../../constants.js";
+import { createProjectGoalConnection } from "../project-goal-connection.js";
+import { collectGoalExtensions } from "./goal-extensions.js";
+import { createGoalDraftRequest } from "@chainlesschain/session-core/goal-draft-request-contract";
+import { digestBusinessObjectContent as digest } from "@chainlesschain/session-core/business-object-contract";
+const HOST = Object.freeze({
+  id: "cli",
+  version: VERSION,
+  capabilities: Object.freeze(["proposal:task.description.update"]),
+});
+function fail(code) {
+  throw new Error(code);
+}
+export function readGoalDraftDescription(file) {
+  const target = path.resolve(file),
+    before = fs.lstatSync(target);
+  if (
+    !before.isFile() ||
+    before.isSymbolicLink() ||
+    before.size > 8192 ||
+    before.nlink !== 1
+  )
+    fail("GOAL_DRAFT_DESCRIPTION_INVALID");
+  const fd = fs.openSync(
+    target,
+    fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0),
+  );
+  try {
+    const opened = fs.fstatSync(fd),
+      raw = Buffer.alloc(8193),
+      length = fs.readSync(fd, raw, 0, raw.length, 0),
+      after = fs.fstatSync(fd),
+      current = fs.lstatSync(target);
+    if (
+      length > 8192 ||
+      [opened, after, current].some(
+        (stat) =>
+          stat.dev !== before.dev ||
+          stat.ino !== before.ino ||
+          stat.size !== before.size ||
+          stat.mtimeMs !== before.mtimeMs ||
+          stat.ctimeMs !== before.ctimeMs,
+      )
+    )
+      fail("GOAL_DRAFT_DESCRIPTION_INVALID");
+    return new TextDecoder("utf-8", { fatal: true }).decode(
+      raw.subarray(0, length),
+    );
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+export async function exportCliGoalDraftRequest(id, options = {}) {
+  options = Object.freeze({
+    ...options,
+    env: Object.freeze({ ...(options.env || process.env) }),
+  });
+  const cwd = path.resolve(options.cwd || process.cwd()),
+    env = Object.freeze({ ...(options.env || process.env) });
+  if (
+    !options.connection ||
+    !options.plugin ||
+    !["user", "project", "local"].includes(options.scope) ||
+    !options.descriptionFile ||
+    !options.out
+  )
+    fail("GOAL_DRAFT_EXPORT_ARGUMENTS_REQUIRED");
+  const connection = createProjectGoalConnection(options.connection),
+    snapshot = await connection.read(id);
+  if (
+    options.expectedStore !== undefined &&
+    options.expectedStore !== snapshot.goalRef.storeId
+  )
+    fail("CLI_GOAL_STORE_MISMATCH");
+  const hostOptions = {
+    cwd,
+    env,
+    host: HOST,
+    managedSettingsFile: options.managedSettingsFile,
+  };
+  const admitted = () =>
+    collectGoalExtensions(hostOptions).extensions.find(
+      (entry) => entry.name === options.plugin && entry.scope === options.scope,
+    );
+  const plugin = admitted();
+  if (
+    !plugin ||
+    !plugin.declaration.proposals.includes("task.description.update")
+  )
+    fail("GOAL_DRAFT_PLUGIN_NOT_ADMITTED");
+  const request = createGoalDraftRequest({
+    declaredPlugin: {
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    },
+    declarationDigest: digest(plugin.declaration),
+    proposal: {
+      type: "task.description.update",
+      goalRef: snapshot.goalRef,
+      sourceRef: options.source,
+      requestId: options.requestId,
+      title: options.title,
+      description: readGoalDraftDescription(
+        path.resolve(cwd, options.descriptionFile),
+      ),
+    },
+  });
+  const latest = await connection.read(id),
+    current = admitted();
+  if (
+    !current ||
+    digest(current) !== digest(plugin) ||
+    latest.objective !== snapshot.objective ||
+    latest.status !== snapshot.status ||
+    digest(latest.goalRef) !== digest(snapshot.goalRef)
+  )
+    fail("GOAL_DRAFT_EXPORT_SOURCE_CHANGED");
+  const file = path.resolve(cwd, options.out),
+    fd = fs.openSync(file, "wx", 0o600);
+  try {
+    fs.writeFileSync(fd, JSON.stringify(request));
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  return {
+    schema: "chainlesschain.goal-draft-export/v1",
+    state: "request-exported",
+    goalRef: request.proposal.goalRef,
+    declaredPlugin: request.declaredPlugin,
+    requestId: request.proposal.requestId,
+    contentDigest: request.contentDigest,
+    file,
+  };
+}