@abelxiaoxing/cadence 1.8.2 → 1.8.4

package/src/phase-execution.ts

@@ -26,7 +26,6 @@ import type {
   TaskLedger,
   VerifiedTaskEvent,
 } from "./task-ledger.ts";
-import type { RunWorkerBroker } from "./worker-broker.ts";
 import {
   type DependencyContractEntry,
   DependencyManifestError,
@@ -39,11 +38,9 @@ import {
   hash,
   hasUnapprovedDependencyChange,
   hasVerificationLifecycle,
-  implementationRouteRequirements,
   isRecord,
   LOCKFILES,
   SHA256,
-  semanticRouteFailure,
   taskExecutionContract,
   type WorkflowAttemptOutcome,
   type WorkflowRouteFacts,
@@ -81,17 +78,14 @@ export class PhaseExecution {
     DurableWorkflowEngineOptions,
     "verificationPolicy" | "verificationEnvironment" | "proposeCandidate"
   >;
-  readonly #broker: RunWorkerBroker;
   constructor(
     options: Pick<
       DurableWorkflowEngineOptions,
       "verificationPolicy" | "verificationEnvironment" | "proposeCandidate"
     >,
-    broker: RunWorkerBroker,
     services: PhaseExecutionServices,
   ) {
     this.#options = options;
-    this.#broker = broker;
     this.#services = services;
   }
   #recordCorrection(
@@ -559,25 +553,6 @@ export class PhaseExecution {
         proposalRoot,
         request.signal,
       );
-      if (request.routeId && !pending) {
-        const rebound = this.#broker.resumeBinding({
-          runId: request.runId,
-          taskId: request.taskId,
-          role: "implementation-worker",
-          routeId: request.routeId,
-          ...(request.routeFingerprint
-            ? { expectedFingerprint: request.routeFingerprint }
-            : {}),
-          requirements: implementationRouteRequirements({
-            task: request.task,
-            ...(request.artifactCorrection
-              ? { artifactCorrection: request.artifactCorrection }
-              : {}),
-            repair: { failureIdentities: input.failureIdentities },
-          }),
-        });
-        if (!rebound.ok) return { kind: "paused", code: rebound.code };
-      }
       const ledgerProjection = ledger.projection({
         runId: request.runId,
         taskId: request.taskId,
@@ -588,99 +563,76 @@ export class PhaseExecution {
         attribution: "introduced" as const,
         failureIdentities: [...input.failureIdentities],
       };
-      let identity: BeginCandidateInput | undefined = pending?.identity;
-      const routed = pending
-        ? {
-            ok: true as const,
-            value: pending.proposal,
-            routeId: pending.identity.routeId,
-            routeFingerprint: pending.identity.routeFingerprint,
-          }
-        : await this.#broker.run({
-            runId: request.runId,
-            taskId: request.taskId,
-            operationId: `${request.operationId}:${request.taskId}:repair:${input.repairAttempt}`,
-            role: "implementation-worker",
-            requirements: implementationRouteRequirements({
-              task: request.task,
-              ...(request.artifactCorrection
-                ? { artifactCorrection: request.artifactCorrection }
-                : {}),
-              repair: { failureIdentities: input.failureIdentities },
-            }),
-            signal: request.signal,
-            ...(request.onActivity ? { onActivity: request.onActivity } : {}),
-            classifyResult: semanticRouteFailure,
-            execute: async (attempt) => {
-              identity = {
-                candidateId: `candidate-${randomUUID()}`,
-                runId: request.runId,
-                deliveryRevision: request.deliveryRevision,
-                taskId: request.taskId,
-                phase: request.phase,
-                attemptId: `repair-${hash(
-                  request.operationId,
-                  request.taskId,
-                  String(input.repairAttempt),
-                  attempt.route.fingerprint,
-                ).slice(0, 40)}`,
-                approvedPaths,
-                isolatedRevisionId: baseRevisionId,
-                verificationId: request.task.repairVerification.id,
-                routeId: attempt.route.id,
-                routeFingerprint: attempt.route.fingerprint,
-              };
-              if (request.reserveCandidate && !request.reserveCandidate())
-                return {
-                  kind: "paused" as const,
-                  code:
-                    request.additionalAttempt || request.verificationOnly
-                      ? "repair-attempts-exhausted"
-                      : "change-work-budget-exhausted",
-                };
-              return this.#options.proposeCandidate({
-                runId: request.runId,
-                operationId: request.operationId,
-                deliveryRevision: request.deliveryRevision,
-                taskId: request.taskId,
-                phase: request.phase,
-                task: structuredClone(request.task),
-                contextReadPaths: request.contextReadPaths,
-                workspaceRoot: proposalRoot,
-                ledgerProjection,
-                candidateArtifact: {
-                  ledger,
-                  identity,
-                  workspaceRoot: proposalRoot,
-                  writePaths: approvedWritePaths,
-                  deletePaths: approvedDeletePaths,
-                },
-                route: attempt.route,
-                repair,
-                ...(request.artifactCorrection
-                  ? { artifactCorrection: request.artifactCorrection }
-                  : {}),
-                ...(request.contextRequest
-                  ? { contextRequest: request.contextRequest }
-                  : {}),
-                ...(request.recoveryFeedback
-                  ? { recoveryFeedback: request.recoveryFeedback }
-                  : {}),
-                signal: attempt.signal,
-                onRequestStart: attempt.onRequestStart,
-                onHeaders: attempt.onHeaders,
-                onProgress: attempt.onProgress,
-              });
+      const launch = async () => {
+        const identity: BeginCandidateInput = {
+          candidateId: `candidate-${randomUUID()}`,
+          runId: request.runId,
+          deliveryRevision: request.deliveryRevision,
+          taskId: request.taskId,
+          phase: request.phase,
+          attemptId: `repair-${hash(
+            request.operationId,
+            request.taskId,
+            String(input.repairAttempt),
+            hash("pi-process"),
+          ).slice(0, 40)}`,
+          approvedPaths,
+          isolatedRevisionId: baseRevisionId,
+          verificationId: request.task.repairVerification.id,
+          routeId: "pi-process",
+          routeFingerprint: hash("pi-process"),
+        };
+        if (request.reserveCandidate && !request.reserveCandidate())
+          return {
+            identity,
+            proposal: {
+              kind: "paused" as const,
+              code:
+                request.additionalAttempt || request.verificationOnly
+                  ? "repair-attempts-exhausted"
+                  : "change-work-budget-exhausted",
             },
-          });
-      if (!routed.ok) {
-        return routed.state === "cancelled" || request.signal.aborted
-          ? { kind: "operation-cancelled", code: "cancelled" }
-          : { kind: "paused", code: routed.code };
-      }
-      if (!identity || identity.routeId !== routed.routeId) {
-        throw new Error("candidate-route-identity-invalid");
-      }
+          };
+        const proposal = await this.#options.proposeCandidate({
+          runId: request.runId,
+          operationId: request.operationId,
+          deliveryRevision: request.deliveryRevision,
+          taskId: request.taskId,
+          phase: request.phase,
+          task: structuredClone(request.task),
+          contextReadPaths: request.contextReadPaths,
+          workspaceRoot: proposalRoot,
+          ledgerProjection,
+          candidateArtifact: {
+            ledger,
+            identity,
+            workspaceRoot: proposalRoot,
+            writePaths: approvedWritePaths,
+            deletePaths: approvedDeletePaths,
+          },
+          repair,
+          ...(request.artifactCorrection
+            ? { artifactCorrection: request.artifactCorrection }
+            : {}),
+          ...(request.contextRequest
+            ? { contextRequest: request.contextRequest }
+            : {}),
+          ...(request.recoveryFeedback
+            ? { recoveryFeedback: request.recoveryFeedback }
+            : {}),
+          signal: request.signal,
+          onRequestStart: () =>
+            emitWorkflowActivity(request.onActivity, {
+              state: "waiting-first-response",
+            }),
+          onHeaders: () =>
+            emitWorkflowActivity(request.onActivity, { state: "running" }),
+          onProgress: () =>
+            emitWorkflowActivity(request.onActivity, { state: "running" }),
+        });
+        return { identity, proposal };
+      };
+      const { identity, proposal } = pending ?? (await launch());
       const correctionIdentity = identity;
       const withRoute = <T extends object>(outcome: T) => ({
         ...outcome,
@@ -708,7 +660,6 @@ export class PhaseExecution {
         this.#recordCorrection(ledger, request, correctionIdentity, correction);
         return withRoute({ ...outcome, retryPolicy: correction.category });
       };
-      const proposal = routed.value;
       if (
         proposal.kind !== "candidate" &&
         proposal.kind !== "sealed-candidate"
@@ -1651,123 +1602,77 @@ export class PhaseExecution {
         proposalRoot,
         input.signal,
       );
-      if (input.routeId && !pending) {
-        const rebound = this.#broker.resumeBinding({
-          runId: input.runId,
-          taskId: input.taskId,
-          role: "implementation-worker",
-          routeId: input.routeId,
-          ...(input.routeFingerprint
-            ? { expectedFingerprint: input.routeFingerprint }
-            : {}),
-          requirements: implementationRouteRequirements({
-            task: input.task,
-            ...(input.artifactCorrection
-              ? { artifactCorrection: input.artifactCorrection }
-              : {}),
-            ...(input.repair ? { repair: input.repair } : {}),
-          }),
-        });
-        if (!rebound.ok) {
-          return retained({ kind: "paused", code: rebound.code });
-        }
-      }
       const ledgerProjection = ledger.projection({
         runId: input.runId,
         taskId: input.taskId,
         nextPhase: input.phase,
       });
-      let identity: BeginCandidateInput | undefined = pending?.identity;
-      const routed = pending
-        ? {
-            ok: true as const,
-            value: pending.proposal,
-            routeId: pending.identity.routeId,
-            routeFingerprint: pending.identity.routeFingerprint,
-          }
-        : await this.#broker.run({
-            runId: input.runId,
-            taskId: input.taskId,
-            operationId: `${input.operationId}:${input.taskId}:${input.phase}`,
-            role: "implementation-worker",
-            requirements: implementationRouteRequirements({
-              task: input.task,
-              ...(input.artifactCorrection
-                ? { artifactCorrection: input.artifactCorrection }
-                : {}),
-              ...(input.repair ? { repair: input.repair } : {}),
-            }),
-            signal: input.signal,
-            ...(input.onActivity ? { onActivity: input.onActivity } : {}),
-            classifyResult: semanticRouteFailure,
-            execute: async (attempt) => {
-              identity = {
-                candidateId: `candidate-${randomUUID()}`,
-                runId: input.runId,
-                deliveryRevision: input.deliveryRevision,
-                taskId: input.taskId,
-                phase: input.phase,
-                attemptId: `attempt-${hash(
-                  input.operationId,
-                  input.taskId,
-                  input.phase,
-                  attempt.route.fingerprint,
-                ).slice(0, 40)}`,
-                approvedPaths,
-                isolatedRevisionId: baseRevisionId,
-                verificationId: phase.verification.id,
-                routeId: attempt.route.id,
-                routeFingerprint: attempt.route.fingerprint,
-              };
-              if (input.reserveCandidate && !input.reserveCandidate())
-                return {
-                  kind: "paused" as const,
-                  code:
-                    input.additionalAttempt || input.verificationOnly
-                      ? "repair-attempts-exhausted"
-                      : "change-work-budget-exhausted",
-                };
-              return this.#options.proposeCandidate({
-                runId: input.runId,
-                operationId: input.operationId,
-                deliveryRevision: input.deliveryRevision,
-                taskId: input.taskId,
-                phase: input.phase,
-                task: structuredClone(input.task),
-                contextReadPaths: input.contextReadPaths,
-                workspaceRoot: proposalRoot,
-                ledgerProjection,
-                candidateArtifact: {
-                  ledger,
-                  identity,
-                  workspaceRoot: proposalRoot,
-                  writePaths: phase.write,
-                  deletePaths: phase.delete,
-                },
-                route: attempt.route,
-                ...(input.contextRequest
-                  ? { contextRequest: input.contextRequest }
-                  : {}),
-                ...(input.recoveryFeedback
-                  ? { recoveryFeedback: input.recoveryFeedback }
-                  : {}),
-                signal: attempt.signal,
-                onRequestStart: attempt.onRequestStart,
-                onHeaders: attempt.onHeaders,
-                onProgress: attempt.onProgress,
-              });
+      const launch = async () => {
+        const identity: BeginCandidateInput = {
+          candidateId: `candidate-${randomUUID()}`,
+          runId: input.runId,
+          deliveryRevision: input.deliveryRevision,
+          taskId: input.taskId,
+          phase: input.phase,
+          attemptId: `attempt-${hash(
+            input.operationId,
+            input.taskId,
+            input.phase,
+            hash("pi-process"),
+          ).slice(0, 40)}`,
+          approvedPaths,
+          isolatedRevisionId: baseRevisionId,
+          verificationId: phase.verification.id,
+          routeId: "pi-process",
+          routeFingerprint: hash("pi-process"),
+        };
+        if (input.reserveCandidate && !input.reserveCandidate())
+          return {
+            identity,
+            proposal: {
+              kind: "paused" as const,
+              code:
+                input.additionalAttempt || input.verificationOnly
+                  ? "repair-attempts-exhausted"
+                  : "change-work-budget-exhausted",
             },
-          });
-      if (!routed.ok) {
-        return retained(
-          routed.state === "cancelled" || input.signal.aborted
-            ? { kind: "operation-cancelled", code: "cancelled" }
-            : { kind: "paused", code: routed.code },
-        );
-      }
-      if (!identity || identity.routeId !== routed.routeId) {
-        throw new Error("candidate-route-identity-invalid");
-      }
+          };
+        const proposal = await this.#options.proposeCandidate({
+          runId: input.runId,
+          operationId: input.operationId,
+          deliveryRevision: input.deliveryRevision,
+          taskId: input.taskId,
+          phase: input.phase,
+          task: structuredClone(input.task),
+          contextReadPaths: input.contextReadPaths,
+          workspaceRoot: proposalRoot,
+          ledgerProjection,
+          candidateArtifact: {
+            ledger,
+            identity,
+            workspaceRoot: proposalRoot,
+            writePaths: phase.write,
+            deletePaths: phase.delete,
+          },
+          ...(input.contextRequest
+            ? { contextRequest: input.contextRequest }
+            : {}),
+          ...(input.recoveryFeedback
+            ? { recoveryFeedback: input.recoveryFeedback }
+            : {}),
+          signal: input.signal,
+          onRequestStart: () =>
+            emitWorkflowActivity(input.onActivity, {
+              state: "waiting-first-response",
+            }),
+          onHeaders: () =>
+            emitWorkflowActivity(input.onActivity, { state: "running" }),
+          onProgress: () =>
+            emitWorkflowActivity(input.onActivity, { state: "running" }),
+        });
+        return { identity, proposal };
+      };
+      const { identity, proposal } = pending ?? (await launch());
       const correctionIdentity = identity;
       selectedRoute = {
         routeId: identity.routeId,
@@ -1794,7 +1699,6 @@ export class PhaseExecution {
         this.#recordCorrection(ledger, input, correctionIdentity, correction);
         return retained({ ...outcome, retryPolicy: correction.category });
       };
-      const proposal = routed.value;
       if (
         proposal.kind !== "candidate" &&
         proposal.kind !== "sealed-candidate"

package/src/startup-card.ts

@@ -26,22 +26,19 @@ export function startupCardLines(options: {
   home: string;
   projectTrusted: boolean;
 }): string[] {
-  const lines = ["Cadence · 研究能力（仅本地配置检查，未联网验证）"];
+  const lines: string[] = [];
   if (!options.projectTrusted) {
-    return [
-      ...lines,
-      "尚未信任当前项目：未读取研究配置；信任项目后重新加载可查看状态。",
-      "不自动启动 Abel 工作流；请勿在聊天中发送 API Key。",
-    ];
+    return ["Cadence：当前项目未信任，未读取研究配置。"];
   }
 
   let selectedPath: string | null = null;
   try {
     selectedPath = selectConfigPath(options);
     const { values } = loadConfig({ ...options, allowMissing: true });
-    const context7 = !validUrl(
+    const context7UrlValid = validUrl(
       values.CONTEXT7_API_URL || "https://context7.com/api/v2",
-    )
+    );
+    const context7 = !context7UrlValid
       ? "CONTEXT7_API_URL 格式无效"
       : values.CONTEXT7_API_KEY
         ? "已配置密钥"
@@ -49,36 +46,33 @@ export function startupCardLines(options: {
     const missing = ["GROK_API_URL", "GROK_API_KEY"].filter(
       (name) => !values[name],
     );
+    const grokUrlValid = !missing.length && validUrl(values.GROK_API_URL);
     const grok = missing.length
       ? `待配置 ${missing.join("、")}`
-      : !validUrl(values.GROK_API_URL)
+      : !grokUrlValid
         ? "GROK_API_URL 格式无效"
         : "已配置";
+    const tavilyUrlValid = validUrl(
+      values.TAVILY_API_URL || "https://api.tavily.com",
+    );
     const tavily =
       values.TAVILY_ENABLED === "false"
         ? "已关闭"
         : !values.TAVILY_API_KEY
           ? "未配置（可选）"
-          : !validUrl(values.TAVILY_API_URL || "https://api.tavily.com")
+          : !tavilyUrlValid
             ? "TAVILY_API_URL 格式无效"
-            : "已配置（Grok Skill 仍需 Grok 配置）";
-    lines.push(
-      `文档查询 Context7：${context7}`,
-      `联网搜索 Grok：${grok}；Tavily：${tavily}`,
-    );
+            : "已配置";
+    lines.push(`Context7：${context7}｜Grok：${grok}｜Tavily：${tavily}`);
   } catch {
-    lines.push("研究配置无法读取或解析：请检查下方文件；未回退到其他配置。");
+    lines.push("研究配置无法读取或解析：请检查配置文件；未回退到其他配置。");
   }
 
   const userPath = path.join(options.home, ".pi", "agent", "cadence", ".env");
-  const projectPath = path.join(options.cwd, ".pi", "cadence", ".env");
-  lines.push(
+  lines.unshift(
     selectedPath
-      ? `生效文件：${displayPath(selectedPath)}${selectedPath === projectPath ? "（项目整文件优先，不合并用户配置）" : "（用户级，跨项目复用）"}`
-      : `配置位置：${displayPath(userPath)}（用户级，跨项目复用）`,
-    "在本地编辑该文件：GROK_API_URL=<服务地址>、GROK_API_KEY=<密钥>，每项一行；可选 TAVILY_API_KEY。",
-    "研究 Skills 不读取 shell API 变量；保存后下次调用生效。不要把密钥发到聊天或提交到 Git。",
-    "可选服务未配置不阻塞普通任务，也不自动启动 Abel 工作流。",
+      ? `Cadence配置文件：${displayPath(selectedPath)}`
+      : `Cadence配置文件：${displayPath(userPath)}（未创建）`,
   );
   return lines;
 }