chainlesschain 0.162.155 → 0.162.157

package/src/runtime/agent-core.js

@@ -1041,6 +1041,7 @@ async function tryIdeDiffApprovalForEdit(
       hasIdeOpenDiff,
       requestIdeDiffApproval,
       formatReviewComments,
+      summarizeUserAmendments,
     } = await import("../lib/ide-context.js");
     const mcpLike = {
       mcpClient: context.mcpClient,
@@ -1056,15 +1057,22 @@ async function tryIdeDiffApprovalForEdit(
       title: `cc agent: ${name} ${path.basename(proposal.filePath)}`,
     });
     if (verdict?.outcome === "accepted") {
+      // When the reviewer amended the proposal in the diff before accepting,
+      // hand the agent the actual -/+ delta — not just a flag — so its model
+      // of the file matches what was really written (gap #4: the agent
+      // perceives the user's edits).
+      const amendments =
+        verdict.finalText != null && verdict.finalText !== proposal.newContent
+          ? summarizeUserAmendments(proposal.newContent, verdict.finalText)
+          : null;
       return {
         outcome: "accepted",
         result: {
           success: true,
           path: proposal.filePath,
           appliedVia: "ide-diff",
-          ...(verdict.finalText != null &&
-          verdict.finalText !== proposal.newContent
-            ? { userEdited: true }
+          ...(amendments
+            ? { userEdited: true, userAmendments: amendments }
             : {}),
           policy: { decision: "allow", rule, via: "ide-diff" },
         },
@@ -2431,6 +2439,24 @@ async function executeToolInner(
         }
       }
 
+      // P1 #8 Windows/PowerShell first-class: per-call args.shell or the
+      // configured settings `shell.windowsDefault` may route this command
+      // through PowerShell via explicit argv (`powershell.exe -NoProfile
+      // [-ExecutionPolicy <p>] -Command <cmd>`). The unconfigured path keeps
+      // the historical default shell byte-identical (useDefaultShell=true).
+      const { resolveShellInvocation } =
+        await import("../lib/shell-selector.cjs");
+      const shellInv = resolveShellInvocation({
+        command: args.command,
+        requested: args.shell,
+        cwd: args.cwd || cwd,
+      });
+      const shellMeta = shellInv.useDefaultShell
+        ? shellInv.note
+          ? { shell_note: shellInv.note }
+          : {}
+        : { shell: shellInv.kind };
+
       // Background: spawn, register, return a task_id immediately. The agent
       // polls output + completion via check_shell. No timeout — that's the whole
       // point of backgrounding (builds, test suites, dev servers).
@@ -2463,9 +2489,9 @@ async function executeToolInner(
           child: null,
         };
         try {
-          const child = spawn(args.command, {
+          const bgSpawnOpts = {
             cwd: task.cwd,
-            shell: true,
+            shell: shellInv.useDefaultShell,
             windowsHide: true,
             // Same agent-identity env as the foreground path: CLAUDECODE marks
             // "running under the agent"; the session id correlates work to the
@@ -2484,7 +2510,12 @@ async function executeToolInner(
             // the whole tree (shell + its grandchild command). No-op on Windows
             // where the tree is killed via taskkill /T instead.
             detached: process.platform !== "win32",
-          });
+          };
+          // PowerShell route: explicit argv (shell:false above); default route
+          // is the historical spawn(command, {shell:true}) byte-for-byte.
+          const child = shellInv.useDefaultShell
+            ? spawn(args.command, bgSpawnOpts)
+            : spawn(shellInv.file, shellInv.argv, bgSpawnOpts);
           task.child = child;
           if (child.stdout) {
             child.stdout.setEncoding("utf8");
@@ -2532,6 +2563,7 @@ async function executeToolInner(
             task_id: id,
             status: task.status,
             command: task.command,
+            ...shellMeta,
             hint: "Poll output and completion with the check_shell tool using this task_id. Kill long-lived servers with check_shell { task_id, kill: true } when done.",
             shellCommandPolicy: shellPolicy,
             approval: approvalOutcome,
@@ -2630,7 +2662,7 @@ async function executeToolInner(
       }
 
       try {
-        const output = execSync(args.command, {
+        const fgExecOpts = {
           cwd: args.cwd || cwd,
           encoding: "utf8",
           timeout: _resolveShellTimeout(args.timeout),
@@ -2649,10 +2681,35 @@ async function executeToolInner(
                 }
               : {}),
           },
-        });
+        };
+        let output;
+        if (shellInv.useDefaultShell) {
+          output = execSync(args.command, fgExecOpts);
+        } else {
+          // PowerShell route: explicit argv, no intermediate default shell.
+          // Reproduce execSync's contract so the shared catch shapes errors
+          // identically: throw on spawn error; throw an Error carrying
+          // status/stdout/stderr on non-zero exit.
+          const res = spawnSync(shellInv.file, shellInv.argv, {
+            ...fgExecOpts,
+            windowsHide: true,
+          });
+          if (res.error) throw res.error;
+          if (res.status !== 0) {
+            const e = new Error(
+              `Command failed (${shellInv.kind}, exit ${res.status}): ${args.command}`,
+            );
+            e.status = res.status;
+            e.stdout = res.stdout;
+            e.stderr = res.stderr;
+            throw e;
+          }
+          output = res.stdout ?? "";
+        }
         return attachDescriptor(
           {
             stdout: output.substring(0, 30000),
+            ...shellMeta,
             shellCommandPolicy: shellPolicy,
             approval: approvalOutcome,
           },
@@ -2672,6 +2729,7 @@ async function executeToolInner(
               : {}),
             stderr: (err.stderr || "").substring(0, 2000),
             exitCode: err.status,
+            ...shellMeta,
             shellCommandPolicy: shellPolicy,
             approval: approvalOutcome,
           },
@@ -3010,6 +3068,125 @@ async function executeToolInner(
       }
     }
 
+    case "notify": {
+      try {
+        const { sendAgentNotification } =
+          await import("../lib/agent-notify.js");
+        const outcome = await sendAgentNotification({
+          title: args.title,
+          body: args.body,
+          level: args.level,
+        });
+        return attachDescriptor(outcome);
+      } catch (err) {
+        return attachDescriptor({ error: `notify failed: ${err.message}` });
+      }
+    }
+
+    case "schedule": {
+      try {
+        const { AgentScheduleStore } =
+          await import("../lib/agent-schedule-store.js");
+        const { parseDuration } = await import("../lib/loop.js");
+        const store = new AgentScheduleStore();
+        const action = String(args.action || "").toLowerCase();
+        if (action === "wakeup") {
+          if (!args.prompt) {
+            return attachDescriptor({
+              error: "schedule wakeup requires a prompt",
+            });
+          }
+          const delayMs = args.delay ? parseDuration(args.delay) : 0;
+          const entry = store.scheduleWakeup({
+            prompt: args.prompt,
+            delayMs,
+            label: args.label || null,
+          });
+          return attachDescriptor({
+            scheduled: entry,
+            hint: "Run `cc agenda run` (e.g. via cron or `cc loop`) to fire due entries.",
+          });
+        }
+        if (action === "cron") {
+          if (!args.prompt || !args.cron) {
+            return attachDescriptor({
+              error: "schedule cron requires a prompt and a cron expression",
+            });
+          }
+          const entry = store.createCron({
+            prompt: args.prompt,
+            cron: args.cron,
+            label: args.label || null,
+          });
+          return attachDescriptor({ scheduled: entry });
+        }
+        if (action === "monitor") {
+          if (!args.command) {
+            return attachDescriptor({
+              error: "schedule monitor requires a command",
+            });
+          }
+          const intervalMs = args.interval
+            ? parseDuration(args.interval)
+            : 60000;
+          const entry = store.createMonitor({
+            command: args.command,
+            intervalMs,
+            stopWhen: args.stop_when || null,
+            notify: args.notify_title ? { title: args.notify_title } : null,
+            maxChecks: args.max_checks ?? null,
+            label: args.label || null,
+          });
+          return attachDescriptor({ scheduled: entry });
+        }
+        if (action === "list") {
+          return attachDescriptor({ entries: store.list() });
+        }
+        if (action === "cancel") {
+          if (!args.id) {
+            return attachDescriptor({
+              error: "schedule cancel requires an id",
+            });
+          }
+          const removed = store.cancel(args.id);
+          return attachDescriptor({
+            cancelled: removed ? removed.id : null,
+            found: Boolean(removed),
+          });
+        }
+        return attachDescriptor({
+          error: `unknown schedule action "${args.action}". Valid: wakeup, cron, monitor, list, cancel.`,
+        });
+      } catch (err) {
+        return attachDescriptor({ error: `schedule failed: ${err.message}` });
+      }
+    }
+
+    case "publish_artifact": {
+      // P1 #10: copy a finished deliverable into the user's artifact store.
+      // Only METADATA returns to the conversation (the transcript never
+      // carries the file body); `cc artifacts` lists/inspects/cleans.
+      try {
+        const { ArtifactStore } = await import("../lib/artifact-store.js");
+        const store = new ArtifactStore();
+        const entry = store.publish({
+          filePath: path.resolve(cwd, String(args.path || "")),
+          title: args.title,
+          kind: args.kind,
+          ttlDays: args.ttl_days,
+          sessionId: sessionId ? String(sessionId) : null,
+        });
+        return attachDescriptor({
+          published: entry,
+          hint: "The user can browse this with `cc artifacts list` / `cc artifacts show <id>`.",
+        });
+      } catch (err) {
+        return attachDescriptor({
+          error: `publish_artifact failed: ${err.message}`,
+        });
+      }
+    }
+
     case "search_files": {
       // An explicit directory scopes the search to one root; otherwise span
       // cwd plus any --add-dir roots so cross-package searches find matches.
@@ -6342,6 +6519,18 @@ export function formatToolArgs(name, args) {
       return `[${args.role}] ${(args.task || "").substring(0, 60)}`;
     case "search_sessions":
       return `"${(args.query || "").substring(0, 60)}"`;
+    case "notify":
+      return `${args.level || "info"}: ${(args.title || "").substring(0, 50)}`;
+    case "publish_artifact":
+      return `${args.kind || "other"}: ${(args.title || args.path || "").substring(0, 60)}`;
+    case "schedule":
+      return args.action === "cron"
+        ? `cron ${args.cron || ""}`.trim()
+        : args.action === "monitor"
+          ? `monitor ${(args.command || "").substring(0, 40)}`.trim()
+          : args.action === "wakeup"
+            ? `wakeup +${args.delay || "0s"}`
+            : String(args.action || "");
     default:
       return JSON.stringify(args).substring(0, 60);
   }

package/src/runtime/coding-agent-contract-shared.cjs

@@ -238,6 +238,12 @@ const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
           description:
             "Foreground (synchronous) timeout in milliseconds. Default 60000, max 600000. Ignored when run_in_background is true.",
         },
+        shell: {
+          type: "string",
+          enum: ["default", "cmd", "powershell", "pwsh"],
+          description:
+            "Shell to run the command with (optional). default = the platform shell (cmd.exe on Windows, /bin/sh elsewhere) or the configured settings shell.windowsDefault. Use powershell (Windows PowerShell 5.1) or pwsh (PowerShell 7+) when the command uses PowerShell syntax: cmdlets, object pipelines, $variables.",
+        },
       },
       required: ["command"],
     },
@@ -849,6 +855,156 @@ const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
       tags: ["tool:search_sessions", "contract:coding-agent", "tier:extension"],
     },
   },
