chainlesschain 0.162.162 → 0.162.163

package/src/runtime/headless-runner.js

@@ -44,6 +44,8 @@ import {
   appendTokenUsage as jsonlAppendTokenUsage,
   appendToolCallCompact as jsonlAppendToolCallCompact,
   appendCompactEvent as jsonlAppendCompactEvent,
+  appendEvent as jsonlAppendEvent,
+  readEvents as jsonlReadEvents,
   rebuildMessages as jsonlRebuildMessages,
   sessionExists as jsonlSessionExists,
   getLastSessionId as jsonlGetLastSessionId,
@@ -461,6 +463,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     appendToolCallCompact:
       deps.appendToolCallCompact || jsonlAppendToolCallCompact,
     appendCompactEvent: deps.appendCompactEvent || jsonlAppendCompactEvent,
+    appendEvent: deps.appendEvent || jsonlAppendEvent,
+    readEvents: deps.readEvents || jsonlReadEvents,
     getLastSessionId: deps.getLastSessionId || jsonlGetLastSessionId,
     verifySession: deps.verifySession || jsonlVerifySession,
   };
@@ -744,12 +748,35 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     outputStyleBody = null;
   }
 
+  // Large-monorepo context lever: `instructionExcludes` (settings.json or an
+  // explicit caller/SDK option) suppresses cc.md/CLAUDE.md/AGENTS.md, path-scoped
+  // rules, and @imports that resolve into legacy/vendor/generated subtrees.
+  // Explicit option wins; otherwise union across the layered settings files.
+  let instructionExcludes = Array.isArray(options.instructionExcludes)
+    ? options.instructionExcludes
+    : null;
+  if (!instructionExcludes) {
+    try {
+      const { readStringArraySetting } =
+        await import("../lib/settings-loader.cjs");
+      const fromSettings = readStringArraySetting("instructionExcludes", {
+        cwd,
+        settingsFile: options.settingsFile,
+      });
+      if (fromSettings && fromSettings.length)
+        instructionExcludes = fromSettings;
+    } catch {
+      instructionExcludes = null; // fail-open
+    }
+  }
+
   const systemContent = composeSystemPrompt(
     buildSystemPrompt(cwd, { additionalDirectories }),
     {
       systemPrompt: options.systemPrompt,
       appendSystemPrompt: options.appendSystemPrompt,
       outputStyle: outputStyleBody,
+      instructionExcludes,
     },
   );
 
@@ -1068,6 +1095,10 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     model,
     provider,
     recorder: _otlpRecorder,
+    // --otlp-content: opt in to stamping prompt CONTENT onto --otlp spans. Off by
+    // default → content stays redacted (agent-core omits it entirely, so default
+    // OTLP output is byte-identical). Only meaningful when a recorder is attached.
+    otlpIncludeContent: options.otlpContent === true,
     hookSupervisor: _hookSupervisor,
     // Extended thinking (Anthropic; opt-in via --think/--ultrathink). null/off
     // → chatWithTools sends no thinking field. thinkingBudget (--thinking-budget)
@@ -1091,6 +1122,13 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     approvalGate,
     permissionRules,
     settingsHooks,
+    // Seed the subagent-contract CEILING with this run's permission mode so a
+    // spawned sub-agent inherits/tightens from it (tighten-only): a
+    // `--permission-mode bypassPermissions` run can hand a child bypass (→ allow
+    // confirmer), a `--permission-mode plan` run clamps children to read-only,
+    // while a "default" run resolves children to "default" exactly as before
+    // (byte-identical — the previous null ceiling also yielded "default").
+    subAgentContract: { permissionMode: options.permissionMode || "default" },
     classifyAllShell,
     enabledToolNames,
     disabledTools,
@@ -1278,6 +1316,138 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     };
   };
 
