humanish 0.106.1 → 0.107.0

package/dist/routes/computer-use/subject-projection.js

@@ -1,32 +1,33 @@
-// Each lane's subject projection and the subject-state marker, from the declared subject and what
-// the lanes ran; the run-level subject aggregated from them; and the provenance argument the
+// Each participant's subject projection and the subject-state marker, from the declared subject
+// and what the participants ran; the run-level subject aggregated from them; and the provenance argument the
 // bundle builders take.
 import { commandDigestOf } from "../../subject/state.js";
 import { cuaDeclaredState } from "./plan.js";
 import {} from "../../run/bundle.js";
 import {} from "../../subject/local-tree-archive.js";
-import {} from "./plan.js";
-import {} from "./types.js";
+import { participantSubjectEnv, } from "./types.js";
 /**
- * Each lane's subject projection. A lane's outcome adds the subject commit it resolved and the
+ * Each participant's subject projection. A participant's outcome adds the subject commit it resolved and the
  * state steps it executed; without outcomes (dry run, or a run still in progress) the declared
  * state is projected as not yet run.
  */
 export function projectParticipantSubjects(args) {
-    const { subjectRoute, publicRepo, localTreeArchive } = args;
+    const { publicRepo, localTreeArchive } = args;
+    const { subject } = args.plan.runner;
+    const subjectEnvNames = [...participantSubjectEnv(subject)];
+    // Only a provisioned subject declares state; cuaDeclaredState is undefined for the others.
     const declaredState = cuaDeclaredState(args.plan);
     return args.runs.map((_spec, index) => {
         const outcome = args.outcomes?.[index];
         const subjectState = resolveSubjectState({
-            declared: subjectRoute.provisionedRoute ? declaredState : undefined,
+            declared: declaredState,
             dryRun: args.dryRun,
             executed: outcome?.stateStepRecords ?? [],
         });
         return participantSubjectProjection({
-            cloneRoute: subjectRoute.cloneRoute,
-            localTreeRoute: subjectRoute.localTreeRoute,
+            kind: subject.kind,
             ...(publicRepo === undefined ? {} : { publicRepo }),
-            subjectEnvNames: subjectRoute.subjectEnvNames,
+            subjectEnvNames,
             ...(outcome?.subjectCommit === undefined ? {} : { subjectCommit: outcome.subjectCommit }),
             ...(localTreeArchive === undefined ? {} : { localTreeArchive }),
             subjectState,
@@ -73,12 +74,12 @@ export function resolveSubjectState(args) {
         ...(external.length > 0 ? { externalEnvNames: external } : {}),
     };
 }
-/** Build the per-lane subject projection (invariant 5). Local-tree lanes all share ONE
- *  host-packed archive, so every lane's projection carries the identical archiveSha256/
- *  commit/dirty (no per-lane divergence is possible, unlike the clone route's per-lane
+/** Build the per-participant subject projection (invariant 5). Local-tree participants all share
+ *  ONE host-packed archive, so every participant's projection carries the identical archiveSha256/
+ *  commit/dirty (no divergence is possible, unlike the clone route's per-participant
  *  in-sandbox commit). */
 function participantSubjectProjection(args) {
-    if (args.cloneRoute && args.publicRepo) {
+    if (args.kind === "clone" && args.publicRepo) {
         return {
             source: "clone",
             repo: args.publicRepo,
@@ -87,7 +88,7 @@ function participantSubjectProjection(args) {
             state: args.subjectState,
         };
     }
-    if (args.localTreeRoute) {
+    if (args.kind === "local-tree") {
         const archive = args.localTreeArchive;
         return {
             source: "local-tree",
@@ -127,10 +128,10 @@ export function subjectProvenanceArg(subject, publicRepo, subjectEnvNames) {
     return undefined;
 }
 /**
- * The run-level subject for the top level and the bundle. Local-tree lanes all pack from the same
- * once-per-run archive, so every lane already carries the identical archiveSha256/commit/dirty and
- * the first lane's projection is the aggregate. Clone lanes each resolve their own commit; the
- * aggregate carries it only when every lane agrees, and warns when they diverge.
+ * The run-level subject for the top level and the bundle. Local-tree participants all pack from the
+ * same once-per-run archive, so every participant already carries the identical archiveSha256/commit/dirty and
+ * the first participant's projection is the aggregate. Clone participants each resolve their own
+ * commit; the aggregate carries it only when every participant agrees, and warns when they diverge.
  */
 export function aggregateCuaSubject(args) {
     const { subjects, outcomes, participantCount, dryRun } = args;