@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/cli/lib/merge-plugin-tree.ts

@@ -0,0 +1,228 @@
+/**
+ * Three-way merge of a plugin tree, used by `plugins upgrade --strategy` to
+ * carry local edits forward across an upgrade instead of discarding them.
+ *
+ * An upgrade has three inputs, exactly like a git merge:
+ * - **base** — the tree the plugin was installed at (the recorded commit,
+ *   re-materialized through the install pipeline; see {@link ./diff-plugin}).
+ * - **ours** — the current on-disk install, carrying any local edits.
+ * - **theirs** — the marketplace's current pin, the tree being upgraded to.
+ *
+ * Per file the merge is delegated to `git merge-file`, the same line-level
+ * three-way algorithm git itself uses: a hunk edited on only one side is taken
+ * from that side, so non-conflicting edits from *both* sides survive. Only a
+ * hunk edited differently on both sides is a true conflict, resolved by the
+ * caller's strategy — `--ours` keeps the local hunk, `--theirs` the pinned one.
+ * File-level add/delete divergence (a file added, removed, or modified on only
+ * one side) is resolved here before any line merge, since `git merge-file`
+ * operates on three existing blobs.
+ *
+ * Binary files cannot be line-merged, so a binary file that diverged on both
+ * sides is resolved whole-file by the strategy rather than corrupted with
+ * conflict markers.
+ *
+ * The `overwrite` strategy never reaches here — it discards local edits and is
+ * a plain re-install at the pin. The `assistant` strategy is not yet supported.
+ */
+
+import { execFile } from "node:child_process";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+
+import { INSTALL_META_FILENAME } from "./install-from-github.js";
+import { computeFingerprint } from "./plugin-fingerprint.js";
+
+const execFileAsync = promisify(execFile);
+
+/** Cap on a single `git merge-file`; a per-file line merge is near-instant. */
+const MERGE_TIMEOUT_MS = 30_000;
+
+/**
+ * Conflict-resolution strategy for the hunks `git merge-file` cannot
+ * auto-resolve. `overwrite` and `assistant` are not merge strategies and are
+ * handled by the caller before a merge is attempted.
+ */
+export type MergeConflictStrategy = "ours" | "theirs";
+
+/** Inputs for a three-way plugin-tree merge. */
+export interface MergePluginTreeOptions {
+  /** Re-materialized install-commit tree (the merge base). */
+  readonly baseDir: string;
+  /** Current on-disk install, carrying local edits (`ours`). */
+  readonly oursDir: string;
+  /** Marketplace-pinned tree being upgraded to (`theirs`). */
+  readonly theirsDir: string;
+  /** Empty directory the merged tree is written into. */
+  readonly destDir: string;
+  /** How to resolve hunks edited differently on both sides. */
+  readonly strategy: MergeConflictStrategy;
+}
+
+/** A NUL byte in the leading bytes is the heuristic git uses to flag a blob as binary. */
+function isBinary(buf: Buffer): boolean {
+  const len = Math.min(buf.length, 8000);
+  for (let i = 0; i < len; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+
+/** Write `content` to `destDir/rel`, creating parent directories as needed. */
+function writeInto(destDir: string, rel: string, content: Buffer): void {
+  const abs = join(destDir, rel);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, content);
+}
+
+/**
+ * Line-merge three blobs with `git merge-file`, resolving conflicting hunks
+ * toward `strategy`. Non-conflicting hunks from both sides are always kept.
+ * Binary input cannot be line-merged: a side that matches the base did not
+ * change, so the other side's edit is taken; only a blob changed on *both*
+ * sides is a true conflict resolved whole-file by `strategy`, avoiding a
+ * marker-corrupted blob.
+ */
+async function threeWayMergeFile(
+  ours: Buffer,
+  base: Buffer,
+  theirs: Buffer,
+  strategy: MergeConflictStrategy,
+): Promise<Buffer> {
+  if (isBinary(ours) || isBinary(base) || isBinary(theirs)) {
+    if (ours.equals(base)) return theirs;
+    if (theirs.equals(base)) return ours;
+    return strategy === "ours" ? ours : theirs;
+  }
+
+  const scratch = mkdtempSync(join(tmpdir(), "plugin-merge-file-"));
+  try {
+    const oursPath = join(scratch, "ours");
+    const basePath = join(scratch, "base");
+    const theirsPath = join(scratch, "theirs");
+    writeFileSync(oursPath, ours);
+    writeFileSync(basePath, base);
+    writeFileSync(theirsPath, theirs);
+
+    // `-p` prints the merged result to stdout instead of editing `ours` in
+    // place; `--ours`/`--theirs` auto-resolve conflicting hunks toward that
+    // side (so no markers are ever written). `git merge-file` exits non-zero
+    // when conflicts remained — impossible with a resolving flag, but stdout
+    // still carries the merged bytes, so capture it from the error too.
+    const args = [
+      "merge-file",
+      "-p",
+      `--${strategy}`,
+      oursPath,
+      basePath,
+      theirsPath,
+    ];
+    try {
+      const { stdout } = await execFileAsync("git", args, {
+        cwd: scratch,
+        encoding: "buffer",
+        timeout: MERGE_TIMEOUT_MS,
+        maxBuffer: 64 * 1024 * 1024,
+      });
+      return stdout;
+    } catch (err) {
+      const stdout = (err as { stdout?: Buffer }).stdout;
+      if (Buffer.isBuffer(stdout)) return stdout;
+      throw err;
+    }
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Three-way merge `oursDir`/`theirsDir` against `baseDir` into `destDir`,
+ * resolving conflicts toward `strategy`. The provenance sidecar is excluded on
+ * every side — it is rewritten by the caller after the swap and must not be
+ * carried through the merge.
+ *
+ * Returns the number of files written into `destDir`.
+ */
+export async function mergePluginTree({
+  baseDir,
+  oursDir,
+  theirsDir,
+  destDir,
+  strategy,
+}: MergePluginTreeOptions): Promise<number> {
+  const exclude = [INSTALL_META_FILENAME];
+  const base = computeFingerprint(baseDir, exclude).files;
+  const ours = computeFingerprint(oursDir, exclude).files;
+  const theirs = computeFingerprint(theirsDir, exclude).files;
+
+  const paths = new Set([
+    ...Object.keys(base),
+    ...Object.keys(ours),
+    ...Object.keys(theirs),
+  ]);
+
+  const readBase = (rel: string) => readFileSync(join(baseDir, rel));
+  const readOurs = (rel: string) => readFileSync(join(oursDir, rel));
+  const readTheirs = (rel: string) => readFileSync(join(theirsDir, rel));
+
+  let fileCount = 0;
+  const keep = (rel: string, content: Buffer): void => {
+    writeInto(destDir, rel, content);
+    fileCount++;
+  };
+
+  for (const rel of paths) {
+    const b = base[rel];
+    const o = ours[rel];
+    const t = theirs[rel];
+
+    if (o !== undefined && t !== undefined) {
+      // Present on both sides: identical needs no merge; otherwise line-merge
+      // (an empty base when the file was added on both sides).
+      if (o === t) {
+        keep(rel, readOurs(rel));
+      } else {
+        const merged = await threeWayMergeFile(
+          readOurs(rel),
+          b !== undefined ? readBase(rel) : Buffer.alloc(0),
+          readTheirs(rel),
+          strategy,
+        );
+        keep(rel, merged);
+      }
+      continue;
+    }
+
+    if (o !== undefined) {
+      // Present only locally. A local-only addition (no base) always survives.
+      // A file deleted upstream is a delete: drop it when unchanged locally,
+      // and on a modify/delete conflict let the strategy decide.
+      if (b === undefined || (b !== o && strategy === "ours")) {
+        keep(rel, readOurs(rel));
+      }
+      continue;
+    }
+
+    if (t !== undefined) {
+      // Present only at the pin. A remote-only addition (no base) always lands.
+      // A file deleted locally is a delete: keep upstream's removal when the
+      // pin left it unchanged, and on a delete/modify conflict let the strategy
+      // decide.
+      if (b === undefined || (b !== t && strategy === "theirs")) {
+        keep(rel, readTheirs(rel));
+      }
+      continue;
+    }
+
+    // Present only in the base: removed on both sides, so it stays removed.
+  }
+
+  return fileCount;
+}

package/src/cli/lib/plugin-fingerprint.ts

@@ -120,6 +120,20 @@ export function compareFingerprint(
   };
 }
 
+/**
+ * Whether two fingerprints cover the same files with identical digests. Used to
+ * confirm a re-materialized tree faithfully reproduces a recorded baseline
+ * before it is trusted as a merge base.
+ */
+export function fingerprintsEqual(a: Fingerprint, b: Fingerprint): boolean {
+  const aKeys = Object.keys(a.files);
+  if (aKeys.length !== Object.keys(b.files).length) return false;
+  for (const key of aKeys) {
+    if (a.files[key] !== b.files[key]) return false;
+  }
+  return true;
+}
+
 /**
  * Parse a fingerprint from already-decoded JSON. Lenient by design — any shape
  * problem yields `null` so an older or hand-edited sidecar simply reports "no

package/src/cli/lib/upgrade-plugin.ts

@@ -10,14 +10,17 @@
  * This is deliberately a distinct operation from install: `install` is
  * first-time materialization (and errors on an existing install unless
  * `--force` is passed), whereas `upgrade` moves an existing install forward.
- * Mechanically the move is a forced re-install at the current pin, which the
- * underlying {@link ./install-from-github.installPlugin} performs atomically —
- * the previously installed copy is preserved until the fetch succeeds.
  *
- * Conflict resolution for locally-modified plugins is intentionally out of
- * scope here: this overwrites the install with the pinned tree. A future
- * iteration will detect local edits (installed SHA = merge base) and resolve
- * them before the swap.
+ * How local edits are reconciled with the pin is controlled by the
+ * {@link PluginUpgradeStrategy}. `overwrite` (the default) moves via a forced
+ * re-install at the current pin — the underlying
+ * {@link ./install-from-github.installPlugin} performs that atomically, and the
+ * previously installed copy (including any local edits) is replaced wholesale.
+ * `ours`/`theirs` instead three-way merge the on-disk tree and the pin against
+ * the re-materialized install commit so non-conflicting local edits survive,
+ * resolving conflicting hunks toward the local edit or the pin respectively.
+ * `assistant` is reserved for assistant-driven conflict resolution and is not
+ * yet implemented.
  *
  * Designed for direct programmatic use with injected dependencies, mirroring
  * the sibling plugin libraries. The CLI command `assistant plugins upgrade
@@ -25,24 +28,66 @@
  * result.
  */
 
-import { join } from "node:path";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import {
   inspectPlugin,
   type PluginInspection,
   PluginInspectNotFoundError,
+  type PluginLocalInfo,
+  type PluginRemoteInfo,
 } from "./inspect-plugin.js";
 import {
+  DEFAULT_PLUGIN_REF,
   type FetchLike,
+  finalizeStagedInstall,
   type GitRunner,
+  INSTALL_META_FILENAME,
   installPlugin,
+  materializePluginTree,
+  type PluginFetchSource,
+  PluginNotFoundError,
   PluginSourceUnavailableError,
   type PostinstallRunner,
+  readInstallMeta,
   sanitizePluginName,
 } from "./install-from-github.js";
+import { mergePluginTree } from "./merge-plugin-tree.js";
+import { computeFingerprint, fingerprintsEqual } from "./plugin-fingerprint.js";
 import { PluginNotInstalledError } from "./uninstall-plugin.js";
 
+/**
+ * How local edits to an installed plugin are reconciled with the marketplace
+ * pin during an upgrade.
+ *
+ * - `overwrite` (default) — discard all local edits and re-install the pin
+ *   wholesale. Matches the historical upgrade behavior.
+ * - `ours` — three-way merge; conflicting hunks resolve toward the local edit.
+ * - `theirs` — three-way merge; conflicting hunks resolve toward the pin.
+ * - `assistant` — hand conflicts to the assistant to resolve (not yet
+ *   implemented).
+ */
+export type PluginUpgradeStrategy =
+  | "ours"
+  | "theirs"
+  | "overwrite"
+  | "assistant";
+
+/** The set of accepted `--strategy` values, for validation and help text. */
+export const PLUGIN_UPGRADE_STRATEGIES: readonly PluginUpgradeStrategy[] = [
+  "ours",
+  "theirs",
+  "overwrite",
+  "assistant",
+];
+
+/** The strategy applied when a caller omits `--strategy`. */
+export const DEFAULT_PLUGIN_UPGRADE_STRATEGY: PluginUpgradeStrategy =
+  "overwrite";
+
 /**
  * Outcome of an upgrade attempt.
  *
@@ -61,6 +106,11 @@ export interface UpgradePluginOptions {
   readonly name: string;
   /** Report what would change without modifying the install. */
   readonly dryRun?: boolean;
+  /**
+   * How to reconcile local edits with the pin. Defaults to
+   * {@link DEFAULT_PLUGIN_UPGRADE_STRATEGY}.
+   */
+  readonly strategy?: PluginUpgradeStrategy;
 }
 
 /** Dependencies injected by the caller. */
@@ -99,6 +149,8 @@ export interface PluginUpgradeResult {
   readonly fileCount: number | null;
   /** Whether this was a dry run (no changes made). */
   readonly dryRun: boolean;
+  /** Conflict-resolution strategy the upgrade applied. */
+  readonly strategy: PluginUpgradeStrategy;
   /**
    * Whether the installed copy lacked resolvable provenance before the
    * upgrade. Such installs are re-pinned to the current SHA, which also
@@ -118,6 +170,32 @@ export class PluginNotUpgradableError extends Error {
   }
 }
 
+/** A requested merge strategy is recognized but not yet implemented. */
+export class PluginUpgradeStrategyUnsupportedError extends Error {
+  constructor(readonly strategy: PluginUpgradeStrategy) {
+    super(
+      `Upgrade strategy "${strategy}" is not yet supported. Use one of: ours, theirs, overwrite.`,
+    );
+    this.name = "PluginUpgradeStrategyUnsupportedError";
+  }
+}
+
+/**
+ * A merge strategy (`ours`/`theirs`) was requested but the install-time
+ * baseline needed for a three-way merge cannot be reconstructed.
+ */
+export class PluginMergeBaselineError extends Error {
+  constructor(
+    readonly pluginName: string,
+    reason: string,
+  ) {
+    super(
+      `Plugin "${pluginName}" cannot be merge-upgraded: ${reason}. Use '--strategy overwrite' to take the pin wholesale, or reinstall with 'plugins install ${pluginName} --force'.`,
+    );
+    this.name = "PluginMergeBaselineError";
+  }
+}
+
 function pluginTarget(name: string, deps: UpgradePluginDeps): string {
   const dir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
   return join(dir, name);
@@ -126,10 +204,19 @@ function pluginTarget(name: string, deps: UpgradePluginDeps): string {
 /**
  * Move an installed plugin to the marketplace's current pin.
  *
+ * The `strategy` controls how local edits are reconciled with the pin:
+ * `overwrite` (default) re-installs the pin wholesale; `ours`/`theirs` do a
+ * three-way merge that carries non-conflicting local edits forward, resolving
+ * conflicting hunks toward the local edit or the pin respectively; `assistant`
+ * is not yet implemented.
+ *
  * Throws {@link PluginNotInstalledError} when no copy is installed,
  * {@link PluginNotUpgradableError} when the install has no marketplace entry to
- * advance to, {@link PluginSourceUnavailableError} when the marketplace catalog
- * is temporarily unreachable (a retryable outage, distinct from the permanent
+ * advance to, {@link PluginUpgradeStrategyUnsupportedError} for the `assistant`
+ * strategy, {@link PluginMergeBaselineError} when a merge strategy is requested
+ * but the install-time baseline cannot be reconstructed,
+ * {@link PluginSourceUnavailableError} when the marketplace catalog is
+ * temporarily unreachable (a retryable outage, distinct from the permanent
  * no-entry case), and propagates {@link installPlugin}'s errors (e.g. source
  * unavailable, postinstall failure) when the re-install itself fails.
  */
@@ -139,6 +226,11 @@ export async function upgradePlugin(
 ): Promise<PluginUpgradeResult> {
   const name = sanitizePluginName(opts.name);
   const dryRun = opts.dryRun ?? false;
+  const strategy = opts.strategy ?? DEFAULT_PLUGIN_UPGRADE_STRATEGY;
+
+  if (strategy === "assistant") {
+    throw new PluginUpgradeStrategyUnsupportedError(strategy);
+  }
 
   let inspection: PluginInspection;
   try {
@@ -199,6 +291,7 @@ export async function upgradePlugin(
       target: local.target,
       fileCount: null,
       dryRun,
+      strategy,
       provenanceWasUnknown: false,
     };
   }
@@ -214,10 +307,28 @@ export async function upgradePlugin(
       target: local.target,
       fileCount: null,
       dryRun: true,
+      strategy,
       provenanceWasUnknown,
     };
   }
 
+  // `ours`/`theirs` carry local edits forward via a three-way merge; the
+  // default `overwrite` discards them and re-installs the pin wholesale.
+  if (strategy === "ours" || strategy === "theirs") {
+    return mergeUpgrade(
+      {
+        name,
+        strategy,
+        local,
+        remote,
+        fromCommit,
+        fromTimestamp,
+        provenanceWasUnknown,
+      },
+      deps,
+    );
+  }
+
   const result = await installPlugin(
     { name, force: true },
     {
@@ -238,6 +349,155 @@ export async function upgradePlugin(
     target: result.target,
     fileCount: result.fileCount,
     dryRun: false,
+    strategy,
     provenanceWasUnknown,
   };
 }
+
+/**
+ * Carry local edits forward by three-way merging the on-disk install (`ours`)
+ * and the marketplace pin (`theirs`) against the re-materialized install commit
+ * (`base`), then atomically swapping the merged tree into place pinned at the
+ * new commit. Conflicting hunks resolve toward `ours` or `theirs` per the
+ * strategy; non-conflicting edits from both sides survive.
+ */
+async function mergeUpgrade(
+  ctx: {
+    readonly name: string;
+    readonly strategy: "ours" | "theirs";
+    readonly local: PluginLocalInfo;
+    readonly remote: PluginRemoteInfo;
+    readonly fromCommit: string | null;
+    readonly fromTimestamp: string | null;
+    readonly provenanceWasUnknown: boolean;
+  },
+  deps: UpgradePluginDeps,
+): Promise<PluginUpgradeResult> {
+  const { name, strategy, local, remote } = ctx;
+
+  const meta = readInstallMeta(local.target);
+  if (!meta || !meta.commit || !meta.fingerprint) {
+    throw new PluginMergeBaselineError(
+      name,
+      "no install commit or fingerprint was recorded (an older or manually-copied install)",
+    );
+  }
+  const recorded = meta.fingerprint;
+
+  const baseSource: PluginFetchSource = {
+    owner: meta.source.owner,
+    repo: meta.source.repo,
+    rootPath: meta.source.path ?? "",
+    ref: meta.commit,
+  };
+  const [remoteOwner, remoteRepo] = remote.repo.split("/");
+  const theirsSource: PluginFetchSource = {
+    owner: remoteOwner ?? "",
+    repo: remoteRepo ?? "",
+    rootPath: remote.path,
+    ref: remote.commit,
+  };
+
+  const pluginsDir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
+  const baseDir = mkdtempSync(join(tmpdir(), `plugin-upgrade-base-${name}-`));
+  const theirsDir = mkdtempSync(
+    join(tmpdir(), `plugin-upgrade-theirs-${name}-`),
+  );
+  // Stage outside the served `plugins/` directory and on its filesystem so the
+  // final swap is an atomic rename, mirroring `installPlugin`.
+  const stagingRoot = join(dirname(pluginsDir), ".plugins-staging");
+  mkdirSync(stagingRoot, { recursive: true });
+  const stagingDir = join(stagingRoot, `${name}.upgrading.${process.pid}`);
+  if (existsSync(stagingDir)) {
+    rmSync(stagingDir, { recursive: true, force: true });
+  }
+  mkdirSync(stagingDir, { recursive: true });
+
+  try {
+    const base = await materializePluginTree(
+      {
+        source: baseSource,
+        name,
+        stubRef: DEFAULT_PLUGIN_REF,
+        destDir: baseDir,
+      },
+      deps,
+    );
+    if (base.fileCount === 0) {
+      throw new PluginNotFoundError(
+        name,
+        baseSource.ref,
+        `${baseSource.owner}/${baseSource.repo}`,
+      );
+    }
+    // The merge base must faithfully reproduce what install materialized;
+    // otherwise a curated adapter overlay that moved since install would read
+    // as base→ours/theirs edits and corrupt the merge. Verify against the
+    // recorded fingerprint, exactly as `plugins diff` does.
+    const baseFingerprint = computeFingerprint(baseDir, [
+      INSTALL_META_FILENAME,
+    ]);
+    if (!fingerprintsEqual(baseFingerprint, recorded)) {
+      throw new PluginMergeBaselineError(
+        name,
+        "the install-time baseline could not be faithfully reconstructed (a curated adapter overlay it was built from has changed since install)",
+      );
+    }
+
+    const theirs = await materializePluginTree(
+      {
+        source: theirsSource,
+        name,
+        stubRef: remote.marketplaceRef,
+        destDir: theirsDir,
+      },
+      deps,
+    );
+    if (theirs.fileCount === 0) {
+      throw new PluginNotFoundError(
+        name,
+        theirsSource.ref,
+        `${theirsSource.owner}/${theirsSource.repo}`,
+      );
+    }
+
+    const fileCount = await mergePluginTree({
+      baseDir,
+      oursDir: local.target,
+      theirsDir,
+      destDir: stagingDir,
+      strategy,
+    });
+
+    const toCommit = theirs.commit ?? remote.commit;
+    const toTimestamp = theirs.committedAt ?? remote.committedAt;
+    finalizeStagedInstall(stagingDir, {
+      name,
+      source: theirsSource,
+      ref: theirsSource.ref,
+      commit: toCommit,
+      committedAt: toTimestamp,
+      pluginsDir,
+    });
+
+    return {
+      name,
+      outcome: "upgraded",
+      fromCommit: ctx.fromCommit,
+      fromTimestamp: ctx.fromTimestamp,
+      toCommit,
+      toTimestamp,
+      target: join(pluginsDir, name),
+      fileCount,
+      dryRun: false,
+      strategy,
+      provenanceWasUnknown: ctx.provenanceWasUnknown,
+    };
+  } catch (err) {
+    rmSync(stagingDir, { recursive: true, force: true });
+    throw err;
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+    rmSync(theirsDir, { recursive: true, force: true });
+  }
+}

package/src/cli/program.ts

@@ -47,7 +47,6 @@ import { registerSequenceCommand } from "./commands/sequence.js";
 import { registerSkillsCommand } from "./commands/skills.js";
 import { registerStatusCommand } from "./commands/status.js";
 import { registerSttCommand } from "./commands/stt.js";
-import { registerTaskCommand } from "./commands/task.js";
 import { registerTelemetryCommand } from "./commands/telemetry.js";
 import { registerToolsCommand } from "./commands/tools.js";
 import { registerTrustCommand } from "./commands/trust.js";
@@ -146,7 +145,6 @@ Examples:
   registerStatusCommand(program);
   registerSkillsCommand(program);
   registerSttCommand(program);
-  registerTaskCommand(program);
   registerTelemetryCommand(program);
   registerToolsCommand(program);
   registerTrustCommand(program);

package/src/config/bundled-skills/subagent/SKILL.md

@@ -71,6 +71,10 @@ Only the parent conversation that spawned a subagent can interact with it (check
 
 Set `send_result_to_user: false` when spawning a subagent whose result is for internal processing only. The parent will still be notified on completion, but the notification will instruct it to read the result without presenting it to the user.
 
+## Inference Profile
+
+Set `inference_profile` to an `llm.profiles` key when a subagent should run under a specific model profile. When omitted, the subagent inherits the parent turn's active profile if one exists; otherwise it uses the `subagentSpawn` call site's default model selection.
+
 ## Fork Mode
 
 Forks are sub-agents that inherit the parent's full context -- messages, system prompt, and memory -- sharing the KV cache for near-free context inheritance. Use forks when the task benefits from knowing what you've been discussing; use a regular sub-agent when the task is self-contained.

package/src/config/bundled-skills/subagent/TOOLS.json

@@ -39,6 +39,10 @@
               "investigator"
             ],
             "description": "Agent specialization that controls tool access. 'researcher': read-only (web, files, memory). 'coder': file and bash access. 'planner': read-only analysis. 'investigator': root-cause analysis — debugging, log forensics, tracing behavior across many files; has bash for read-only investigation (grep/find/log inspection) and returns a compact root-cause report. 'general': full access (default). Ignored when fork: true (forks always use general)."
+          },
+          "inference_profile": {
+            "type": "string",
+            "description": "Optional llm.profiles key this subagent should run under. When omitted, the subagent inherits the parent turn's profile when one is active; otherwise it uses the subagentSpawn call site's default model selection."
           }
         },
         "required": ["label", "objective"]

package/src/config/bundled-skills/workflows/SKILL.md

@@ -7,7 +7,6 @@ metadata:
   vellum:
     display-name: "Workflows"
     category: "system"
-    feature-flag: "workflows"
     activation-hints:
       - "A task decomposes into many similar sub-tasks that can run concurrently (score every item, extract a field from each of many documents, draft-then-verify a batch)"
       - "You want fan-out orchestrated deterministically and the result reported back when the whole run finishes"