+  // --goal-condition: session-level completion-condition engine (P1). After each
+  // outer turn an independent checker judges a completion CONDITION; if unmet and
+  // budget remains, a follow-up user turn re-drives the agent — until met
+  // (goal_completed) or a budget is exhausted (goal_exhausted). OPT-IN: when
+  // unset, `goalEngine` is null and the outer loop runs exactly once, so one-shot
+  // `cc agent -p` behavior is byte-for-byte unchanged.
+  let goalEngine = null;
+  let _goalHelpers = null;
+  let _goalTokensSeen = 0; // per-turn usage deltas (engine totals == run total)
+  let _goalCostSeen = 0;
+  // Model-judged conditions reuse the run's own model as an independent
+  // evaluator (mirrors --goal-assess). Overridable via deps for tests.
+  const _defaultGoalJudge = async (cond, transcript) => {
+    const { chatWithTools } = await import("./agent-core.js");
+    const { firstBalancedJson } = await import("../lib/json-schema-output.js");
+    const judgePrompt =
+      `You are judging whether a coding session met a completion condition.\n` +
+      `Condition: ${cond.text || cond.source}\n\n` +
+      `Latest assistant output:\n${String(transcript.finalText || "").slice(0, 2000)}\n\n` +
+      `Reply with STRICT JSON only: {"met": true|false, "reason": "<short>"}.`;
+    const r = await chatWithTools([{ role: "user", content: judgePrompt }], {
+      model,
+      provider,
+      baseUrl,
+      apiKey,
+      enabledToolNames: [],
+    });
+    const text = r?.message?.content || "";
+    let met = false;
+    let reason = "model judge returned no verdict";
+    const block = firstBalancedJson(text, "{");
+    if (block) {
+      try {
+        const parsed = JSON.parse(block);
+        met = parsed.met === true;
+        if (typeof parsed.reason === "string" && parsed.reason.trim())
+          reason = parsed.reason.trim();
+        else reason = met ? "condition met" : "condition not met";
+      } catch {
+        /* tolerant: a non-JSON verdict stays unmet */
+      }
+    }
+    return {
+      met,
+      reason,
+      evidence: { kind: "model", raw: text.slice(0, 200) },
+    };
+  };
+  // Persist the engine snapshot as a hash-chained `goal_snapshot` session event
+  // (best-effort, only when persisting). Re-read on --resume so an unfinished
+  // goal continues across processes with its outerTurns/tokens/cost/startedAtMs
+  // intact. rebuildMessages ignores this event type, so it never pollutes model
+  // context. Defined here so the outer loop can call it after each evaluate().
+  const persistGoalSnapshot = () => {
+    if (!persist || !goalEngine) return;
+    try {
+      store.appendEvent(sessionId, "goal_snapshot", goalEngine.snapshot());
+    } catch {
+      // best-effort — never fail the run over persistence
+    }
+  };
+  if (options.goalCondition) {
+    try {
+      const eng = await import("../lib/goal-condition-engine.js");
+      const goalNow = () => (deps.now ? deps.now() : Date.now());
+      // Cross-process resume: if the resumed session persisted an UNFINISHED
+      // goal, continue it (fromSnapshot keeps accumulated progress + startedAtMs)
+      // rather than starting fresh. A finished (done) snapshot is ignored — the
+      // prior goal already concluded, so --goal-condition begins a new cycle. On
+      // restore the persisted condition/budget win over freshly-passed flags, so
+      // a resume faithfully continues the same goal.
+      let restoredSnap = null;
+      if (resumeId) {
+        try {
+          const events = store.readEvents(resumeId) || [];
+          for (let i = events.length - 1; i >= 0; i--) {
+            const ev = events[i];
+            if (ev && ev.type === "goal_snapshot") {
+              const snap = ev.data;
+              if (snap && snap.state && snap.state.done !== true)
+                restoredSnap = snap;
+              break; // only the latest goal_snapshot matters
+            }
+          }
+        } catch {
+          restoredSnap = null; // unreadable transcript → start fresh
+        }
+      }
+      if (restoredSnap) {
+        goalEngine = eng.GoalConditionEngine.fromSnapshot(restoredSnap, {
+          now: goalNow,
+        });
+      } else {
+        goalEngine = new eng.GoalConditionEngine({
+          condition: options.goalCondition,
+          budget: {
+            maxOuterTurns: options.maxOuterTurns,
+            maxTokens: options.goalMaxTokens,
+            maxCostUsd: options.goalMaxCostUsd,
+            maxTimeMs: options.goalMaxTimeMs,
+          },
+          now: goalNow,
+        });
+      }
+      _goalHelpers = {
+        isDeterministicCondition: eng.isDeterministicCondition,
+        runDeterministicCheck: eng.runDeterministicCheck,
+        GOAL_DECISION: eng.GOAL_DECISION,
+      };
+      const started = goalEngine.start();
+      emitStream({
+        type: started.type,
+        condition: started.condition,
+        budget: started.budget,
+        resumed: Boolean(restoredSnap),
+      });
+      persistGoalSnapshot(); // checkpoint the starting/restored state
+      if (isText)
+        writeErr(
+          `  ◎ goal-condition ${restoredSnap ? "resumed" : "active"}: ` +
+            `${goalEngine.condition.source} ` +
+            `(outer turn ${goalEngine.state.outerTurns + 1}/` +
+            `${goalEngine.budget.maxOuterTurns})\n`,
+        );
+    } catch (err) {
+      // A bad spec should have been rejected at the command layer; fail-open so
+      // a malformed condition never aborts an otherwise-valid run.
+      goalEngine = null;
+      if (isText) writeErr(`  goal-condition ignored: ${err.message}\n`);
+    }
+  }
+
   // A Ctrl-C (SIGINT) / SIGTERM terminates Node WITHOUT unwinding the `finally`
   // below, so its background-task reaper is bypassed — a backgrounded run_shell
   // task (e.g. a dev server) this run spawned would be orphaned. Install a
