dsh-task-time-cost 0.2.8-beta.2 → 0.2.9-beta.1

package/lib/index.js

@@ -19948,7 +19948,18 @@ function estimateWorkload(input2, route, options = {}) {
   let output2 = { ...template.visibleOutputTokens };
   let tool = { ...template.toolMs };
   const reasons = [...classification.reasons, "serial-conservative-dependencies", "cache-ratio-unknown", "reasoning-budget-unknown"];
-  if (history) {
+  const observations = (options.observations ?? []).filter((sample) => Number.isSafeInteger(sample.requestCount) && sample.requestCount >= 1 && Number.isSafeInteger(sample.visibleOutputTokens) && sample.visibleOutputTokens >= 0 && Number.isFinite(sample.toolMs) && sample.toolMs >= 0).slice(-config2.maxSamplesPerBucket);
+  const empirical = observations.length >= config2.minConditionalSamples;
+  if (empirical) {
+    const range = (key) => {
+      const values = observations.map((sample) => sample[key]).sort((a, b) => a - b);
+      return { low: values[Math.floor((values.length - 1) * 0.2)], high: values[Math.ceil((values.length - 1) * 0.8)] };
+    };
+    count3 = range("requestCount");
+    output2 = range("visibleOutputTokens");
+    tool = range("toolMs");
+    reasons.push("local-workload-distribution");
+  } else if (history) {
     for (const key of ["requestCount", "visibleOutputTokens", "toolMs", "samples"]) nonnegative(history[key], key);
     count3 = scaleRange(count3, history.requestCount);
     count3 = { low: Math.max(1, Math.floor(count3.low)), high: Math.max(1, Math.ceil(count3.high)) };
@@ -19979,15 +19990,15 @@ function estimateWorkload(input2, route, options = {}) {
     output2 = { low: Math.max(output2.low, length.low * artifacts), high: Math.max(output2.high, length.high * artifacts * overhead) };
     reasons.push(input2.explicitOutputTokens ? "explicit-output-token-budget" : "requested-length-token-conversion:heuristic");
   }
-  const origin = history ? template.sourceKind === "local-measured" ? "local-measured" : "mixed" : template.sourceKind;
+  const origin = empirical ? "local-measured" : history ? template.sourceKind === "local-measured" ? "local-measured" : "mixed" : template.sourceKind;
   return {
     kind: classification.kind,
     low: buildScenario(count3.low, output2.low, tool.low, input2.currentInputTokens, route, classification.kind, template.sourceKind, config2, false, length ? length.low * artifacts : null),
     high: buildScenario(count3.high, output2.high, tool.high, input2.currentInputTokens, route, classification.kind, template.sourceKind, config2, true, length ? length.high * artifacts : null),
     origin,
     reasons,
-    workloadSamples: history?.samples ?? 0,
-    sourceIds: [template.sourceId ?? `engineering-${template.kind}-v1`, ...history ? [`local-workload:${history.kind}:${history.samples}`] : []]
+    workloadSamples: empirical ? observations.length : history?.samples ?? 0,
+    sourceIds: empirical ? [`local-workload-distribution:${classification.kind}:${observations.length}`] : [template.sourceId ?? `engineering-${template.kind}-v1`, ...history ? [`local-workload:${history.kind}:${history.samples}`] : []]
   };
 }
 function outputLengthFromPrompt(prompt) {
@@ -20232,7 +20243,7 @@ function csvBaselines(text) {
 }
 
 // src/shared/wire.ts
-var ALGORITHM_VERSION = "p0-0.2.4";
+var ALGORITHM_VERSION = "p0-0.2.9";
 var PACKAGE_NAME = "dsh-task-time-cost";
 
 // src/shared/remote-contract.ts
@@ -22200,10 +22211,14 @@ var EstimatorEngine = class {
     const firstCall = task.calls[0];
     const input2 = this.initialInput.get(key) ?? (firstCall ? this.normalize(firstCall).promptTokens : null);
     const requestMode = task.calls.findLast((call) => call.mode !== "unknown" && (!task.route || call.route.providerId === task.route.providerId && call.route.modelId === task.route.modelId && call.route.reasoningEffort === task.route.reasoningEffort))?.mode ?? "unknown";
-    const signature2 = JSON.stringify([task.taskType, task.explicitOutputWords, task.attachmentCount, task.route, requestMode, input2, task.aiPlan]);
+    const route = this.route(task.route, requestMode);
+    const comparable = task.aiPlan ? [] : [...this.repository.tasks.values()].filter((record2) => {
+      const past = record2.current, p = past.performance;
+      return record2.id !== key && record2.learned?.eligible && past.state === "completed" && past.endedAt !== null && past.endedAt <= task.startedAt && record2.savedAt > this.repository.resetAt && task.startedAt - past.endedAt <= this.config.historyRetentionDays * 864e5 && past.taskType === task.taskType && p?.providerId === route.providerId && p.modelId === route.modelId && p.endpointFingerprint === route.endpointFingerprint && p.reasoningEffort === route.reasoningEffort && p.serviceTier === route.serviceTier;
+    }).sort((a, b) => a.current.endedAt - b.current.endedAt).slice(-this.config.maxSamplesPerBucket);
+    const signature2 = JSON.stringify([task.taskType, task.explicitOutputWords, task.attachmentCount, task.route, requestMode, input2, task.aiPlan, comparable.map((record2) => record2.id)]);
     const previous = this.plans.get(key);
     if (previous?.signature === signature2) return structuredClone(previous.plan);
-    const route = this.route(task.route, requestMode);
     const templates = this.templates(route);
     let plan = estimateWorkload(
       {
@@ -22213,7 +22228,13 @@ var EstimatorEngine = class {
         ...task.explicitOutputWords ? { explicitOutputTokens: { low: task.explicitOutputWords, high: task.explicitOutputWords * 2 } } : {}
       },
       route,
-      { config: this.engineConfig(), templates, history: [...this.workloadHistory.values()], rules: [{ id: "durable-classification", kind: task.taskType, patterns: [".*"] }] }
+      {
+        config: this.engineConfig(),
+        templates,
+        history: [...this.workloadHistory.values()],
+        observations: comparable.map((record2) => ({ requestCount: record2.learned.calls, visibleOutputTokens: record2.learned.visibleOutputTokens, toolMs: record2.learned.toolWorkMs })),
+        rules: [{ id: "durable-classification", kind: task.taskType, patterns: [".*"] }]
+      }
     );
     if (task.aiPlan) plan = applyAiPlan(plan, task.aiPlan, route, this.currentInput.get(key) ?? input2, this.engineConfig());
     this.plans.set(key, { signature: signature2, plan });
@@ -22369,7 +22390,10 @@ var EstimatorEngine = class {
       const low = sumKnown(lows), high = sumKnown(highs);
       return low === null || high === null ? null : { low, high };
     });
-    const outputScenarios = [plan.low, plan.high].map((scenario) => scenario.requests.filter((request) => !completedIds.includes(request.id)).reduce((sum, request) => ({ low: sum.low + request.visibleOutputTokens.low, high: sum.high + request.visibleOutputTokens.high }), { low: 0, high: 0 }));
+    const outputScenarios = [plan.low, plan.high].map((scenario) => scenario.requests.filter((request) => !completedIds.includes(request.id)).reduce((sum, request) => {
+      const generated = progress[request.id]?.generatedTextTokens ?? 0;
+      return { low: sum.low + Math.max(0, request.visibleOutputTokens.low - generated), high: sum.high + Math.max(0, request.visibleOutputTokens.high - generated) };
+    }, { low: 0, high: 0 }));
     const estimatedRemainingOutputTokens = task.endedAt !== null ? { low: 0, high: 0 } : errors || planExhausted ? null : { low: Math.min(...outputScenarios.map((value) => value.low)), high: Math.max(...outputScenarios.map((value) => value.high)) };
     const estimatedTokens = tokenScenarios.every((span3) => span3 !== null) ? { low: Math.max(totalTokens ?? 0, Math.min(...tokenScenarios.map((span3) => span3.low))), high: Math.max(totalTokens ?? 0, ...tokenScenarios.map((span3) => span3.high)) } : null;
     const initial = saved?.current.initial ?? (task.endedAt === null && task.promptChars > 0 && this.startedHere.has(key) ? { estimatedTotalMs: remaining ? { low: elapsedActive + remaining.low, high: elapsedActive + remaining.high } : null, estimatedTotalCost: totalCost } : null);
@@ -22910,7 +22934,7 @@ async function apply(ctx, rawConfig) {
     name: "task_estimate_plan",
     description: "Update the current task ETA from your assessment of the work still needed. Submit after understanding a multi-step task, and revise when its scope or remaining work materially changes. The Host combines the plan with this route\u2019s observed response times. These are reference estimates, not completion promises.",
     parameters: { type: "object", properties: {
-      remainingCalls: { type: "object", description: "Future model requests after this reporting call, including final answer and verification; ordered integer bounds, 1\u2013500.", properties: { low: { type: "integer", minimum: 1, maximum: 500 }, high: { type: "integer", minimum: 1, maximum: 500 } }, required: ["low", "high"], additionalProperties: false },
+      remainingCalls: { type: "object", description: "Future model response rounds after this reporting call, including final answer and verification; 1\u2013500. Count one response containing many tool calls as ONE model request, not one per tool or file. Reuse the observed work pattern to bound remaining rounds.", properties: { low: { type: "integer", minimum: 1, maximum: 500 }, high: { type: "integer", minimum: 1, maximum: 500 } }, required: ["low", "high"], additionalProperties: false },
       remainingOutputTokens: { type: "object", description: "Total future visible text/tool-argument tokens, excluding hidden reasoning; ordered bounds, 0\u20132000000.", properties: { low: { type: "integer", minimum: 0, maximum: 2e6 }, high: { type: "integer", minimum: 0, maximum: 2e6 } }, required: ["low", "high"], additionalProperties: false },
       remainingToolSeconds: { type: "object", description: "Future tool execution time, excluding model requests and human waits; ordered bounds, 0\u201386400 seconds.", properties: { low: { type: "integer", minimum: 0, maximum: 86400 }, high: { type: "integer", minimum: 0, maximum: 86400 } }, required: ["low", "high"], additionalProperties: false },
       stage: { type: "string", enum: ["planning", "implementation", "verification", "finishing"] }
@@ -22926,7 +22950,7 @@ async function apply(ctx, rawConfig) {
   ctx.systemPrompt.section({
     name: "task-estimate-planning",
     order: 1e3,
-    text: "For a multi-step user task, submit a task_estimate_plan after understanding the scope, preferably alongside your initial work tools. Include implementation, verification and delivery. Revise it only when scope or remaining work materially changes or the budget is exceeded. Count work remaining after the reporting call. Use task_estimator snapshot route timings when useful; never invent measured performance or treat call count as percentage complete. Skip planning for trivial answers. This uses the executing agent; do not start another model request just to estimate or poll."
+    text: "For a multi-step user task, submit a task_estimate_plan after understanding the scope, preferably alongside your initial work tools. Include implementation, verification and delivery. Revise it only when scope or remaining work materially changes or the budget is exceeded. Count work remaining after the reporting call. Count model response rounds, not individual tools, files, commands or parallel calls; one model response can contain many tools. Estimate tool wall time on the critical path, not the sum of parallel execution times. Prefer concrete bounds for the known scope and revise when evidence changes; do not add speculative optional work. Use task_estimator snapshot route timings when useful; never invent measured performance or treat call count as percentage complete. Skip planning for trivial answers. This uses the executing agent; do not start another model request just to estimate or poll."
   });
   for (const agent of ctx.agents.list()) safe(agent, () => {
     projection.stateOf(agent.session);