+  {
+    name: "notify",
+    title: "Send Notification",
+    kind: "notify",
+    tier: "extension",
+    description:
+      "Push a notification to the user's configured channels (Telegram / WeCom / DingTalk / Feishu) and/or a paired mobile device. Use for long-running tasks: report completion, flag that you need a human decision, or surface an error. Best-effort: reports which channels delivered.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short notification title" },
+        body: { type: "string", description: "Notification body text" },
+        level: {
+          type: "string",
+          enum: ["info", "success", "failure"],
+          description: "Severity (default: info)",
+        },
+      },
+      required: ["title"],
+    },
+    ...TOOL_POLICY_METADATA.notify,
+    permissions: {
+      level: "standard",
+      scopes: ["network:notify"],
+    },
+    telemetry: {
+      category: "notify",
+      tags: ["tool:notify", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "schedule",
+    title: "Schedule / Monitor",
+    kind: "schedule",
+    tier: "extension",
+    description:
+      "Set up work that outlives this turn (persisted for `cc agenda run` to execute). Actions: `wakeup` — run a prompt once after a delay; `cron` — run a prompt on a 5-field cron schedule; `monitor` — run a shell command every interval and notify when its output matches a regex; `list` — show scheduled items; `cancel` — remove one by id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["wakeup", "cron", "monitor", "list", "cancel"],
+          description: "What to do",
+        },
+        prompt: {
+          type: "string",
+          description:
+            "For wakeup/cron: the agent prompt to run (via `cc agent -p`) when it fires",
+        },
+        delay: {
+          type: "string",
+          description:
+            "For wakeup: how long from now before it fires (e.g. 30s, 5m, 1h)",
+        },
+        cron: {
+          type: "string",
+          description:
+            'For cron: a 5-field cron expression, e.g. "0 9 * * 1" (09:00 every Monday)',
+        },
+        command: {
+          type: "string",
+          description: "For monitor: the shell command to run each interval",
+        },
+        interval: {
+          type: "string",
+          description:
+            "For monitor: how often to run the command (e.g. 30s, 5m)",
+        },
+        stop_when: {
+          type: "string",
+          description:
+            "For monitor: a regex; when the command output matches, the monitor fires its notification and stops",
+        },
+        notify_title: {
+          type: "string",
+          description: "For monitor: notification title sent when it matches",
+        },
+        max_checks: {
+          type: "number",
+          description:
+            "For monitor: give up after this many checks (optional safety cap)",
+        },
+        label: {
+          type: "string",
+          description: "Optional human label for list/cancel",
+        },
+        id: {
+          type: "string",
+          description: "For cancel: the schedule entry id to remove",
+        },
+      },
+      required: ["action"],
+    },
+    ...TOOL_POLICY_METADATA.schedule,
+    permissions: {
+      level: "standard",
+      scopes: ["schedule:write"],
+    },
+    telemetry: {
+      category: "schedule",
+      tags: ["tool:schedule", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "publish_artifact",
+    title: "Publish Artifact",
+    kind: "artifact",
+    tier: "extension",
+    description:
+      "Publish a finished deliverable file (Markdown report, patch, screenshot, test log, findings JSON) as a durable artifact the user can find later with `cc artifacts`. The file is copied into the user's artifact store with metadata; only the metadata enters the conversation. Use at the END of a task for its key outputs — not for intermediate scratch files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description:
+            "Path of the file to publish (relative to cwd or absolute)",
+        },
+        title: {
+          type: "string",
+          description: "Human title for the artifact (default: the file name)",
+        },
+        kind: {
+          type: "string",
+          enum: ["report", "patch", "screenshot", "log", "data", "other"],
+          description: "What kind of deliverable this is (default: other)",
+        },
+        ttl_days: {
+          type: "number",
+          description:
+            "Days to retain before `cc artifacts clean` may remove it (default 30)",
+        },
+      },
+      required: ["path"],
+    },
+    ...TOOL_POLICY_METADATA.publish_artifact,
+    permissions: {
+      level: "standard",
+      scopes: ["filesystem:read", "artifact:write"],
+    },
+    telemetry: {
+      category: "artifact",
+      tags: [
+        "tool:publish_artifact",
+        "contract:coding-agent",
+        "tier:extension",
+      ],
+    },
+  },
 ]);
 
 const CODING_AGENT_MVP_TOOL_NAMES = Object.freeze(

package/src/runtime/coding-agent-policy.cjs

@@ -261,6 +261,49 @@ const TOOL_POLICY_METADATA = Object.freeze({
     approvalFlow: "auto",
     isReadOnly: true,
   },
+  // Sends an outbound notification to the user's own channels/device. No
+  // workspace mutation and no un-gated shell; blocked in plan mode (an
+  // external side effect) but otherwise auto — it targets the user, not a
+  // third party.
+  notify: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: false,
+  },
+  // Persists a wakeup/cron/monitor entry for `cc agenda run` to execute later.
+  // Writing the schedule is itself harmless (a JSONL row under the user's
+  // config dir); the eventual `cc agent`/shell run is gated when the agenda
+  // consumer executes it. Blocked in plan mode (schedules future side effects).
+  schedule: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: false,
+  },
+  // Copies a finished deliverable (report/patch/screenshot/log) into the
+  // user's own ~/.chainlesschain/artifacts store with metadata. Reads a
+  // workspace file, writes only under the user's config dir — no third-party
+  // egress. Blocked in plan mode (publishing is a side effect of DONE work,
+  // not analysis).
+  publish_artifact: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: false,
+  },
 });
 
 function normalizeGitCommand(command) {

package/src/runtime/headless-stream.js

@@ -181,6 +181,47 @@ export function planSnapshot(pm) {
   }
   return { active: pm.isActive(), state: pm.state || null, items, risk };
 }