@@ -1492,6 +1662,103 @@ export async function runAgentHeadless(options = {}, deps = {}) {
           );
         }
       }
+      // ── goal-condition re-drive (opt-in via --goal-condition) ─────────────
+      // After the turn settles (and any auto-rewake fix), evaluate the session
+      // completion condition. Unmet + budget remaining → append a follow-up user
+      // turn and re-drive; met → goal_completed; budget spent → goal_exhausted.
+      // Cost / max-turns exhaustion of the INNER loop stops here regardless.
+      if (
+        goalEngine &&
+        _goalHelpers &&
+        !goalEngine.done &&
+        !stopForCost &&
+        endReason !== "cost-budget-exhausted" &&
+        endReason !== "max_turns"
+      ) {
+        // Feed this turn's usage DELTA so the engine's totals equal the run's
+        // cumulative usage (recordTurnUsage accumulates).
+        const curTokens =
+          usage.input_tokens +
+          usage.output_tokens +
+          usage.cache_read_input_tokens +
+          usage.cache_creation_input_tokens;
+        const curCost = costBudget ? Number(costBudget.spentUsd) || 0 : 0;
+        goalEngine.recordTurnUsage({
+          tokens: curTokens - _goalTokensSeen,
+          costUsd: curCost - _goalCostSeen,
+        });
+        _goalTokensSeen = curTokens;
+        _goalCostSeen = curCost;
+
+        const cond = goalEngine.condition;
+        let evaluation;
+        try {
+          if (_goalHelpers.isDeterministicCondition(cond)) {
+            const gc = deps.goalCheck || {};
+            const spawnSync =
+              gc.spawnSync || (await import("node:child_process")).spawnSync;
+            const existsSync =
+              gc.existsSync || (await import("node:fs")).existsSync;
+            evaluation = _goalHelpers.runDeterministicCheck(cond, {
+              spawnSync,
+              existsSync,
+              cwd,
+              lastOutput: finalText,
+            });
+          } else {
+            const judge = deps.goalConditionJudge || _defaultGoalJudge;
+            evaluation = await judge(cond, {
+              prompt: options.prompt,
+              finalText,
+              toolCalls,
+            });
+          }
+        } catch (err) {
+          evaluation = {
+            met: false,
+            reason: `goal check failed: ${err.message}`,
+            evidence: { error: true },
+          };
+        }
+
+        const { decision, events } = goalEngine.evaluate(evaluation);
+        for (const ev of events) {
+          emitStream(ev);
+          if (isText) {
+            if (ev.type === "goal_completed")
+              writeErr(`  ✔ goal-condition met: ${ev.reason}\n`);
+            else if (ev.type === "goal_exhausted")
+              writeErr(
+                `  ⛔ goal-condition unmet (${ev.limit}): ${ev.reason}\n`,
+              );
+            else if (ev.type === "goal_evaluated")
+              writeErr(
+                `  ◎ goal-condition ${ev.met ? "met" : "not met"}: ${ev.reason}\n`,
+              );
+          }
+        }
+        // Checkpoint the post-evaluate state (outerTurns incremented, and
+        // done/outcome on a terminal decision) so a crash or Ctrl-C between here
+        // and the next turn still resumes at the right point.
+        persistGoalSnapshot();
+        if (decision === _goalHelpers.GOAL_DECISION.CONTINUE) {
+          messages.push({
+            role: "user",
+            content:
+              `The completion condition is not yet met: ${evaluation.reason}.\n` +
+              `Keep working toward: "${cond.source}". When you believe it is ` +
+              `satisfied, make sure it actually passes.`,
+          });
+          finalText = "";
+          endReason = "complete";
+          if (isText)
+            writeErr(
+              `  ↻ goal-condition re-drive — outer turn ${goalEngine.state.outerTurns + 1}\n`,
+            );
+          continue; // re-drive: run another outer turn
+        }
+        // complete | exhausted → fall through to the break below.
+      }
       break;
     }
   } catch (err) {

package/src/runtime/headless-stream.js

@@ -1035,12 +1035,55 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
   } catch {
     outputStyleBody = null;
   }
