@open-agent-toolkit/cli 0.2.71 → 0.2.73

package/assets/skills/subagent-orchestration/SKILL.md

@@ -4,7 +4,7 @@ description: Use when delegating work to subagents or choosing a model for a tas
 compatibility: Self-contained; no OAT installation required.
 user-invocable: true
 metadata:
-  version: 1.0.3
+  version: 1.0.4
 ---
 
 # Subagent Orchestration
@@ -49,13 +49,13 @@ Classify in order: deterministic verifiability, silent-miss risk,
 dispersed-context reconciliation, ambiguity or novelty, then consequence.
 File count and duration alone never justify escalation.
 
-| Task class               | Contract                                                                                                                               |
-| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
-| `mechanical-recon`       | Deterministic inventories, parity checks, enumeration, lint/test/build runs. Misses are visible. Optimize for cost and throughput.     |
-| `intelligent-recon`      | Interpreting unfamiliar code, semantics, or policy; auditing API usage. A miss could be silent. Needs reliable judgment and tool use.  |
-| `default-implementation` | Normal multi-file coding, debugging, and reconciliation of dispersed context in one bounded scope.                                     |
-| `hard-reasoning`         | Ambiguous debugging, architecture analysis, novel problems, competing interpretations.                                                 |
-| `consequential`          | Security, release safety, incidents, irreversible operations, adversarial analysis, foundational decisions, final load-bearing review. |
+| Task class               | Contract                                                                                                                                                                   |
+| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mechanical-recon`       | Deterministic inventories, parity checks, bounded extraction/counterexample searches, and command runs whose misses are cheaply checked. Optimize for cost and throughput. |
+| `intelligent-recon`      | Interpreting unfamiliar code, semantics, or policy; auditing API usage. A miss could be silent. Needs reliable judgment and tool use.                                      |
+| `default-implementation` | Normal multi-file coding, debugging, and context-dependent implementation in one bounded scope.                                                                            |
+| `hard-reasoning`         | Ambiguous debugging, architecture analysis, novel problems, competing interpretations.                                                                                     |
+| `consequential`          | Security, release safety, incidents, irreversible operations, judgment-bearing adversarial analysis, foundational decisions, final load-bearing review.                    |
 
 Escalation boundaries:
 
@@ -66,7 +66,16 @@ Escalation boundaries:
 - Default → hard reasoning when ambiguity, novelty, or reasoning difficulty
   dominates. Large context alone is not a reason.
 - Any class → consequential when security, production impact,
-  irreversibility, adversarial behavior, or expensive failure dominates.
+  irreversibility, judgment-bearing adversarial analysis, or expensive failure
+  dominates.
+
+Recon wave names do not determine task class. Bounded citation reopening,
+inventory comparison, counterexample search, and mechanical dossier
+grouping/deduplication may remain `mechanical-recon` when their misses are
+visible and cheaply checked. Interpreting ambiguous evidence, deciding between
+competing explanations, or making a consequential final review remains at the
+class required by that judgment. Narrow an over-broad assignment before
+escalating it, and keep sufficiency judgment in the caller.
 
 **Never route below a class floor.** When uncertain between two classes, use
 the stronger one.

package/assets/skills/subagent-orchestration/references/model-selection-principles.md

@@ -37,13 +37,13 @@ Classify in this order: deterministic verifiability, silent-miss risk,
 dispersed-context reconciliation, ambiguity or novelty, then consequence.
 File count and duration alone never justify escalation.
 
-| Task class               | Qualification contract                                                                                                          |
-| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
-| `mechanical-recon`       | Deterministic inventories, parity checks, exact extraction, or command execution whose misses are visible and cheaply verified. |
-| `intelligent-recon`      | Interpretation of unfamiliar code, policy, semantics, or evidence where a plausible miss could survive mechanical validation.   |
-| `default-implementation` | Independently bounded implementation or dossier work that must retain and reconcile dispersed context.                          |
-| `hard-reasoning`         | Ambiguity, novelty, architecture, difficult diagnosis, or competing interpretations dominates.                                  |
-| `consequential`          | Security, release safety, irreversible effects, adversarial analysis, foundational decisions, or expensive failure dominates.   |
+| Task class               | Qualification contract                                                                                                                                           |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mechanical-recon`       | Deterministic inventories, parity checks, exact extraction, bounded counterexample searches, or command execution whose misses are visible and cheaply verified. |
+| `intelligent-recon`      | Interpretation of unfamiliar code, policy, semantics, or evidence where a plausible miss could survive mechanical validation.                                    |
+| `default-implementation` | Independently bounded implementation that must retain and reconcile dispersed context.                                                                           |
+| `hard-reasoning`         | Ambiguity, novelty, architecture, difficult diagnosis, or competing interpretations dominates.                                                                   |
+| `consequential`          | Security, release safety, irreversible effects, judgment-bearing adversarial analysis, foundational decisions, or expensive failure dominates.                   |
 
 When uncertain, use the stronger class. Never select below a supplied floor.
 