+
+const MAX_PLAN_REVIEW_SNAPSHOT_CHARS = 24000;
+
+function planReviewFromInput(obj) {
+  const review =
+    obj && obj.review && typeof obj.review === "object" ? obj.review : null;
+  const snapshot =
+    typeof obj?.snapshot === "string"
+      ? obj.snapshot
+      : typeof review?.snapshot === "string"
+        ? review.snapshot
+        : "";
+  if (!snapshot.trim()) return null;
+  const text =
+    snapshot.length > MAX_PLAN_REVIEW_SNAPSHOT_CHARS
+      ? snapshot.slice(0, MAX_PLAN_REVIEW_SNAPSHOT_CHARS) +
+        `\n\n[review snapshot truncated: ${snapshot.length - MAX_PLAN_REVIEW_SNAPSHOT_CHARS} chars omitted]`
+      : snapshot;
+  return {
+    action: String(review?.action || obj.action || "").toLowerCase(),
+    reviewedAt:
+      typeof review?.reviewedAt === "string" ? review.reviewedAt : null,
+    conversationId:
+      typeof review?.conversationId === "string" ? review.conversationId : null,
+    snapshot: text,
+  };
+}
+
+function planReviewSystemMessage(review) {
+  if (!review?.snapshot) return null;
+  const meta = [
+    review.action ? `action=${review.action}` : null,
+    review.reviewedAt ? `reviewedAt=${review.reviewedAt}` : null,
+    review.conversationId ? `conversationId=${review.conversationId}` : null,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  return (
+    "[PLAN REVIEW SNAPSHOT]" + (meta ? ` ${meta}` : "") + "\n" + review.snapshot
+  );
+}
 import { withQuietStdout } from "./quiet-stdout.js";
 
 /**
@@ -199,7 +240,9 @@ export function parseInputEvent(line) {
   //   {"type":"plan","action":"enter"|"approve"|"reject"}
   if (obj && typeof obj === "object" && obj.type === "plan") {
     const action = String(obj.action || "").toLowerCase();
-    return action ? { plan: action } : null;
+    if (!action) return null;
+    const planReview = planReviewFromInput(obj);
+    return planReview ? { plan: action, planReview } : { plan: action };
   }
   // Turn interrupt (panel Stop / Claude-Code Esc parity): aborts the
   // in-flight turn without ending the conversation. {"type":"interrupt"}
@@ -1304,6 +1347,13 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     // exits plan mode. Every control answers with a `plan_update` event.
     if (parsed.plan) {
       const pm = getPlanModeManager();
+      const reviewMessage =
+        parsed.plan === "approve" || parsed.plan === "reject"
+          ? planReviewSystemMessage(parsed.planReview)
+          : null;
+      if (reviewMessage) {
+        messages.push({ role: "system", content: reviewMessage });
+      }
       if (parsed.plan === "enter") {
         if (!pm.isActive()) {
           pm.enterPlanMode({ title: "Agent Plan" });

package/src/runtime/policies/agent-policy.js

@@ -55,6 +55,7 @@ export function resolveAgentPolicy({
     fallbackModels: overrides.fallbackModels,
     pdh: overrides.pdh,
     outputStyle: overrides.outputStyle,
+    disableSlashCommands: overrides.disableSlashCommands === true,
   };
 }