dorfl 0.8.0 → 0.10.0

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,OAAO,EAAS,MAAM,WAAW,CAAC;AAmH1C,OAAO,EAAiB,KAAK,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAwCvE,OAAO,EAAgB,KAAK,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AA2xB5E;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,OAAO,GACb,MAAM,CAoCR;AA6RD,wBAAgB,YAAY,IAAI,OAAO,CA04GtC;AAaD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,OAAO,GACZ,MAAM,CAyBR;AA+FD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBzE"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,OAAO,EAAS,MAAM,WAAW,CAAC;AAmH1C,OAAO,EAAiB,KAAK,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAwCvE,OAAO,EAAgB,KAAK,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AA+xB5E;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,OAAO,GACb,MAAM,CAoCR;AA6RD,wBAAgB,YAAY,IAAI,OAAO,CAq7GtC;AAaD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,OAAO,GACZ,MAAM,CAyBR;AA+FD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBzE"}

package/dist/cli.js

@@ -256,11 +256,13 @@ function buildRegistrySetAdvanceTick(options) {
                 // The per-TRANSITION TASKING override: the `do spec:` tasking path threads
                 // `taskingIntegration ?? integration`; the build path stays on `integration`.
                 taskingIntegration: config.taskingIntegration,
-                // The TASK-PLACEMENT configured default (`do spec:` tasking output:
+                // The TASK-PLACEMENT configured defaults (`do spec:` tasking output:
                 // `backlog` staged vs `ready` pool). No operator flag on this
-                // registry-driven advance context, so only the configured default rung is
-                // threaded (the resolver still layers untrusted-origin force + built-in floor).
+                // registry-driven advance context, so only the configured default rungs
+                // are threaded (trusted + the untrusted twin the tasker selects from the
+                // spec's stamp; the resolver layers the built-in floor).
                 tasksLandIn: config.tasksLandIn,
+                untrustedTasksLandIn: config.untrustedTasksLandIn,
                 prepare: config.prepare,
                 verify: config.verify,
                 // Single-job build path: gate the REBASED tip (the default) unconditionally.
@@ -449,8 +451,8 @@ function explicitSpecsLandInFromFlag(raw, flagName = '--specs-land-in') {
     if (raw === undefined) {
         return undefined;
     }
-    if (raw !== 'pre-proposed' && raw !== 'ready') {
-        throw new Error(`${flagName} must be 'pre-proposed' or 'ready' (got '${raw}').`);
+    if (raw !== 'proposed' && raw !== 'ready') {
+        throw new Error(`${flagName} must be 'proposed' or 'ready' (got '${raw}').`);
     }
     return raw;
 }
@@ -1629,10 +1631,12 @@ export function buildProgram() {
                 explicitMerge: flagMode === 'merge',
                 // Per-TRANSITION TASKING override (the `do --remote spec:` tasking path).
                 taskingIntegration: remoteConfig.taskingIntegration,
-                // TASK-PLACEMENT: the configured default + the EXPLICIT operator override
-                // (`--tasks-land-in`), the top of the placement precedence — mirrors
-                // `explicitMerge` (set only when the flag was typed).
+                // TASK-PLACEMENT: the configured defaults (trusted + the untrusted twin
+                // the tasker selects from the spec's stamp) + the EXPLICIT operator
+                // override (`--tasks-land-in`), the top of the placement precedence —
+                // mirrors `explicitMerge` (set only when the flag was typed).
                 tasksLandIn: remoteConfig.tasksLandIn,
+                untrustedTasksLandIn: remoteConfig.untrustedTasksLandIn,
                 explicitTasksLandIn: explicitTasksLandInFromFlag(flags.tasksLandIn),
                 prepare: remoteConfig.prepare,
                 verify: remoteConfig.verify,
@@ -1795,12 +1799,13 @@ export function buildProgram() {
             // `taskingIntegration ?? integration`; the task-build path stays on
             // `integration`. Unset ⇒ tasking falls back to `integration` (today's behaviour).
             taskingIntegration: config.taskingIntegration,
-            // TASK-PLACEMENT (`do spec:` tasking output): the configured default rung +
+            // TASK-PLACEMENT (`do spec:` tasking output): the configured default rungs
+            // (trusted + the untrusted twin the tasker selects from the spec's stamp) +
             // the EXPLICIT operator override `--tasks-land-in` (top of the precedence).
             // `explicitTasksLandIn` is set ONLY when the flag was typed (mirrors
-            // `explicitMerge`), so an untrusted-origin staging force still wins under a
-            // config default.
+            // `explicitMerge`).
             tasksLandIn: config.tasksLandIn,
+            untrustedTasksLandIn: config.untrustedTasksLandIn,
             explicitTasksLandIn: explicitTasksLandInFromFlag(flags.tasksLandIn),
             // In-place divergence guard override (mirrors --ignore-not-ready).
             ignoreDivergedMain: flags.ignoreDivergedMain === true,
@@ -2062,9 +2067,10 @@ export function buildProgram() {
                 explicitMerge: flagMode === 'merge',
                 // Per-TRANSITION TASKING override (the isolated `do --remote spec:` path).
                 taskingIntegration: remoteConfig.taskingIntegration,
-                // TASK-PLACEMENT: configured default + EXPLICIT `--tasks-land-in` override
-                // (set only when typed, mirroring `explicitMerge`).
+                // TASK-PLACEMENT: configured defaults (trusted + untrusted twin) + EXPLICIT
+                // `--tasks-land-in` override (set only when typed, mirroring `explicitMerge`).
                 tasksLandIn: remoteConfig.tasksLandIn,
+                untrustedTasksLandIn: remoteConfig.untrustedTasksLandIn,
                 explicitTasksLandIn: explicitTasksLandInFromFlag(flags.tasksLandIn),
                 prepare: remoteConfig.prepare,
                 verify: remoteConfig.verify,
@@ -2201,9 +2207,10 @@ export function buildProgram() {
             // Per-TRANSITION TASKING override (the `do spec:` tasking path threads
             // `taskingIntegration ?? integration`; the build path stays on `integration`).
             taskingIntegration: config.taskingIntegration,
-            // TASK-PLACEMENT: configured default + EXPLICIT `--tasks-land-in` override
-            // (set only when typed, mirroring `explicitMerge`).
+            // TASK-PLACEMENT: configured defaults (trusted + untrusted twin) + EXPLICIT
+            // `--tasks-land-in` override (set only when typed, mirroring `explicitMerge`).
             tasksLandIn: config.tasksLandIn,
+            untrustedTasksLandIn: config.untrustedTasksLandIn,
             explicitTasksLandIn: explicitTasksLandInFromFlag(flags.tasksLandIn),
             prepare: config.prepare,
             verify: config.verify,
@@ -2995,7 +3002,8 @@ export function buildProgram() {
         .option('--merge-task', 'integrate a task outcome in merge mode (granular; overrides --merge/--propose for a task; mutually exclusive with --propose-task)')
         .option('--propose-task', 'integrate a task outcome in propose mode (granular; overrides --merge/--propose for a task; mutually exclusive with --merge-task)')
         .option('--origin-trust <trusted|untrusted>', "the author-trust verdict to STAMP onto the emitted spec/task (origin: issue + originTrust: <value>), so an untrusted origin survives the merge boundary and later forces the task's BUILD transition to propose. CI's intake.yml derives it from the SAME author_association case as the integration flags. UNSET (a local intake) ⇒ emitted unstamped (human/trusted) — the human running intake IS the checkpoint.")
-        .option('--specs-land-in <where>', 'where an intake-authored spec lands: `pre-proposed` (staged, not auto-taskable) or `ready` (the auto-tasking pool). The EXPLICIT operator override at the top of the placement precedence (explicit flag > untrusted-origin forces staging > specsLandIn default > built-in). Resolved flag > env (DORFL_SPECS_LAND_IN) > per-repo > global > built-in.')
+        .option('--specs-land-in <where>', 'where an intake-authored spec lands: `proposed` (staged, not auto-taskable) or `ready` (the auto-tasking pool). The EXPLICIT operator override at the top of the placement precedence (explicit flag > untrusted-origin forces staging > specsLandIn default > built-in). Resolved flag > env (DORFL_SPECS_LAND_IN) > per-repo > global > built-in.')
+        .option('--tasks-land-in <where>', 'where an intake-authored TASK (emitted DIRECTLY from an issue) lands: `backlog` (staged, not agent-eligible) or `ready` (the agent POOL). The task twin of --specs-land-in: the EXPLICIT operator override at the top of the placement precedence (explicit flag > configured default > built-in staging; the caller selects the trusted-vs-untrusted default from the origin-trust stamp). Resolved flag > env (DORFL_TASKS_LAND_IN) > per-repo > global > built-in.')
         .option('--agent-cmd <cmd>', 'command to run the decision agent')
         .option('--model <id>', 'model the decision agent runs on (routing intent; resolved flag > env > per-repo > global > default)')
         .option('--harness <adapter>', 'harness adapter that launches the decision agent: null (default) or pi')
@@ -3028,14 +3036,18 @@ export function buildProgram() {
         // Resolve the PER-OUTCOME integration modes (spec US #9): `intake` decides
         // the artifact TYPE at runtime, so a single --merge/--propose can't express
         // a type-conditional policy. The granular flags override the aggregate; an
-        // UNSET type falls back to the per-repo/global `integration` (the SAME chain
-        // `do`/`complete` use — flag > per-repo > global > default propose). `intake`
-        // is GATE-FREE, so autoTask/autoBuild are NOT consulted (the explicit
-        // invocation is its own authorization). `intake` owns only these KNOBS; WHICH
-        // knobs CI sets is CI's POLICY (`runner-in-ci`), NOT here.
+        // UNSET type falls back to the per-repo/global `intakeIntegration ??
+        // integration` (the INTAKE-DOCUMENT knob, twin of the tasking path's
+        // `taskingIntegration ?? integration`; spec
+        // `intake-integration-knob-and-specs-land-in-proposed-rename`). DECOUPLED
+        // from the autonomy gates: `intake` is GATE-FREE, so autoTask/autoBuild are
+        // NOT consulted for the document mode (the explicit invocation is its own
+        // authorization; ADR untrusted-origin-carries-via-stamp-not-forced-staging).
+        // `intake` owns only these KNOBS; WHICH knobs CI sets is CI's POLICY
+        // (`runner-in-ci`), NOT here.
         let modes;
         try {
-            modes = resolveIntakeIntegrationModes(flags, config.integration);
+            modes = resolveIntakeIntegrationModes(flags, config.intakeIntegration ?? config.integration);
         }
         catch (err) {
             console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
@@ -3071,6 +3083,18 @@ export function buildProgram() {
             console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
+        // The OPERATOR's EXPLICIT task-placement override (`--tasks-land-in`), the
+        // TOP of the placement precedence for a DIRECT-from-issue task emit — the
+        // task twin of `explicitSpecsLandIn` above (reuses the same `do`-path
+        // helper). Fails loudly on a bad value.
+        let explicitTasksLandIn;
+        try {
+            explicitTasksLandIn = explicitTasksLandInFromFlag(flags.tasksLandIn);
+        }
+        catch (err) {
+            console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
         const result = await performIntake({
             issueNumber,
             cwd,
@@ -3086,11 +3110,25 @@ export function buildProgram() {
             // The origin-trust stamp the CI shell passes IN (unset ⇒ unstamped).
             originTrust,
             noPR: config.noPR,
-            // SPEC-PLACEMENT: the configured-default `specsLandIn` rung + the EXPLICIT
-            // `--specs-land-in` override (top of the precedence). The shared placement
-            // resolver in `intake.ts` overlays the untrusted-origin staging force.
+            // SPEC-PLACEMENT: the TRUSTED-side configured default (`specsLandIn`) +
+            // the UNTRUSTED-side twin (`untrustedSpecsLandIn`, selected in
+            // `dispatchSpec` when the stamp is untrusted) + the EXPLICIT
+            // `--specs-land-in` override (top of the precedence). The placement
+            // resolver no longer has an untrusted-forces-staging rung (ADR
+            // `untrusted-origin-carries-via-stamp-not-forced-staging`); the caller
+            // selects the trusted-vs-untrusted default from the stamp.
             specsLandIn: config.specsLandIn,
+            untrustedSpecsLandIn: config.untrustedSpecsLandIn,
             explicitSpecsLandIn,
+            // TASK-PLACEMENT (parity with the spec-placement block above; ADR
+            // `untrusted-origin-carries-via-stamp-not-forced-staging`): the
+            // TRUSTED-side default (`tasksLandIn`) + the UNTRUSTED-side twin
+            // (`untrustedTasksLandIn`, selected in `dispatchTask` when the stamp is
+            // untrusted) + the EXPLICIT `--tasks-land-in` override. Replaces the old
+            // hardcoded `tasks-ready` path; the resolver picks backlog vs ready.
+            tasksLandIn: config.tasksLandIn,
+            untrustedTasksLandIn: config.untrustedTasksLandIn,
+            explicitTasksLandIn,
             harness,
             agentCmd: config.agentCmd,
             model: config.model,