+  // Large-monorepo context lever: `instructionExcludes` (settings.json or an
+  // explicit caller/SDK option) suppresses instruction/rule/@import files that
+  // resolve into excluded subtrees. Explicit option wins; else union settings.
+  let instructionExcludes = Array.isArray(options.instructionExcludes)
+    ? options.instructionExcludes
+    : null;
+  if (!instructionExcludes) {
+    try {
+      const { readStringArraySetting } =
+        await import("../lib/settings-loader.cjs");
+      const fromSettings = readStringArraySetting("instructionExcludes", {
+        cwd,
+        settingsFile: options.settingsFile,
+      });
+      if (fromSettings && fromSettings.length)
+        instructionExcludes = fromSettings;
+    } catch {
+      instructionExcludes = null; // fail-open
+    }
+  }
+  // --json-schema (P2 §"JSON Schema 与流式结构化结果"): resolve + meta-validate
+  // the schema up front (fail-fast on a broken contract, mirroring the
+  // single-prompt path), then inject its output contract into the system prompt
+  // so the model's final reply is JSON. A per-turn `structured_result` event is
+  // emitted after each turn below. Off by default → nothing changes.
+  let _jsonSchema = null;
+  let _jso = null;
+  if (options.jsonSchema) {
+    try {
+      _jso = await import("../lib/json-schema-output.js");
+      _jsonSchema = _jso.loadSchemaFile(_jso._deps.fs, options.jsonSchema);
+    } catch (err) {
+      // Fail-fast, exactly like `cc agent -p --json-schema` on a bad schema.
+      writeErr(`Error: ${err.message}\n`);
+      return { exitCode: 1, turns: 0 };
+    }
+  }
+
   const systemContent = composeSystemPrompt(
     buildSystemPrompt(cwd, { additionalDirectories }),
     {
       systemPrompt: options.systemPrompt,
-      appendSystemPrompt: options.appendSystemPrompt,
+      appendSystemPrompt: _jsonSchema
+        ? [options.appendSystemPrompt, _jso.buildSchemaInstruction(_jsonSchema)]
+            .filter(Boolean)
+            .join("\n\n")
+        : options.appendSystemPrompt,
       outputStyle: outputStyleBody,
+      instructionExcludes,
     },
   );
   const messages = [{ role: "system", content: systemContent }];