@@ -78,13 +78,22 @@ single entry cannot express a choice, only a default.
 - Default implementation to hard reasoning when ambiguity, novelty, or
   reasoning difficulty dominates.
 - Any class to consequential when security, production impact, irreversibility,
-  adversarial behavior, or expensive failure dominates.
+  judgment-bearing adversarial analysis, or expensive failure dominates.
 
 Narrow a poorly decomposed task before escalating its model. Model capability
 never repairs an over-broad objective. A consequential classification does not
 by itself justify top effort; raise effort only when deeper reasoning is also a
 bottleneck.
 
+For reconnaissance, classify the concrete assignment rather than the wave
+name. Reopening named citations, comparing an explicit inventory, seeking
+counterexamples to a specified claim, and mechanically grouping or
+deduplicating dossiers can remain `mechanical-recon`. A worker that must infer
+what counts as a material finding, reconcile ambiguous explanations, or issue a
+security or final-review judgment needs the corresponding stronger class. Cheap
+evidence acquisition never transfers sufficiency or conclusion ownership away
+from the caller.
+
 ## Eligibility
 
 Eliminate ineligible routes before ranking capability, cost, or speed. Verify:

package/dist/commands/sync/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAiB3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAgVtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAsMf"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAoB3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AA6XtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAyMf"}

package/dist/commands/sync/apply.js

@@ -1,3 +1,4 @@
+import { hasMaterializationChanges, } from '../../providers/shared/materialization-extension.js';
 import { getProviderRegistrations, } from '../../providers/shared/registry.js';
 import { adviseProviderRefresh, } from '../../providers/shared/restart-adviser.js';
 import { buildCollectionLifecycle, countPlannedOperations, formatCollectionLifecycle, toSyncOutputPlan, } from './sync.utils.js';
@@ -96,6 +97,47 @@ function normalizeOperationResults(plan, result) {
         };
     });
 }
+/**
+ * Records the outcome of the extension plans the apply step will not run.
+ *
+ * A plan whose operations are all skips is never applied — there is nothing to
+ * write — and a scope with no work at all is skipped whole before the extension
+ * loop is reached, so neither path populates `operationResults`. The report and
+ * the JSON payload still describe every planned operation, so an unrecorded
+ * skip rendered as `result: unknown` while the identical skip rendered as
+ * `current` whenever some sibling operation happened to make the apply step run.
+ *
+ * Both extension implementations record a skip as `status: 'current'` without
+ * touching the filesystem, so that is what is reproduced here: same statuses,
+ * same per-extension counts, one answer for a skip regardless of which path
+ * produced it. Recording the results here rather than defaulting the renderer
+ * keeps the `--json` payload consistent too, since its consumers read
+ * `materializationExtensions[].operationResults` and the sibling counts
+ * directly.
+ */
+function recordUnappliedExtensionSkips(scopePlan) {
+    for (const plan of scopePlan.materializationExtensionPlans) {
+        if (hasMaterializationChanges(plan)) {
+            continue;
+        }
+        const summary = scopePlan.materializationExtensions.find((candidate) => candidate.provider === plan.provider);
+        if (!summary) {
+            continue;
+        }
+        const operationResults = plan.operations.map((operation) => ({
+            provider: operation.provider,
+            target: operation.target,
+            path: operation.path,
+            entryName: operation.entryName,
+            action: operation.action,
+            status: 'current',
+        }));
+        summary.applied = 0;
+        summary.failed = 0;
+        summary.skipped = operationResults.length;
+        summary.operationResults = operationResults;
+    }
+}
 function materializationOperationIdentity(operation) {
     return JSON.stringify([
         operation.provider,
@@ -227,6 +269,9 @@ export async function runSyncApply(context, scopePlans, dependencies) {
     const coreApplyEvidence = [];
     const extensionOperationResults = [];
     for (const scopePlan of scopePlans) {
+        // Runs before the two `continue`s below, both of which can leave an
+        // all-skip extension plan unapplied and therefore unreported.
+        recordUnappliedExtensionSkips(scopePlan);
         const hasSyncEntries = scopePlan.plan.entries.length > 0 ||
             scopePlan.plan.removals.length > 0 ||
             (scopePlan.plan.collections?.length ?? 0) > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.2.71",
+  "version": "0.2.73",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -34,7 +34,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.2.71"
+    "@open-agent-toolkit/control-plane": "0.2.73"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",