@love-moon/conductor-cli 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @love-moon/conductor-cli
 
+## 0.7.0
+
+### Minor Changes
+
+- 689fc50: Add scheduled message management APIs and conductor task schedule list/create/delete commands.
+
+### Patch Changes
+
+- Updated dependencies [689fc50]
+  - @love-moon/conductor-sdk@0.7.0
+  - @love-moon/ai-sdk@0.7.0
+
 ## 0.6.1
 
 ### Patch Changes

package/bin/conductor-channel.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { loadConfig } from "@love-moon/conductor-sdk";
+import { envForExplicitConfigFile } from "../src/config-env.js";
 
 const isMainModule = (() => {
   const currentFile = fileURLToPath(import.meta.url);
@@ -56,7 +57,9 @@ export async function connectFeishuChannel(options = {}) {
 
   const resolvedConfigPath = path.resolve(options.configFile || resolveDefaultConfigPath(env));
   const rawYaml = readTextFile(resolvedConfigPath);
-  const config = loadConfig(resolvedConfigPath, { env });
+  const config = loadConfig(resolvedConfigPath, {
+    env: envForExplicitConfigFile(options.configFile, env),
+  });
   const feishu = ensureFeishuChannelConfig(config);
 
   const url = new URL("/api/channel/feishu/config", config.backendUrl);

package/bin/conductor-config.js

@@ -63,7 +63,7 @@ const DEFAULT_CLIs = {
 const backendUrl =
   process.env.CONDUCTOR_BACKEND_URL ||
   process.env.BACKEND_URL ||
-  "https://conductor-ai.top";
+  "https://conductor.conductor-ai.top";
 const defaultDaemonName = os.hostname() || "my-daemon";
 const cliVersion = packageJson.version || "unknown";
 const OPENCODE_INSTALL_URL = "https://opencode.ai/install";

package/bin/conductor-fire.js

@@ -2543,26 +2543,35 @@ export class BridgeRunner {
   async handleInterruptedTurn(replyTo, interruptInfo) {
     const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
     this.clearInterruptRetryForReplyTarget(normalizedReplyTo);
-    this.copilotLog(`turn interrupted replyTo=${normalizedReplyTo || "latest"}`);
-    await this.reportRuntimeStatus(
-      {
-        phase: "interrupted",
-        reply_in_progress: false,
-        status_done_line: "Conversation interrupted",
-      },
-      normalizedReplyTo,
+    // An insert is implemented as "interrupt the running turn so the just
+    // inserted message runs next". In that case we deliberately suppress the
+    // "Conversation interrupted" confirmation so the insertion feels seamless:
+    // the inserted user message + its fresh reply are all the user should see.
+    const isInsertInterrupt = interruptInfo?.reason === "user_insert";
+    this.copilotLog(
+      `turn interrupted replyTo=${normalizedReplyTo || "latest"}${isInsertInterrupt ? " (insert)" : ""}`,
     );
-    try {
-      await this.conductor.sendMessage(this.taskId, "Conversation interrupted", {
-        backend: this.backendName,
-        reply_to: normalizedReplyTo || undefined,
-        interrupted: true,
-        interruption_request_id: interruptInfo?.requestId || undefined,
-        reason: interruptInfo?.reason || undefined,
-        cli_args: this.cliArgs,
-      });
-    } catch (error) {
-      log(`Failed to send interrupt confirmation for ${this.taskId}: ${error?.message || error}`);
+    if (!isInsertInterrupt) {
+      await this.reportRuntimeStatus(
+        {
+          phase: "interrupted",
+          reply_in_progress: false,
+          status_done_line: "Conversation interrupted",
+        },
+        normalizedReplyTo,
+      );
+      try {
+        await this.conductor.sendMessage(this.taskId, "Conversation interrupted", {
+          backend: this.backendName,
+          reply_to: normalizedReplyTo || undefined,
+          interrupted: true,
+          interruption_request_id: interruptInfo?.requestId || undefined,
+          reason: interruptInfo?.reason || undefined,
+          cli_args: this.cliArgs,
+        });
+      } catch (error) {
+        log(`Failed to send interrupt confirmation for ${this.taskId}: ${error?.message || error}`);
+      }
     }
     if (normalizedReplyTo) {
       this.processedMessageIds.add(normalizedReplyTo);

package/bin/conductor-send-file.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from "node:url";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
+import { envForExplicitConfigFile } from "../src/config-env.js";
 
 const DEFAULT_MIME_TYPE = "application/octet-stream";
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".conductor", "config.yaml");
@@ -110,8 +111,9 @@ export function detectTaskId(options = {}) {
 
 function loadCliConfig(configFile, env = process.env) {
   const configPath = configFile ? path.resolve(configFile) : DEFAULT_CONFIG_PATH;
+  const configEnv = envForExplicitConfigFile(configFile, env);
   if (fs.existsSync(configPath)) {
-    return loadConfig(configPath, { env });
+    return loadConfig(configPath, { env: configEnv });
   }
 
   const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
@@ -123,7 +125,7 @@ function loadCliConfig(configFile, env = process.env) {
     });
   }
 
-  return loadConfig(configPath, { env });
+  return loadConfig(configPath, { env: configEnv });
 }
 
 export function guessMimeType(fileName, preferredMimeType = "") {

package/bin/conductor-task.js

@@ -7,7 +7,11 @@
  *   list [--project ...] [--issue <id>] [--status ...]
  *   show <id>
  *   send <id> [<message>] [--stdin] [--from-file FILE] [--metadata-json '{...}']
+ *   insert <id> [<message>] [--stdin] [--from-file FILE] [--target-reply-to <msg-id>]
  *   messages <id> [--limit N] [--before <msg-id>]
+ *   schedule list <id>
+ *   schedule create <id> [<message>] (--delay 10m | --at ISO | --every 1h)
+ *   schedule delete <id> <schedule-id>
  *
  * Global flags supported on every write subcommand:
  *   --json, --dry-run, --project, --config-file
@@ -85,6 +89,133 @@ function parseMetadataJson(value) {
   }
 }
 
+function parseDuration(value, label) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  const match = raw.match(/^(\d+)\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours)$/);
+  if (!match) {
+    const err = new Error(`${label} must look like 10m, 2h, 10 minutes, or 2 hours`);
+    err.code = "ARGS";
+    throw err;
+  }
+  const amount = Number.parseInt(match[1], 10);
+  if (!Number.isInteger(amount) || amount <= 0) {
+    const err = new Error(`${label} must be a positive duration`);
+    err.code = "ARGS";
+    throw err;
+  }
+  return {
+    amount,
+    unit: match[2].startsWith("h") ? "hour" : "minute",
+  };
+}
+
+function parseFutureIso(value, label) {
+  const raw = String(value ?? "").trim();
+  const date = new Date(raw);
+  if (!raw || !Number.isFinite(date.getTime())) {
+    const err = new Error(`${label} must be a valid date/time string`);
+    err.code = "ARGS";
+    throw err;
+  }
+  return date.toISOString();
+}
+
+function parsePositiveIntegerOption(value, label) {
+  if (value === undefined || value === null) return undefined;
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    const err = new Error(`${label} must be a positive integer`);
+    err.code = "ARGS";
+    throw err;
+  }
+  return parsed;
+}
+
+function parseScheduleOptions(argv) {
+  const modes = [
+    argv.delay !== undefined ? "delay" : null,
+    argv.at !== undefined ? "at" : null,
+    argv.every !== undefined ? "every" : null,
+  ].filter(Boolean);
+  if (modes.length !== 1) {
+    const err = new Error("Provide exactly one schedule mode: --delay, --at, or --every");
+    err.code = "ARGS";
+    throw err;
+  }
+
+  if (argv.delay !== undefined) {
+    const parsed = parseDuration(argv.delay, "--delay");
+    return {
+      mode: "delay",
+      amount: parsed.amount,
+      unit: parsed.unit,
+    };
+  }
+
+  if (argv.at !== undefined) {
+    return {
+      mode: "at",
+      sendAt: parseFutureIso(argv.at, "--at"),
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    };
+  }
+
+  const parsed = parseDuration(argv.every, "--every");
+  const stop = {
+    stopWhenTaskNotRunning: !argv.keepWhenTaskStopped,
+  };
+  const maxRuns = parsePositiveIntegerOption(argv.maxRuns, "--max-runs");
+  const maxSkips = parsePositiveIntegerOption(argv.maxSkips, "--max-skips");
+  if (maxRuns !== undefined) {
+    stop.maxRuns = maxRuns;
+  }
+  if (maxSkips !== undefined) {
+    stop.maxSkips = maxSkips;
+  }
+  if (argv.stopAt !== undefined) {
+    stop.stopAt = parseFutureIso(argv.stopAt, "--stop-at");
+  }
+
+  return {
+    mode: "interval",
+    every: parsed.amount,
+    unit: parsed.unit,
+    condition: argv.ifIdle ? "ai_idle" : "none",
+    stop,
+  };
+}
+
+function scheduledMessageAsObject(schedule) {
+  if (!schedule) return null;
+  if (typeof schedule.asObject === "function") return schedule.asObject();
+  return {
+    id: schedule.id,
+    taskId: schedule.taskId ?? schedule.task_id,
+    sourceMessageId: schedule.sourceMessageId ?? schedule.source_message_id ?? null,
+    content: schedule.content,
+    kind: schedule.kind,
+    condition: schedule.condition,
+    status: schedule.status,
+    nextRunAt: schedule.nextRunAt ?? schedule.next_run_at,
+    runCount: schedule.runCount ?? schedule.run_count ?? 0,
+    skipCount: schedule.skipCount ?? schedule.skip_count ?? 0,
+    failureCount: schedule.failureCount ?? schedule.failure_count ?? 0,
+    maxRuns: schedule.maxRuns ?? schedule.max_runs ?? null,
+    maxSkips: schedule.maxSkips ?? schedule.max_skips ?? null,
+    stopAt: schedule.stopAt ?? schedule.stop_at ?? null,
+    lastRunAt: schedule.lastRunAt ?? schedule.last_run_at ?? null,
+    lastError: schedule.lastError ?? schedule.last_error ?? null,
+    createdAt: schedule.createdAt ?? schedule.created_at ?? null,
+    updatedAt: schedule.updatedAt ?? schedule.updated_at ?? null,
+  };
+}
+
+function formatContentPreview(value) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= 60) return text;
+  return `${text.slice(0, 57)}...`;
+}
+
 async function handleList(argv, deps) {
   const apis = await buildApis(deps);
   const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
@@ -182,6 +313,48 @@ async function handleSend(argv, deps) {
   return EXIT.OK;
 }
 
+async function handleInsert(argv, deps) {
+  const apis = await buildApis(deps);
+  const content = readMessageInput({
+    positional: argv.message,
+    fromFile: argv.fromFile,
+    useStdin: Boolean(argv.stdin),
+    stdin: deps.stdin,
+  });
+  const extraMetadata = parseMetadataJson(argv.metadataJson);
+  const metadata = buildAuditMetadata(deps.env, extraMetadata || {});
+  const body = {
+    content,
+    metadata,
+  };
+  if (argv.targetReplyTo) {
+    body.target_reply_to = String(argv.targetReplyTo);
+  }
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "POST",
+        `${buildBaseUrl(apis.config)}/api/tasks/${encodeURIComponent(argv.id)}/insert`,
+        body,
+      ),
+    );
+    return EXIT.OK;
+  }
+  const result = await apis.tasks.insertTaskMessage(argv.id, content, {
+    metadata: body.metadata,
+    targetReplyTo: argv.targetReplyTo ? String(argv.targetReplyTo) : undefined,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, result ?? { inserted: true });
+    return EXIT.OK;
+  }
+  const id = result?.id ? `${result.id} ` : "";
+  printPretty(deps.stdout, `Inserted message ${id}into task ${argv.id}`);
+  return EXIT.OK;
+}
+
 async function handleMessages(argv, deps) {
   const apis = await buildApis(deps);
   const list = await apis.tasks.listTaskMessages(argv.id, {
@@ -200,6 +373,90 @@ async function handleMessages(argv, deps) {
   return EXIT.OK;
 }
 
+async function handleScheduleList(argv, deps) {
+  const apis = await buildApis(deps);
+  const schedules = await apis.tasks.listScheduledMessages(argv.id);
+  const objects = (Array.isArray(schedules) ? schedules : []).map(scheduledMessageAsObject);
+  if (argv.json) {
+    printJson(deps.stdout, objects);
+    return EXIT.OK;
+  }
+  if (objects.length === 0) {
+    printPretty(deps.stdout, "(no scheduled messages)");
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 10)} ${pad("NEXT RUN", 24)} CONTENT`);
+  for (const schedule of objects) {
+    printPretty(
+      deps.stdout,
+      `${pad(schedule.id, 24)} ${pad(schedule.status, 10)} ${pad(schedule.nextRunAt, 24)} ${formatContentPreview(schedule.content)}`,
+    );
+  }
+  return EXIT.OK;
+}
+
+async function handleScheduleCreate(argv, deps) {
+  const apis = await buildApis(deps);
+  const content = readMessageInput({
+    positional: argv.message,
+    fromFile: argv.fromFile,
+    useStdin: Boolean(argv.stdin),
+    stdin: deps.stdin,
+  });
+  const schedule = parseScheduleOptions(argv);
+  const body = {
+    content,
+    sourceMessageId: argv.sourceMessageId ? String(argv.sourceMessageId) : null,
+    schedule,
+  };
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "POST",
+        `${buildBaseUrl(apis.config)}/api/tasks/${encodeURIComponent(argv.id)}/scheduled-messages`,
+        body,
+      ),
+    );
+    return EXIT.OK;
+  }
+  const result = await apis.tasks.createScheduledMessage(argv.id, body);
+  const obj = scheduledMessageAsObject(result);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Created scheduled message ${obj.id} for task ${argv.id}`);
+  if (obj.nextRunAt) {
+    printPretty(deps.stdout, `Next run: ${obj.nextRunAt}`);
+  }
+  return EXIT.OK;
+}
+
+async function handleScheduleDelete(argv, deps) {
+  const apis = await buildApis(deps);
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "DELETE",
+        `${buildBaseUrl(apis.config)}/api/tasks/${encodeURIComponent(argv.id)}/scheduled-messages/${encodeURIComponent(argv.scheduleId)}`,
+        undefined,
+      ),
+    );
+    return EXIT.OK;
+  }
+  await apis.tasks.deleteScheduledMessage(argv.id, argv.scheduleId);
+  if (argv.json) {
+    printJson(deps.stdout, { deleted: true, taskId: argv.id, scheduleId: argv.scheduleId });
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Deleted scheduled message ${argv.scheduleId} from task ${argv.id}`);
+  return EXIT.OK;
+}
+
 export async function main(argvInput = hideBin(process.argv), deps = {}) {
   const stdout = deps.stdout || process.stdout;
   const stderr = deps.stderr || process.stderr;
@@ -249,6 +506,20 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           exitCode = await handleSend(argv, { ...handlerDeps, configFile: argv.configFile });
         },
       )
+      .command(
+        "insert <id> [message]",
+        "Insert a mid-turn message into a running task (interrupts the current turn so it runs next)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .positional("message", { type: "string" })
+          .option("stdin", { type: "boolean", default: false })
+          .option("from-file", { type: "string" })
+          .option("target-reply-to", { type: "string", describe: "Reply target of the in-flight turn to interrupt (defaults to the latest user message)" })
+          .option("metadata-json", { type: "string", describe: "Extra JSON metadata to merge into the message" }),
+        async (argv) => {
+          exitCode = await handleInsert(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
       .command(
         "messages <id>",
         "Pull a slice of task messages and exit (no --follow in this RFC)",
@@ -260,6 +531,55 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           exitCode = await handleMessages(argv, { ...handlerDeps, configFile: argv.configFile });
         },
       )
+      .command(
+        "schedule",
+        "Create, list, and delete scheduled messages for a task",
+        (cmd) => cmd
+          .command(
+            "list <id>",
+            "List scheduled messages for a task",
+            (sub) => sub.positional("id", { type: "string", demandOption: true }),
+            async (argv) => {
+              exitCode = await handleScheduleList(argv, { ...handlerDeps, configFile: argv.configFile });
+            },
+          )
+          .command(
+            "create <id> [message]",
+            "Create a scheduled message for a task",
+            (sub) => sub
+              .positional("id", { type: "string", demandOption: true })
+              .positional("message", { type: "string" })
+              .option("stdin", { type: "boolean", default: false })
+              .option("from-file", { type: "string" })
+              .option("source-message-id", { type: "string", describe: "Original message id, when scheduling a copy" })
+              .option("delay", { type: "string", describe: "Send once after a duration, e.g. 10m or 2h" })
+              .option("at", { type: "string", describe: "Send once at an ISO/local date-time string" })
+              .option("every", { type: "string", describe: "Repeat every duration, e.g. 30m or 1h" })
+              .option("if-idle", { type: "boolean", default: false, describe: "For repeats, only send when the AI is idle" })
+              .option("max-runs", { type: "number", describe: "For repeats, stop after N sends" })
+              .option("max-skips", { type: "number", describe: "For repeats, stop after N skips" })
+              .option("stop-at", { type: "string", describe: "For repeats, stop after this date-time" })
+              .option("keep-when-task-stopped", {
+                type: "boolean",
+                default: false,
+                describe: "For repeats, skip instead of completing when the task is not running",
+              }),
+            async (argv) => {
+              exitCode = await handleScheduleCreate(argv, { ...handlerDeps, configFile: argv.configFile });
+            },
+          )
+          .command(
+            "delete <id> <scheduleId>",
+            "Delete an active scheduled message",
+            (sub) => sub
+              .positional("id", { type: "string", demandOption: true })
+              .positional("scheduleId", { type: "string", demandOption: true }),
+            async (argv) => {
+              exitCode = await handleScheduleDelete(argv, { ...handlerDeps, configFile: argv.configFile });
+            },
+          )
+          .demandCommand(1),
+      )
       .demandCommand(1)
       .fail((msg, err) => {
         if (err) {

package/bin/conductor.js

@@ -14,7 +14,7 @@
  *   serve-ai - Start an OpenAI-compatible local AI server
  *   project  - Manage Conductor projects (list/show/create/...)
  *   issue    - Manage issues (list/show/create/update/start/done)
- *   task     - Manage tasks (list/show/send/messages)
+ *   task     - Manage tasks (list/show/send/messages/schedule)
  */
 
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -134,7 +134,7 @@ Subcommands:
   serve-ai  Start an OpenAI-compatible local AI server
   project   Manage Conductor projects (list/show/create/...)
   issue     Manage issues (list/show/create/update/start/done)
-  task      Manage tasks (list/show/send/messages)
+  task      Manage tasks (list/show/send/messages/schedule)
 
 Options:
   -h, --help     Show this help message
@@ -153,6 +153,7 @@ Examples:
   conductor project list
   conductor issue create --title "Refactor module" --priority P2
   conductor task send <task-id> "please add a unit test"
+  conductor task schedule create <task-id> "follow up" --delay 10m
 
 For subcommand-specific help:
   conductor fire --help

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.6.1",
-  "gitCommitId": "707fffe",
+  "version": "0.7.0",
+  "gitCommitId": "ed4e3ab",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -20,11 +20,12 @@
     "provenance": true
   },
   "scripts": {
+    "pretest": "pnpm --dir ../modules/ai-sdk build && pnpm --dir ../modules/conductor-sdk build",
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.6.1",
-    "@love-moon/conductor-sdk": "0.6.1",
+    "@love-moon/ai-sdk": "0.7.0",
+    "@love-moon/conductor-sdk": "0.7.0",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -37,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.6.1"
+    "@love-moon/chat-web": "0.7.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/config-env.js

@@ -0,0 +1,10 @@
+export function envForExplicitConfigFile(configFile, env = process.env) {
+  if (!configFile) return env;
+
+  const configEnv = { ...env };
+  delete configEnv.CONDUCTOR_AGENT_TOKEN;
+  delete configEnv.CONDUCTOR_BACKEND_URL;
+  delete configEnv.CONDUCTOR_WS_URL;
+  delete configEnv.CONDUCTOR_BACKEND_WS_URL;
+  return configEnv;
+}

package/src/daemon.js

@@ -16,6 +16,7 @@ import {
   ProjectContext,
 } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
+import { envForExplicitConfigFile } from "./config-env.js";
 import { createAiManagerHandlers, handleAiManagerRequest } from "./ai-manager-handlers.js";
 import {
   CUSTOM_COMMANDS_CAPABILITY,
@@ -598,6 +599,7 @@ function normalizeTerminalEnv(value) {
 }
 
 const PTY_TASK_SCOPED_ENV_KEYS = [
+  "CONDUCTOR_CLI_COMMAND",
   "CONDUCTOR_PROJECT_ID",
   "CONDUCTOR_TASK_ID",
   "CONDUCTOR_PTY_SESSION_ID",
@@ -667,8 +669,9 @@ export function startDaemon(config = {}, deps = {}) {
   };
 
   let fileConfig;
+  const configFileEnv = envForExplicitConfigFile(config.CONFIG_FILE, process.env);
   try {
-    fileConfig = loadConfig(config.CONFIG_FILE);
+    fileConfig = loadConfig(config.CONFIG_FILE, { env: configFileEnv });
     log(`Loaded config from ${config.CONFIG_FILE || "~/.conductor/config.yaml"}`);
   } catch (err) {
     if (!(err instanceof ConfigFileNotFound)) {
@@ -677,15 +680,15 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   const userConfig = getUserConfig(config.CONFIG_FILE);
+  const allowEnvConfigOverrides = !config.CONFIG_FILE;
   const explicitWsUrl =
     config.BACKEND_URL ||
-    process.env.CONDUCTOR_BACKEND_WS_URL ||
-    process.env.CONDUCTOR_WS_URL ||
+    (allowEnvConfigOverrides ? process.env.CONDUCTOR_BACKEND_WS_URL || process.env.CONDUCTOR_WS_URL : null) ||
     null;
   const derivedHttpFromWs = explicitWsUrl ? deriveBackendHttpFromWebsocket(explicitWsUrl) : null;
   const BACKEND_HTTP =
     config.BACKEND_HTTP ||
-    process.env.CONDUCTOR_BACKEND_URL ||
+    (allowEnvConfigOverrides ? process.env.CONDUCTOR_BACKEND_URL : null) ||
     derivedHttpFromWs ||
     fileConfig?.backendUrl ||
     "http://localhost:6152";
@@ -693,7 +696,10 @@ export function startDaemon(config = {}, deps = {}) {
     explicitWsUrl ||
     deriveWebsocketUrlFromHttp(BACKEND_HTTP);
   const AGENT_TOKEN =
-    config.AGENT_TOKEN || process.env.CONDUCTOR_AGENT_TOKEN || fileConfig?.agentToken || "default-agent-token";
+    config.AGENT_TOKEN ||
+    (allowEnvConfigOverrides ? process.env.CONDUCTOR_AGENT_TOKEN : null) ||
+    fileConfig?.agentToken ||
+    "default-agent-token";
   const configuredDaemonName =
     (typeof userConfig.daemon_name === "string" && userConfig.daemon_name.trim()) ||
     (typeof fileConfig?.daemonName === "string" && fileConfig.daemonName.trim()) ||
@@ -5264,7 +5270,7 @@ export function startDaemon(config = {}, deps = {}) {
       });
 
       const env = {
-        ...process.env,
+        ...stripPtyTaskScopedEnv(process.env),
         PWD: taskDir,
         CONDUCTOR_PROJECT_ID: projectId,
         CONDUCTOR_TASK_ID: taskId,
@@ -5907,7 +5913,7 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     const env = {
-      ...process.env,
+      ...stripPtyTaskScopedEnv(process.env),
       PWD: taskDir,
       CONDUCTOR_PROJECT_ID: normalizedProjectId,
       CONDUCTOR_TASK_ID: normalizedTargetTaskId,

package/src/entity-helpers.js

@@ -20,6 +20,8 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
+import { envForExplicitConfigFile } from "./config-env.js";
+
 // RFC §4 exit codes
 export const EXIT = {
   OK: 0,
@@ -69,8 +71,9 @@ export async function loadConductorConfig(options = {}) {
   const sdk = await loadSdk(options);
 
   const configPath = resolveConfigPath(configFile, env);
+  const configEnv = envForExplicitConfigFile(configFile, env);
   if (fs.existsSync(configPath)) {
-    return sdk.loadConfig(configPath, { env });
+    return sdk.loadConfig(configPath, { env: configEnv });
   }
 
   const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
@@ -83,7 +86,7 @@ export async function loadConductorConfig(options = {}) {
   }
 
   // Let the SDK raise a typed not-found error.
-  return sdk.loadConfig(configPath, { env });
+  return sdk.loadConfig(configPath, { env: configEnv });
 }
 
 /**