@@ -2041,6 +2084,22 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
       usage: outcome.usage,
     });
 
+    // --json-schema (P2): emit this turn's structured verdict right after its
+    // result — schema_digest + valid + value/errors from the turn's final text.
+    // Never falls back to free text; an unparseable/invalid reply reports
+    // valid:false with coded/pointered errors. Parity with single-prompt output.
+    if (_jsonSchema) {
+      const parsed = _jso.extractJsonPayload(String(outcome.finalText ?? ""));
+      emit({
+        ..._jso.buildStructuredResult(
+          _jsonSchema,
+          parsed.ok ? parsed.value : null,
+        ),
+        session_id: sessionId,
+        turn: turns,
+      });
+    }
+
     // Session-wide cost cap reached → stop accepting further turns.
     if (costStopped) break;
 

package/src/assets/web-panel/assets/ChatBubbleRenderer-HwJR-C6B.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as n,R as a,S as y,K as C,Q as x,V as w,_ as B,b as s}from"./vendor-Bn1JzzAn.js";import{_ as k}from"./index-CudmwNBV.js";import"./icons-DG5UD-6K.js";const T={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=s(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=s(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=s(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=s(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=s(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),f=String(e.getMonth()+1).padStart(2,"0"),g=String(e.getDate()).padStart(2,"0"),b=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${f}-${g} ${b}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:s};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},M={class:"bubble"},N={class:"meta"},R={class:"actor"},D={class:"time"},V={class:"body"};function q(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:B(["chat-row",{mine:r.isMine}])},[n("div",M,[n("div",N,[n("span",R,a(r.actorLabel),1),n("span",D,a(r.formattedTime),1)]),n("div",V,a(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:C(()=>[x(a(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const j=k(T,[["render",q],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-PMRrTD/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{j as default};

package/src/assets/web-panel/assets/MobileProjects-D10VISps.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as b}from"./vendor-Bn1JzzAn.js";import{_ as v,b as m}from"./index-CudmwNBV.js";import{a8 as M,M as y}from"./icons-DG5UD-6K.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=m();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return m},get MobileOutlined(){return y},get FolderOutlined(){return M}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},T={class:"subtitle"},k={class:"explainer"};function w(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",T,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",k,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),b(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),b(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",w],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-PMRrTD/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};

package/src/assets/web-panel/assets/devWarning-DhiGrbsh.js

@@ -1 +0,0 @@
-import{Q as r}from"./index-CudmwNBV.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-B7a1TrU6.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-C5MRZ0bi.js";import{a0 as t}from"./index-CudmwNBV.js";import"./vendor-Bn1JzzAn.js";import"./responsiveObserve-Ck42c9MP.js";import"./useFlexGapSupport-DoIVpJNq.js";import"./styleChecker-B4K46m5w.js";import"./index-Ck_52dz_.js";import"./icons-DG5UD-6K.js";const l=t(o);export{l as default};

package/src/assets/web-panel/assets/index-C2B1KRja.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-DAB5ZWm7.js";import{a0 as t}from"./index-CudmwNBV.js";import"./vendor-Bn1JzzAn.js";import"./index-Ck_52dz_.js";import"./icons-DG5UD-6K.js";const s=t(o);export{s as default};