@abelxiaoxing/cadence 2.0.22 → 2.0.24
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.de.md +4 -10
- package/README.es.md +4 -10
- package/README.fr.md +4 -10
- package/README.ja.md +4 -10
- package/README.ko.md +4 -10
- package/README.md +5 -13
- package/README.pt-BR.md +4 -10
- package/README.ru.md +4 -10
- package/README.zh-CN.md +4 -12
- package/docs/conversation-mode.md +22 -2
- package/docs/history.md +50 -0
- package/docs/service-management.md +1 -1
- package/package.json +9 -7
- package/src/agent-panel-cadence.ts +4 -4
- package/src/cadence-mode.ts +284 -166
- package/src/coordinator-tools.mjs +9 -0
- package/src/data-shapes.ts +16 -0
- package/src/history-shell.ts +370 -0
- package/src/index.ts +3 -3
- package/src/native-build.ts +1 -1
- package/src/native-client.ts +1 -1
- package/src/native-workflow-history.ts +134 -0
- package/src/operator-cli.mjs +93 -65
- package/src/research-tools.mjs +365 -0
- package/src/sdk-worker.mjs +59 -9
- package/src/service/checkout-lock.ts +142 -0
- package/src/service/contracts/workbench.ts +43 -23
- package/src/service/contracts/workflow.ts +137 -2
- package/src/service/coordination.ts +6 -7
- package/src/service/private-files.ts +2 -1
- package/src/service-cli.mjs +259 -425
- package/src/service-host.mjs +3680 -6048
- package/src/worker-public.mjs +16 -1
- package/src/workspace.ts +302 -0
- package/web/dist/assets/cadence.css +1 -1
- package/web/dist/assets/cadence.js +16 -15
- package/web/dist/manifest.json +7 -7
- package/config/workflow-task.example.json +0 -7
- package/src/plan-proposal.ts +0 -87
- package/src/task-shell.ts +0 -1059
- package/src/task-store.ts +0 -593
- package/src/task-types.ts +0 -184
package/src/cadence-mode.ts
CHANGED
|
@@ -30,19 +30,21 @@ import {
|
|
|
30
30
|
type WorkflowRequest,
|
|
31
31
|
type WorkflowResponse,
|
|
32
32
|
type WorkflowRun,
|
|
33
|
+
workflowDiagnostics,
|
|
33
34
|
} from "./service/contracts/workflow.ts";
|
|
34
35
|
import { ServiceCoordination } from "./service/coordination.ts";
|
|
35
36
|
import {
|
|
36
37
|
ContractError,
|
|
37
38
|
canonicalJson,
|
|
39
|
+
decodeId,
|
|
38
40
|
decodeModelSelector,
|
|
39
41
|
type ErrorCode,
|
|
40
42
|
type ModelSelector,
|
|
41
43
|
type PublicError,
|
|
42
44
|
type Reply,
|
|
43
45
|
} from "./service-contract.ts";
|
|
44
|
-
import { effectiveWorkspace } from "./task-store.ts";
|
|
45
46
|
import { diagnosticText } from "./verification-diagnostics.ts";
|
|
47
|
+
import { effectiveWorkspace } from "./workspace.ts";
|
|
46
48
|
|
|
47
49
|
export const CADENCE_MODE_ENTRY = "cadence-conversation-mode/1";
|
|
48
50
|
const CONTEXT = "cadence-mode-context";
|
|
@@ -280,6 +282,34 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
280
282
|
let state = idle(),
|
|
281
283
|
context: ExtensionContext | undefined,
|
|
282
284
|
generation = 0;
|
|
285
|
+
// One native conversation has one current run/proposal. Claim synchronously,
|
|
286
|
+
// before any attachment/model await; status and explicit Cancel remain usable.
|
|
287
|
+
type Mutation = { generation: number; assertCurrent(): void };
|
|
288
|
+
let mutation: Mutation | undefined;
|
|
289
|
+
const changing = async <T>(
|
|
290
|
+
ctx: ExtensionContext,
|
|
291
|
+
body: (claim: Mutation) => Promise<T>,
|
|
292
|
+
) => {
|
|
293
|
+
active(ctx);
|
|
294
|
+
if (mutation?.generation === generation)
|
|
295
|
+
throw new Error(
|
|
296
|
+
"A Cadence request is already in progress. Use cadence_status; no additional work was sent.",
|
|
297
|
+
);
|
|
298
|
+
const claim: Mutation = {
|
|
299
|
+
generation,
|
|
300
|
+
assertCurrent() {
|
|
301
|
+
if (claim.generation !== generation || mutation !== claim)
|
|
302
|
+
throw new ContractError("stale");
|
|
303
|
+
active(ctx);
|
|
304
|
+
},
|
|
305
|
+
};
|
|
306
|
+
mutation = claim;
|
|
307
|
+
try {
|
|
308
|
+
return await body(claim);
|
|
309
|
+
} finally {
|
|
310
|
+
if (mutation === claim) mutation = undefined;
|
|
311
|
+
}
|
|
312
|
+
};
|
|
283
313
|
let permission: { id: string; digest: string; at: number } | undefined;
|
|
284
314
|
let allowStart = false,
|
|
285
315
|
reattach = false;
|
|
@@ -353,7 +383,7 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
353
383
|
context = ctx;
|
|
354
384
|
};
|
|
355
385
|
const summarize = (run: WorkflowRun) =>
|
|
356
|
-
`Cadence ${run.status} • ${run.goal}\n${run.steps.map((s) => `${s.kind} ${s.id}: ${s.status}${s.exitCode === null ? "" : ` (exit ${s.exitCode})`}\n${s.text}${s.truncated ? "\n[Preview truncated; full result retained by owner.]" : ""}`).join("\n")}\n${run.notice}${run.mergedCommit ? `\nLocal merge: ${run.mergedCommit}` : ""}${run.status === "unknown" ? "\nOutcome unknown: neither completed nor failed. Its actual effects are not inferred, and the owner keeps any fences." : ""}\nAutomatic review is not human review. Cadence mode remains enabled.`;
|
|
386
|
+
`Cadence ${run.status} • ${run.goal}\nRun: ${run.id}\n${workflowDiagnostics(run)}\n${run.steps.map((s) => `${s.kind} ${s.id}: ${s.status}${s.exitCode === null ? "" : ` (exit ${s.exitCode})`}\n${s.text}${s.truncated ? "\n[Preview truncated; full result retained by owner.]" : ""}`).join("\n")}\n${run.notice}${run.mergedCommit ? `\nLocal merge: ${run.mergedCommit}` : ""}${run.status === "unknown" ? "\nOutcome unknown: neither completed nor failed. Its actual effects are not inferred, and the owner keeps any fences." : ""}\nAutomatic review is not human review. Cadence mode remains enabled.`;
|
|
357
387
|
const agentDir = () => getAgentDir();
|
|
358
388
|
const launchOwner = async (ctx: ExtensionContext) => {
|
|
359
389
|
if (process.env.CADENCE_AUTOSTART === "0")
|
|
@@ -501,8 +531,10 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
501
531
|
});
|
|
502
532
|
};
|
|
503
533
|
const connect = async (ctx: ExtensionContext, selectModel = true) => {
|
|
534
|
+
const expected = generation;
|
|
504
535
|
active(ctx);
|
|
505
536
|
await ensureAttached(ctx);
|
|
537
|
+
if (generation !== expected) throw new ContractError("stale");
|
|
506
538
|
if (!connection.client || !connection.compatible()) {
|
|
507
539
|
reattach = true;
|
|
508
540
|
let stop = "its explicit stop command";
|
|
@@ -516,13 +548,17 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
516
548
|
);
|
|
517
549
|
}
|
|
518
550
|
if (selectModel) await ensureModel(ctx);
|
|
551
|
+
if (generation !== expected) throw new ContractError("stale");
|
|
519
552
|
};
|
|
520
553
|
const request = async (
|
|
521
554
|
ctx: ExtensionContext,
|
|
522
555
|
input: WorkflowRequest,
|
|
523
556
|
commandId = randomUUID(),
|
|
524
557
|
sending?: () => void,
|
|
558
|
+
claim?: Mutation,
|
|
525
559
|
): Promise<WorkflowResponse> => {
|
|
560
|
+
claim?.assertCurrent();
|
|
561
|
+
const expected = generation;
|
|
526
562
|
await connect(
|
|
527
563
|
ctx,
|
|
528
564
|
input.action === "research" || input.action === "propose",
|
|
@@ -535,9 +571,14 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
535
571
|
epoch: connection.session.epoch,
|
|
536
572
|
request: input,
|
|
537
573
|
};
|
|
574
|
+
if (expected !== generation) throw new ContractError("stale");
|
|
575
|
+
claim?.assertCurrent();
|
|
576
|
+
active(ctx);
|
|
538
577
|
// Everything before this point had no owner effect.
|
|
539
578
|
sending?.();
|
|
540
579
|
const r = value(await connection.client.workbenchCommand(command));
|
|
580
|
+
if (generation !== expected) throw new ContractError("stale");
|
|
581
|
+
claim?.assertCurrent();
|
|
541
582
|
if (r.kind !== "workflow") throw new ContractError("invalid");
|
|
542
583
|
const response = r.response;
|
|
543
584
|
if (
|
|
@@ -590,10 +631,13 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
590
631
|
return `Attempted run ${id} is not known to the owner and is not active, so it was never accepted. Cadence forgot it; nothing was replayed.\n`;
|
|
591
632
|
};
|
|
592
633
|
/** Returns a notice when an attempted run was proven absent and forgotten. */
|
|
593
|
-
const requireSettledRun = async (ctx: ExtensionContext) => {
|
|
594
|
-
|
|
595
|
-
const
|
|
596
|
-
if (
|
|
634
|
+
const requireSettledRun = async (ctx: ExtensionContext, claim: Mutation) => {
|
|
635
|
+
claim.assertCurrent();
|
|
636
|
+
const id = state.runId;
|
|
637
|
+
if (!id) return "";
|
|
638
|
+
const seen = await observe(ctx, id);
|
|
639
|
+
claim.assertCurrent();
|
|
640
|
+
if ("absent" in seen) return forget(id);
|
|
597
641
|
const previous = seen.run;
|
|
598
642
|
if (["running", "queued"].includes(previous.status))
|
|
599
643
|
throw new Error(
|
|
@@ -905,53 +949,88 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
905
949
|
parameters: Type.Object({
|
|
906
950
|
goal: Type.String(),
|
|
907
951
|
questions: Type.Array(Type.String(), { minItems: 1, maxItems: 2 }),
|
|
952
|
+
roots: Type.Optional(
|
|
953
|
+
Type.Array(
|
|
954
|
+
Type.String({
|
|
955
|
+
description:
|
|
956
|
+
"Specific investigation directories; defaults to project cwd. Avoid filesystem roots and broad parent trees.",
|
|
957
|
+
}),
|
|
958
|
+
{ minItems: 1, maxItems: 8 },
|
|
959
|
+
),
|
|
960
|
+
),
|
|
908
961
|
}),
|
|
909
962
|
async execute(_id, input, signal, update, ctx) {
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
963
|
+
return changing(ctx, async (claim) => {
|
|
964
|
+
active(ctx);
|
|
965
|
+
await connect(ctx);
|
|
966
|
+
claim.assertCurrent();
|
|
967
|
+
const notice = await requireSettledRun(ctx, claim);
|
|
968
|
+
const model = value(await client().models()).version;
|
|
969
|
+
const commandId = randomUUID(),
|
|
970
|
+
before = state.runId;
|
|
971
|
+
let sent = false,
|
|
972
|
+
response: WorkflowResponse;
|
|
973
|
+
try {
|
|
974
|
+
response = await request(
|
|
975
|
+
ctx,
|
|
976
|
+
{ action: "research", ...input, model },
|
|
977
|
+
commandId,
|
|
978
|
+
() => {
|
|
979
|
+
// Retain the attempted identity before transport: a lost reply is
|
|
980
|
+
// observed, never replaced with another research request.
|
|
981
|
+
state.runId = commandId;
|
|
982
|
+
persist();
|
|
983
|
+
sent = true;
|
|
984
|
+
},
|
|
985
|
+
claim,
|
|
986
|
+
);
|
|
987
|
+
} catch (error) {
|
|
988
|
+
if (
|
|
989
|
+
generation === claim.generation &&
|
|
990
|
+
(!sent || definite(error)) &&
|
|
991
|
+
state.runId === commandId
|
|
992
|
+
) {
|
|
993
|
+
state.runId = before;
|
|
927
994
|
persist();
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
);
|
|
931
|
-
} catch (error) {
|
|
932
|
-
if ((!sent || definite(error)) && state.runId === commandId) {
|
|
933
|
-
state.runId = before;
|
|
934
|
-
persist();
|
|
995
|
+
}
|
|
996
|
+
throw error;
|
|
935
997
|
}
|
|
936
|
-
throw
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
998
|
+
if (response.type !== "run") throw new ContractError("invalid");
|
|
999
|
+
status("research");
|
|
1000
|
+
const expected = generation;
|
|
1001
|
+
let run = response.run;
|
|
1002
|
+
while (
|
|
1003
|
+
["queued", "running"].includes(run.status) &&
|
|
1004
|
+
!signal?.aborted &&
|
|
1005
|
+
generation === expected
|
|
1006
|
+
) {
|
|
1007
|
+
update?.(
|
|
1008
|
+
result(
|
|
1009
|
+
`Investigating: ${run.goal}\n${run.steps.map((s) => `${s.kind} ${s.id}: ${s.status}`).join("\n")}\nSubagents are listed in Pi's agent panel.`,
|
|
1010
|
+
),
|
|
1011
|
+
);
|
|
1012
|
+
await new Promise((resolve) => setTimeout(resolve, 1000));
|
|
1013
|
+
if (generation !== expected) break;
|
|
1014
|
+
const seen = await observe(ctx, run.id);
|
|
1015
|
+
if (generation !== expected) break;
|
|
1016
|
+
if ("absent" in seen) throw new ContractError("unavailable");
|
|
1017
|
+
run = seen.run;
|
|
1018
|
+
}
|
|
1019
|
+
if (generation === expected) {
|
|
1020
|
+
status("ready");
|
|
1021
|
+
if (signal?.aborted) watch(ctx, run.id);
|
|
1022
|
+
}
|
|
1023
|
+
return {
|
|
1024
|
+
...result(`${notice}${summarize(run)}`),
|
|
1025
|
+
details: {
|
|
1026
|
+
runId: run.id,
|
|
1027
|
+
steps: run.steps.map(({ id, childRunId }) => ({
|
|
1028
|
+
stepId: id,
|
|
1029
|
+
childRunId,
|
|
1030
|
+
})),
|
|
1031
|
+
},
|
|
1032
|
+
};
|
|
1033
|
+
});
|
|
955
1034
|
},
|
|
956
1035
|
});
|
|
957
1036
|
pi.registerTool({
|
|
@@ -961,38 +1040,47 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
961
1040
|
"After interactive clarification, publish the exact readable plan, dependency graph, checks, setup commands, repair budget and delivery policy for user approval. Does not execute.",
|
|
962
1041
|
parameters: PLAN,
|
|
963
1042
|
async execute(_id, input, _signal, _update, ctx) {
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
});
|
|
974
|
-
if (response.type !== "proposal") throw new ContractError("invalid");
|
|
975
|
-
state.proposal = response.proposal;
|
|
976
|
-
persist();
|
|
977
|
-
status("awaiting plan approval");
|
|
978
|
-
const shown = readableWorkflowPlan(response.proposal.plan);
|
|
979
|
-
const redacted =
|
|
980
|
-
canonicalJson(response.proposal.plan) !== canonicalJson(plan);
|
|
981
|
-
// The plan is displayed by this tool's own result: a message sent now
|
|
982
|
-
// would land between this tool call and its result.
|
|
983
|
-
return {
|
|
984
|
-
content: [
|
|
1043
|
+
return changing(ctx, async (claim) => {
|
|
1044
|
+
active(ctx);
|
|
1045
|
+
await connect(ctx);
|
|
1046
|
+
claim.assertCurrent();
|
|
1047
|
+
permission = undefined;
|
|
1048
|
+
const notice = await requireSettledRun(ctx, claim);
|
|
1049
|
+
const plan = decodeWorkflowPlan(input);
|
|
1050
|
+
const response = await request(
|
|
1051
|
+
ctx,
|
|
985
1052
|
{
|
|
986
|
-
|
|
987
|
-
|
|
1053
|
+
action: "propose",
|
|
1054
|
+
plan,
|
|
1055
|
+
model: value(await client().models()).version,
|
|
988
1056
|
},
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
1057
|
+
undefined,
|
|
1058
|
+
undefined,
|
|
1059
|
+
claim,
|
|
1060
|
+
);
|
|
1061
|
+
if (response.type !== "proposal") throw new ContractError("invalid");
|
|
1062
|
+
state.proposal = response.proposal;
|
|
1063
|
+
persist();
|
|
1064
|
+
status("awaiting plan approval");
|
|
1065
|
+
const shown = readableWorkflowPlan(response.proposal.plan);
|
|
1066
|
+
const redacted =
|
|
1067
|
+
canonicalJson(response.proposal.plan) !== canonicalJson(plan);
|
|
1068
|
+
// The plan is displayed by this tool's own result: a message sent now
|
|
1069
|
+
// would land between this tool call and its result.
|
|
1070
|
+
return {
|
|
1071
|
+
content: [
|
|
1072
|
+
{
|
|
1073
|
+
type: "text" as const,
|
|
1074
|
+
text: `${notice}${shown}\nPlan identity: ${response.proposal.digest}\n${redacted ? "The owner redacted credential-like text; the plan above is exactly what would run.\n" : ""}The user sees this complete plan. They can type 按计划实施 to approve these exact bytes; vague agreement is not execution consent. Existing unrelated working-copy changes are not imported into isolated candidates.`,
|
|
1075
|
+
},
|
|
1076
|
+
],
|
|
1077
|
+
details: {
|
|
1078
|
+
plan: shown,
|
|
1079
|
+
digest: response.proposal.digest,
|
|
1080
|
+
redacted,
|
|
1081
|
+
},
|
|
1082
|
+
};
|
|
1083
|
+
});
|
|
996
1084
|
},
|
|
997
1085
|
renderResult(output) {
|
|
998
1086
|
const d = output.details as
|
|
@@ -1021,110 +1109,133 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
1021
1109
|
"Start the current exact plan after fresh user approval. The service automatically implements, reviews, verifies, performs bounded repairs and delivers; client departure only detaches.",
|
|
1022
1110
|
parameters: Type.Object({}),
|
|
1023
1111
|
async execute(_id, _input, signal, _update, ctx) {
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
proposalId: proposal.id,
|
|
1058
|
-
digest: proposal.digest,
|
|
1059
|
-
});
|
|
1060
|
-
if (
|
|
1061
|
-
prepared.type !== "grant" ||
|
|
1062
|
-
canonicalJson(prepared.proposal.plan) !==
|
|
1063
|
-
canonicalJson(proposal.plan) ||
|
|
1064
|
-
prepared.proposal.cwd !== proposal.cwd
|
|
1065
|
-
)
|
|
1066
|
-
throw new ContractError("stale");
|
|
1067
|
-
const commandId = randomUUID(),
|
|
1068
|
-
before = { runId: state.runId, proposal };
|
|
1069
|
-
let sent = false,
|
|
1070
|
-
started: WorkflowResponse;
|
|
1071
|
-
try {
|
|
1072
|
-
started = await request(
|
|
1112
|
+
return changing(ctx, async (claim) => {
|
|
1113
|
+
active(ctx);
|
|
1114
|
+
const proposal = state.proposal;
|
|
1115
|
+
if (!proposal)
|
|
1116
|
+
throw new Error("No current plan. Clarify and propose it first.");
|
|
1117
|
+
const expected = generation;
|
|
1118
|
+
const fromInput =
|
|
1119
|
+
permission?.id === proposal.id &&
|
|
1120
|
+
permission.digest === proposal.digest &&
|
|
1121
|
+
Date.now() >= permission.at &&
|
|
1122
|
+
Date.now() - permission.at < 120000;
|
|
1123
|
+
permission = undefined;
|
|
1124
|
+
if (
|
|
1125
|
+
!fromInput &&
|
|
1126
|
+
!(await confirm(
|
|
1127
|
+
ctx,
|
|
1128
|
+
"Implement this plan automatically?",
|
|
1129
|
+
`${readableWorkflowPlan(proposal.plan)}\nProject: ${proposal.cwd}\nNo push or deployment. Keeping the discussion changes nothing.`,
|
|
1130
|
+
"Keep discussing (do not start)",
|
|
1131
|
+
"Start this exact plan",
|
|
1132
|
+
))
|
|
1133
|
+
)
|
|
1134
|
+
return result(
|
|
1135
|
+
"Not started. Cadence remains enabled for further discussion.",
|
|
1136
|
+
);
|
|
1137
|
+
if (
|
|
1138
|
+
signal?.aborted ||
|
|
1139
|
+
expected !== generation ||
|
|
1140
|
+
state.proposal?.digest !== proposal.digest
|
|
1141
|
+
)
|
|
1142
|
+
throw new ContractError("stale");
|
|
1143
|
+
// The grant is fresh after consent, so reading the plan never expires it.
|
|
1144
|
+
const prepared = await request(
|
|
1073
1145
|
ctx,
|
|
1074
1146
|
{
|
|
1075
|
-
action: "
|
|
1147
|
+
action: "prepare",
|
|
1076
1148
|
proposalId: proposal.id,
|
|
1077
1149
|
digest: proposal.digest,
|
|
1078
|
-
grant: prepared.grant,
|
|
1079
|
-
},
|
|
1080
|
-
commandId,
|
|
1081
|
-
() => {
|
|
1082
|
-
// Retain the exact attempted identity before transport; a lost
|
|
1083
|
-
// reply is observed, never replaced with another Start or a
|
|
1084
|
-
// revived approval.
|
|
1085
|
-
state.runId = commandId;
|
|
1086
|
-
state.proposal = null;
|
|
1087
|
-
persist();
|
|
1088
|
-
sent = true;
|
|
1089
1150
|
},
|
|
1151
|
+
undefined,
|
|
1152
|
+
undefined,
|
|
1153
|
+
claim,
|
|
1090
1154
|
);
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1155
|
+
if (
|
|
1156
|
+
prepared.type !== "grant" ||
|
|
1157
|
+
canonicalJson(prepared.proposal.plan) !==
|
|
1158
|
+
canonicalJson(proposal.plan) ||
|
|
1159
|
+
prepared.proposal.cwd !== proposal.cwd
|
|
1160
|
+
)
|
|
1161
|
+
throw new ContractError("stale");
|
|
1162
|
+
const commandId = randomUUID(),
|
|
1163
|
+
before = { runId: state.runId, proposal };
|
|
1164
|
+
let sent = false,
|
|
1165
|
+
started: WorkflowResponse;
|
|
1166
|
+
try {
|
|
1167
|
+
started = await request(
|
|
1168
|
+
ctx,
|
|
1169
|
+
{
|
|
1170
|
+
action: "execute",
|
|
1171
|
+
proposalId: proposal.id,
|
|
1172
|
+
digest: proposal.digest,
|
|
1173
|
+
grant: prepared.grant,
|
|
1174
|
+
},
|
|
1175
|
+
commandId,
|
|
1176
|
+
() => {
|
|
1177
|
+
// Retain the exact attempted identity before transport; a lost
|
|
1178
|
+
// reply is observed, never replaced with another Start or a
|
|
1179
|
+
// revived approval.
|
|
1180
|
+
state.runId = commandId;
|
|
1181
|
+
state.proposal = null;
|
|
1182
|
+
persist();
|
|
1183
|
+
sent = true;
|
|
1184
|
+
},
|
|
1185
|
+
claim,
|
|
1186
|
+
);
|
|
1187
|
+
} catch (error) {
|
|
1188
|
+
// A proven refusal had no effect: keep the plan for a fresh approval.
|
|
1189
|
+
if (
|
|
1190
|
+
generation === claim.generation &&
|
|
1191
|
+
(!sent || definite(error)) &&
|
|
1192
|
+
state.runId === commandId
|
|
1193
|
+
) {
|
|
1194
|
+
state.runId = before.runId;
|
|
1195
|
+
state.proposal = before.proposal;
|
|
1196
|
+
persist();
|
|
1197
|
+
}
|
|
1198
|
+
throw error;
|
|
1097
1199
|
}
|
|
1098
|
-
throw
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
|
|
1108
|
-
);
|
|
1200
|
+
if (started.type !== "run") throw new ContractError("invalid");
|
|
1201
|
+
state.runId = started.run.id;
|
|
1202
|
+
state.proposal = null;
|
|
1203
|
+
persist();
|
|
1204
|
+
status("executing");
|
|
1205
|
+
watch(ctx, started.run.id);
|
|
1206
|
+
return result(
|
|
1207
|
+
`Accepted. Implementation, verification and agreed delivery now run under the persistent owner. No further routine approval is needed. ${started.run.id}\nCadence remains enabled. Closing/switching the conversation does not cancel this work.`,
|
|
1208
|
+
);
|
|
1209
|
+
});
|
|
1109
1210
|
},
|
|
1110
1211
|
});
|
|
1111
1212
|
pi.registerTool({
|
|
1112
1213
|
name: "cadence_status",
|
|
1113
1214
|
label: "Observe workflow",
|
|
1114
1215
|
description:
|
|
1115
|
-
"Read
|
|
1216
|
+
"Read a retained workflow without replaying any action. Specify runId for earlier runs; otherwise selects the current run. With stepId read its result, or transcript: true for its transcript.",
|
|
1116
1217
|
parameters: Type.Object({
|
|
1218
|
+
runId: Type.Optional(Type.String()),
|
|
1117
1219
|
stepId: Type.Optional(Type.String()),
|
|
1118
1220
|
transcript: Type.Optional(Type.Boolean()),
|
|
1119
1221
|
}),
|
|
1120
1222
|
async execute(_id, input, _signal, _update, ctx) {
|
|
1121
1223
|
active(ctx);
|
|
1122
|
-
|
|
1224
|
+
const id =
|
|
1225
|
+
input.runId === undefined ? state.runId : decodeId(input.runId);
|
|
1226
|
+
if (!id)
|
|
1123
1227
|
return result(
|
|
1124
1228
|
"Cadence is enabled; no run yet. Continue clarifying the goal.",
|
|
1125
1229
|
);
|
|
1126
|
-
const id = state.runId;
|
|
1127
1230
|
if (input.stepId) {
|
|
1231
|
+
const seen = await observe(ctx, id);
|
|
1232
|
+
if (
|
|
1233
|
+
"absent" in seen ||
|
|
1234
|
+
!seen.run.steps.some((s) => s.id === input.stepId)
|
|
1235
|
+
)
|
|
1236
|
+
throw new Error(
|
|
1237
|
+
`Step ${input.stepId} does not belong to selected run ${id}. Supply the exact runId and stepId from the research result; no other run was searched.`,
|
|
1238
|
+
);
|
|
1128
1239
|
await connect(ctx, false);
|
|
1129
1240
|
if (input.transcript) {
|
|
1130
1241
|
const t = value(
|
|
@@ -1158,14 +1269,20 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
1158
1269
|
}
|
|
1159
1270
|
const seen = await observe(ctx, id);
|
|
1160
1271
|
if ("absent" in seen) {
|
|
1272
|
+
if (id !== state.runId)
|
|
1273
|
+
return result(
|
|
1274
|
+
`Run ${id} is not known to this owner. Current selection was not changed.`,
|
|
1275
|
+
);
|
|
1161
1276
|
status("ready");
|
|
1162
1277
|
return result(`${forget(id)}Continue normally.`);
|
|
1163
1278
|
}
|
|
1164
1279
|
const run = seen.run;
|
|
1165
|
-
if (["running", "queued"].includes(run.status))
|
|
1166
|
-
|
|
1280
|
+
if (id === state.runId && ["running", "queued"].includes(run.status))
|
|
1281
|
+
watch(ctx, run.id);
|
|
1282
|
+
if (id === state.runId && run.status === "unknown")
|
|
1283
|
+
acknowledgedUnknown = run.id;
|
|
1167
1284
|
return result(
|
|
1168
|
-
`${summarize(run)}${run.status === "unknown" ? "\nThis explicit observation is recorded: research or a new plan may now continue. A new plan observes the current files; nothing about this run is assumed." : ""}`,
|
|
1285
|
+
`${summarize(run)}${run.status === "unknown" && id === state.runId ? "\nThis explicit observation is recorded: research or a new plan may now continue. A new plan observes the current files; nothing about this run is assumed." : ""}`,
|
|
1169
1286
|
);
|
|
1170
1287
|
},
|
|
1171
1288
|
});
|
|
@@ -1177,18 +1294,19 @@ export function registerCadenceMode(pi: ExtensionAPI): void {
|
|
|
1177
1294
|
parameters: Type.Object({}),
|
|
1178
1295
|
async execute(_id, _input, _signal, _update, ctx) {
|
|
1179
1296
|
active(ctx);
|
|
1180
|
-
|
|
1297
|
+
const runId = state.runId;
|
|
1298
|
+
if (!runId) return result("No active workflow.");
|
|
1181
1299
|
if (
|
|
1182
1300
|
!(await confirm(
|
|
1183
1301
|
ctx,
|
|
1184
1302
|
"Cancel current workflow?",
|
|
1185
|
-
|
|
1303
|
+
`Request Stop for ${runId} and retain actual files/results. This does not reset or undo edits. Cadence mode remains enabled.`,
|
|
1186
1304
|
"Keep running",
|
|
1187
1305
|
"Request cancellation",
|
|
1188
1306
|
))
|
|
1189
1307
|
)
|
|
1190
1308
|
return result("Cancellation not requested.");
|
|
1191
|
-
const r = await request(ctx, { action: "cancel", runId
|
|
1309
|
+
const r = await request(ctx, { action: "cancel", runId });
|
|
1192
1310
|
if (r.type !== "run") throw new ContractError("invalid");
|
|
1193
1311
|
watch(ctx, r.run.id);
|
|
1194
1312
|
return result(
|
|
@@ -67,6 +67,15 @@ export function coordinatorTools() {
|
|
|
67
67
|
parameters: Type.Object({
|
|
68
68
|
goal: Type.String(),
|
|
69
69
|
questions: Type.Array(Type.String(), { minItems: 1, maxItems: 2 }),
|
|
70
|
+
roots: Type.Optional(
|
|
71
|
+
Type.Array(
|
|
72
|
+
Type.String({
|
|
73
|
+
description:
|
|
74
|
+
"Specific investigation directories; defaults to project cwd. Avoid filesystem roots and broad parent trees.",
|
|
75
|
+
}),
|
|
76
|
+
{ minItems: 1, maxItems: 8 },
|
|
77
|
+
),
|
|
78
|
+
),
|
|
70
79
|
}),
|
|
71
80
|
},
|
|
72
81
|
{
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
/** Small shape predicates shared by filesystem records; no task model. */
|
|
2
|
+
export function object(value: unknown): value is Record<string, unknown> {
|
|
3
|
+
return value !== null && typeof value === "object" && !Array.isArray(value);
|
|
4
|
+
}
|
|
5
|
+
export function boundedString(value: unknown, max: number): value is string {
|
|
6
|
+
return (
|
|
7
|
+
typeof value === "string" &&
|
|
8
|
+
Buffer.byteLength(value) <= max &&
|
|
9
|
+
!value.includes("\0")
|
|
10
|
+
);
|
|
11
|
+
}
|
|
12
|
+
export function validId(value: string): boolean {
|
|
13
|
+
return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(
|
|
14
|
+
value,
|
|
15
|
+
);
|
|
16
|
+
}
|