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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-task-time-cost",
-  "version": "0.2.8-beta.2",
+  "version": "0.2.9-beta.1",
   "type": "module",
   "description": "Remaining-time, Token budget and reference cost estimates for DeepSeek Harness, calibrated locally without a separate model call.",
   "license": "MIT",

package/src/client/details.tsx

@@ -9,7 +9,7 @@ function Facts({ rows }: { rows: ReadonlyArray<readonly [string, React.ReactNode
 
 const reasonKeys: Record<string, MessageKey> = {
   'engineering-assumption': 'reasonHeuristic', 'engineering-workload-template': 'reasonWorkloadTemplate',
-  'local-workload-ewma': 'reasonLocalWorkload', 'public-endpoint-reference': 'reasonPublicEndpoint',
+  'local-workload-ewma': 'reasonLocalWorkload', 'local-workload-distribution': 'reasonWorkloadDistribution', 'public-endpoint-reference': 'reasonPublicEndpoint',
   'reference-range-not-calibrated-confidence': 'reasonReferenceRange', 'conditional-samples-insufficient': 'reasonFewSamples',
   'reference-range-exhausted-reassessing': 'reasonReassessing', 'output-budget-exhausted-task-still-running': 'reasonBudgetExhausted',
   'waiting-for-model-response': 'reasonWaitingModel', 'mixed-route-upstream-unknown': 'reasonMixedRoute',

package/src/client/format.ts

@@ -73,6 +73,11 @@ function formatCoarse(ms: number, t: Translate): string {
   return rest === 0 ? t('durationHoursOnly', { value: hours }) : t('durationHours', { value: hours, minutes: rest });
 }
 
+/** Wide early references should not masquerade as a useful countdown. */
+export function isWideEta(range: Span | null | undefined): boolean {
+  return validSpan(range) && range.high - range.low >= 300_000 && range.high >= Math.max(60_000, range.low) * 4;
+}
+
 /** Compact ETA for the one-line display: coarse bounds, latin units, stable width. */
 export function formatEta(range: Span | null | undefined, t: Translate): string {
   if (!validSpan(range)) return t('unknown');
@@ -83,6 +88,20 @@ export function formatEta(range: Span | null | undefined, t: Translate): string
   return low === high ? low : t('range', { low, high });
 }
 
+/** Compact counts retain separate observed and forecast labels in the summary. */
+export function compactTokens(value: number | null | undefined, t: Translate): string {
+  if (value == null || !Number.isFinite(value) || value < 0) return t('unknown');
+  if (value < 1_000) return String(Math.round(value));
+  const divisor = value < 1_000_000 ? 1_000 : 1_000_000;
+  const scaled = value / divisor;
+  return `${scaled >= 100 ? Math.round(scaled) : Number(scaled.toFixed(1))}${divisor === 1_000 ? 'k' : 'M'}`;
+}
+export function compactTokenRange(range: Span | null | undefined, t: Translate): string {
+  if (!validSpan(range)) return t('unknown');
+  const low = compactTokens(range.low, t), high = compactTokens(range.high, t);
+  return low === high ? low : t('range', { low, high });
+}
+
 export function formatTokenRange(range: Span | null | undefined, locale: string, t: Translate): string {
   if (!validSpan(range)) return t('unknown');
   const low = formatNumber(range.low, locale, t);

package/src/client/index.tsx

@@ -2,9 +2,9 @@ import * as React from 'react';
 import { createPortal } from 'react-dom';
 import type { Context } from '@deepseek-ai/cordis';
 import type { ChatSnapshot, TurnTailChatData } from '@deepseek-ai/dsh-client-ui-chat/client';
-import type { EstimateSnapshot, EstimatorRemote } from '../shared/wire.ts';
+import type { EstimatorRemote } from '../shared/wire.ts';
 import { EstimateDetails } from './details.tsx';
-import { costSummary, costUnconfigured, formatDuration, formatEta, isTerminal, localTiming } from './format.ts';
+import { compactTokens, compactTokenRange, costSummary, costUnconfigured, formatDuration, formatEta, isTerminal, isWideEta, localTiming } from './format.ts';
 import { en, zh, LOCALE_NAMESPACE } from './locale.ts';
 import type { Translate } from './locale.ts';
 import { Management } from './management.tsx';
@@ -43,33 +43,6 @@ function readMarker(value: unknown): ProjectionMarker | null {
 }
 const idleSubscribe = () => () => {};
 
-/** Compact human token count, matching the host's own usage meta. */
-function compactTokens(value: number | null | undefined): string | null {
-  if (value == null || !Number.isFinite(value) || value < 0) return null;
-  if (value < 1_000) return String(Math.round(value));
-  if (value < 1_000_000) {
-    const scaled = value / 1_000;
-    return `${scaled >= 100 ? Math.round(scaled) : Number(scaled.toFixed(1))}k`;
-  }
-  const scaled = value / 1_000_000;
-  return `${scaled >= 100 ? Math.round(scaled) : Number(scaled.toFixed(1))}M`;
-}
-
-/**
- * The bare count, for places whose own label already says "tokens": a row
- * reading `Observed tokens  46.2M tokens` repeats the unit the label supplied.
- */
-function tokenValue(snapshot: EstimateSnapshot | null, _locale: string, t: Translate): string {
-  if (!snapshot) return t('unknown');
-  const observed = compactTokens(snapshot.observedTokens);
-  if (observed) return observed;
-  const estimate = snapshot.estimatedTotalTokens;
-  if (!estimate) return t('unknown');
-  const low = compactTokens(estimate.low) ?? t('unknown');
-  const high = compactTokens(estimate.high) ?? t('unknown');
-  return low === high ? low : t('range', { low, high });
-}
-
   /**
    * Small clock that carries the task state by colour instead of by text: the
    * line itself must stay a single short ETA, so a dot plus a word would repeat
@@ -118,7 +91,7 @@ export function applyClient(ctx: Context): void {
     const frozenNow = React.useCallback(() => state.receivedAt, [state.receivedAt]);
     const now = React.useSyncExternalStore(ticking ? store.clock.subscribe : idleSubscribe, ticking ? store.clock.getSnapshot : frozenNow, frozenNow);
     const [expanded, setExpanded] = React.useState(false);
-    const [view, setView] = React.useState<'summary' | 'details' | 'settings'>('summary');
+    const [view, setView] = React.useState<'summary' | 'more' | 'details' | 'settings'>('summary');
     const summary = React.useRef<HTMLButtonElement>(null);
     const panel = React.useRef<HTMLDivElement>(null);
     const firstAction = React.useRef<HTMLButtonElement>(null);
@@ -140,12 +113,14 @@ export function applyClient(ctx: Context): void {
         if (event.key !== 'Escape') return;
         event.preventDefault();
         setExpanded(false);
+        setView('summary');
         summary.current?.focus();
       };
       const onOutside = (event: Event) => {
         const target = event.target as Node | null;
         if (!target || summary.current?.contains(target) || panel.current?.contains(target)) return;
         setExpanded(false);
+        setView('summary');
       };
       document.addEventListener('keydown', onKeyDown);
       document.addEventListener('pointerdown', onOutside, true);
@@ -162,16 +137,18 @@ export function applyClient(ctx: Context): void {
     const elapsed = formatDuration(timing?.activeMs ?? snapshot?.elapsedActiveMs, t);
     const retained = !tail && sessionRemaining === null && state.lastForecast
       && (!snapshot || state.lastForecast.taskKey === snapshot.taskKey) && (active || !snapshot && targetTurn !== null) ? state.lastForecast : null;
-    const eta = formatEta(sessionRemaining ?? retained?.remainingMs, t);
+    const displayedRemaining = sessionRemaining ?? retained?.remainingMs;
+    const wide = isWideEta(displayedRemaining);
+    const eta = formatEta(displayedRemaining, t);
     // Keep the last time reference while the new plan is unavailable. It is
     // frozen and labelled in the dialog, never used as a current cost budget.
-    const line = tail ? t('doneElapsed', { elapsed }) : (active && sessionRemaining !== null || retained) ? t('etaEstimate', { value: eta }) : t('titleShort');
+    const line = tail ? t('doneElapsed', { elapsed }) : (active && sessionRemaining !== null || retained) ? wide ? t('etaUncertain') : t('etaEstimate', { value: eta }) : t('titleShort');
     const unconfigured = !!snapshot && costUnconfigured(snapshot);
     const referencePrice = snapshot?.reasons.includes('public-reference-price-not-provider-bill') ?? false;
     return <div className="dte" data-slot={tail ? 'assistant-actions' : 'composer-dock'}>
       <style>{styles}</style>
       <button type="button" className={tail ? 'dte-line dte-line-tail' : 'dte-line'} aria-haspopup="dialog" aria-expanded={expanded} aria-controls={`${id}-panel`}
-        aria-label={line} onClick={() => setExpanded((value) => !value)} ref={summary}
+        aria-label={line} onClick={() => { setView('summary'); setExpanded((value) => !value); }} ref={summary}
         title={terminal ? line : snapshot || retained ? t('etaFull', { value: eta }) : t('title')}>
         <ClockIcon state={snapshot?.state ?? 'idle'} />
         <span className="dte-line-text">{line}</span>
@@ -182,22 +159,29 @@ export function applyClient(ctx: Context): void {
         <div className="dte-pop-head">
           <span className="dte-pop-title"><ClockIcon state={snapshot?.state ?? 'idle'} />{t(tail ? 'turnTimeTitle' : 'titleShort')}</span>
           <span className="dte-pop-value dte-tabular">{terminal ? elapsed : eta}</span>
+          <button type="button" ref={firstAction} className="dte-more" aria-label={t('more')} title={t('more')} aria-expanded={view !== 'summary'} aria-controls={`${id}-more`}
+            onClick={() => setView(view === 'summary' ? 'more' : 'summary')}>
+            <svg width="16" height="16" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><circle cx="3" cy="8" r="1.2" fill="currentColor" /><circle cx="8" cy="8" r="1.2" fill="currentColor" /><circle cx="13" cy="8" r="1.2" fill="currentColor" /></svg>
+          </button>
         </div>
         <div className="dte-pop-rule" aria-hidden="true" />
         <dl className="dte-summary">
           <dt>{t('activeTime')}</dt><dd>{snapshot ? elapsed : t('unknown')}</dd>
           <dt>{t('estimatedTotal')}</dt><dd>{formatEta(snapshot?.estimatedTotalMs ?? retained?.estimatedTotalMs, t)}</dd>
-          <dt>{t('tokenTotal')}</dt><dd>{tokenValue(snapshot, localeSnapshot.active, t)}</dd>
+          <dt>{t('tokenTotal')}</dt><dd>{snapshot?.observedTokenStatus === 'partial' ? t('partialKnown', { value: compactTokens(snapshot.observedTokens, t) }) : compactTokens(snapshot?.observedTokens, t)}</dd>
+          {!terminal && <><dt>{t('tokenRemainingOutput')}</dt><dd title={t('tokenRemainingNote')}>{compactTokenRange(snapshot?.estimatedRemainingOutputTokens, t)}</dd>
+            {snapshot?.estimatedTotalTokens != null && <><dt>{t('tokenForecast')}</dt><dd>{compactTokenRange(snapshot.estimatedTotalTokens, t)}</dd></>}</>}
           <dt>{t(referencePrice ? 'referenceCost' : 'knownCost')}</dt><dd>{unconfigured ? t('unpriced') : snapshot ? costSummary(snapshot, localeSnapshot.active, t) : t('unknown')}</dd>
         </dl>
+        {wide && !terminal && <p className="dte-muted dte-small">{t('wideEtaHint')}</p>}
         {retained && <p className="dte-muted dte-small">{t('retainedForecastHint', { time: new Date(retained.updatedAt).toLocaleString(localeSnapshot.active) })}</p>}
         {referencePrice && <p className="dte-muted dte-small">{t('referencePriceHint')}</p>}
         {unconfigured && <p className="dte-muted dte-small">{t('unpricedHint')}</p>}
         {!unconfigured && snapshot && (snapshot.observedCostStatus === 'partial' || snapshot.forecastCostStatus === 'partial') && <p className="dte-muted dte-small">{t('incompleteCostDetail')}</p>}
         {state.error && <p className="dte-error dte-small" role="alert">{errorText(state.error, t)}</p>}
-        <div className="dte-pop-actions">
-          <button type="button" ref={firstAction} className={view === 'details' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'details'} onClick={() => setView(view === 'details' ? 'summary' : 'details')}>{t('details')}</button>
-          <button type="button" className={view === 'settings' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'settings'} onClick={() => setView(view === 'settings' ? 'summary' : 'settings')}>{t('settings')}</button>
+        <div id={`${id}-more`} className="dte-pop-actions" hidden={view === 'summary'}>
+          <button type="button" className={view === 'details' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'details'} onClick={() => setView(view === 'details' ? 'more' : 'details')}>{t('details')}</button>
+          <button type="button" className={view === 'settings' ? 'dte-link dte-link-active' : 'dte-link'} aria-pressed={view === 'settings'} onClick={() => setView(view === 'settings' ? 'more' : 'settings')}>{t('settings')}</button>
           <span className="dte-spacer" />
           {view === 'details' && <button type="button" className="dte-link" disabled={state.pending} onClick={refresh}>{t('refresh')}</button>}
         </div>

package/src/client/locale.ts

@@ -9,6 +9,9 @@ export const en = {
   tokenRemainingNote: 'Visible output and tool arguments only; excludes hidden reasoning and repeated input.',
   reassessingShort: 'Reassessing',
   upTo: '≤{value}',
+  more: 'More estimate options',
+  etaUncertain: 'Refining estimate',
+  wideEtaHint: 'The task size is still uncertain. A work plan or comparable completed tasks will help narrow this range.',
   details: 'Estimate details',
   settings: 'Settings and calibration',
   close: 'Close',
@@ -208,6 +211,7 @@ export const en = {
   overdue: 'Estimate is being revised',
   reasonHeuristic: 'Uses engineering assumptions until local measurements are available.',
   reasonWorkloadTemplate: 'Workload comes from an engineering template.',
+  reasonWorkloadDistribution: 'Workload uses the central 20–80% of comparable completed local tasks, rather than retaining the template spread.',
   reasonLocalWorkload: 'Workload is smoothed from local completed tasks.',
   reasonPublicEndpoint: 'Public endpoint measurements are a reference for this route.',
   reasonReferenceRange: 'This is a reference range, not a calibrated confidence interval.',
@@ -259,6 +263,7 @@ export const zh: Record<MessageKey, string> = {
   title: '任务耗时与费用预估', titleShort: '耗时预估', turnTimeTitle: '本轮用时',
   retainedForecastHint: '正在更新，暂用 {time} 的预估参考。',
   tokenRemainingOutput: '预计剩余输出 Token', tokenRemainingNote: '包含可见输出和工具参数，不含隐藏推理与重复输入。',
+  more: '更多预估选项', etaUncertain: '预估待收敛', wideEtaHint: '任务规模尚不确定；工作计划或可比的已完成任务可帮助收窄此区间。',
   reassessingShort: '重新评估', upTo: '≤{value}', details: '预估详情', settings: '设置与校准', close: '关闭',
   refresh: '刷新', retry: '重试', loading: '正在加载…', updating: '正在更新…',
   unavailable: '暂时无法预估', noTask: '任务开始后显示预估。', noSnapshot: '本回合暂无预估。',
@@ -329,6 +334,7 @@ export const zh: Record<MessageKey, string> = {
   rawDetail: 'Host 详情：{message}', sourceDetail: '来源：{value}', unknownRemaining: '剩余时间未知',
   unknownTime: '暂时无法预估耗时', overdue: '正在修正预估',
   reasonHeuristic: '本地实测不足时使用工程假设。', reasonWorkloadTemplate: '工作量来自工程模板。',
+  reasonWorkloadDistribution: '工作量采用可比已完成本地任务的 20%–80% 实际分布，不再沿用模板宽幅。',
   reasonLocalWorkload: '工作量由本地已完成任务平滑更新。', reasonPublicEndpoint: '公开端点实测仅作为当前线路的参考。',
   reasonReferenceRange: '这是参考区间，并非经过校准的置信区间。', reasonFewSamples: '相似样本不足，无法给出条件剩余时间。',
   reasonAiPlan: '执行 AI 评估了剩余工作量，再结合当前路由性能换算耗时；这是参考预估，不是已测得的完成时间。',

package/src/client/styles.ts

@@ -76,7 +76,10 @@ export const styles = `
    body portal with the native gap/inset and a bounded internal scroll area. */
 .dte .dte-pop{position:fixed;inset:auto;z-index:1100;box-sizing:border-box;width:max-content;min-width:min(300px,calc(100vw - 24px));max-width:min(440px,calc(100vw - 24px));padding:16px;border:0;border-radius:var(--dsw-radius-lg);background:var(--dsw-specific-menu);backdrop-filter:var(--dsw-menu-backdrop-filter);--dsw-elevation-stroke-color:var(--dsw-alias-border-l1);box-shadow:var(--dsw-elevation-prominent);font-family:inherit;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);cursor:default;max-height:calc(100dvh - 12px - max(12px,var(--dsh-frame-overlay-top,12px)));overflow-x:hidden;overflow-y:auto;--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2);--dsh-scrollbar-thumb-hover:var(--dsw-alias-scrollbar-hover-l2);top:max(12px,var(--dsh-frame-overlay-top,12px));left:12px;height:auto;min-height:0;margin:0;overscroll-behavior:contain}
 .dte .dte-pop-head{display:flex;justify-content:space-between;gap:16px;margin-bottom:8px;color:var(--dsw-alias-label-primary);font-weight:500}
-.dte .dte-pop-title{display:inline-flex;align-items:center;gap:6px;min-width:0}
+.dte .dte-pop-title{display:inline-flex;align-items:center;gap:6px;min-width:0;flex:1}
+.dte .dte-pop-value{white-space:nowrap}
+.dte button.dte-more{display:inline-flex;align-items:center;justify-content:center;border:0;background:transparent;min-height:24px;width:24px;padding:2px;margin:-3px -4px -3px -8px;color:var(--dsw-alias-label-tertiary)}
+.dte .dte-pop-actions[hidden]{display:none}
 .dte .dte-pop-rule{margin-bottom:10px;border-top:.5px solid var(--dsw-alias-border-l2)}
 .dte .dte-summary{display:grid;grid-template-columns:minmax(76px,auto) minmax(0,1fr);gap:6px 16px;margin:0;color:var(--dsw-alias-label-tertiary)}
 .dte .dte-summary dt,.dte .dte-summary dd{min-width:0;margin:0}

package/src/host/engine.ts

@@ -202,14 +202,24 @@ export class EstimatorEngine {
     const input = 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 signature = JSON.stringify([task.taskType, task.explicitOutputWords, task.attachmentCount, task.route, requestMode, input, task.aiPlan]);
+    const route = this.route(task.route, requestMode);
+    const comparable = task.aiPlan ? [] : [...this.repository.tasks.values()].filter(record => {
+      const past = record.current, p = past.performance;
+      return record.id !== key && record.learned?.eligible && past.state === 'completed' && past.endedAt !== null
+        && past.endedAt <= task.startedAt && record.savedAt > this.repository.resetAt
+        && task.startedAt - past.endedAt <= this.config.historyRetentionDays * 86_400_000 && 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 signature = JSON.stringify([task.taskType, task.explicitOutputWords, task.attachmentCount, task.route, requestMode, input, task.aiPlan, comparable.map(record => record.id)]);
     const previous = this.plans.get(key);
     if (previous?.signature === signature) return structuredClone(previous.plan);
-    const route = this.route(task.route, requestMode);
     const templates = this.templates(route);
     let plan = estimateWorkload({ prompt: syntheticPrompts[task.taskType], currentInputTokens: input, fileCount: task.attachmentCount,
       ...(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(record => ({ requestCount: record.learned!.calls, visibleOutputTokens: record.learned!.visibleOutputTokens, toolMs: record.learned!.toolWorkMs })),
+      rules: [{ id: 'durable-classification', kind: task.taskType, patterns: ['.*'] }] });
     if (task.aiPlan) plan = applyAiPlan(plan, task.aiPlan, route, this.currentInput.get(key) ?? input, this.engineConfig());
     this.plans.set(key, { signature, plan });
     return structuredClone(plan);
@@ -388,7 +398,10 @@ export class EstimatorEngine {
       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 }));
+      .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((span): span is Span => span !== null)

package/src/host/index.ts

@@ -245,7 +245,7 @@ export async function apply(ctx: Context, rawConfig: unknown): Promise<void> {
     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’s 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–500.', 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–500. 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–2000000.', properties: { low: { type: 'integer', minimum: 0, maximum: 2000000 }, high: { type: 'integer', minimum: 0, maximum: 2000000 } }, required: ['low', 'high'], additionalProperties: false },
       remainingToolSeconds: { type: 'object', description: 'Future tool execution time, excluding model requests and human waits; ordered bounds, 0–86400 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'] },
@@ -259,7 +259,7 @@ export async function apply(ctx: Context, rawConfig: unknown): Promise<void> {
     },
   });
   ctx.systemPrompt.section({ name: 'task-estimate-planning', order: 1_000,
-    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.' });
   // Existing sessions are folded once on demand by the projection owner. No log rescans per frame.
   for (const agent of ctx.agents.list()) safe(agent, () => { projection.stateOf(agent.session); engine.runtime.task(agent.id, ctx.agents.turnBoundaryOf(agent.session).lastTurn); });
   ctx.effect(() => async () => {

package/src/shared/wire.ts

@@ -130,5 +130,5 @@ export interface EstimatorRemote {
   manage(action: ManagementAction, payload: string, signal?: AbortSignal): Promise<RemoteResult<ManagementResult>>;
 }
 export type RemoteResult<T> = { ok: true; value: T } | { ok: false; error: { message: string; code: string } };
-export const ALGORITHM_VERSION = 'p0-0.2.4';
+export const ALGORITHM_VERSION = 'p0-0.2.9';
 export const PACKAGE_NAME = 'dsh-task-time-cost';

package/src/shared/workload.ts

@@ -30,6 +30,7 @@ export interface RequestBudget {
 export interface ToolBudget { id: string; durationMs: Span; dependsOn: string[]; resource?: string; sourceKind: SourceKind }
 export interface PlanScenario { requests: RequestBudget[]; tools: ToolBudget[] }
 export interface WorkloadPlan { kind: TaskKind; low: PlanScenario; high: PlanScenario; origin: EstimateOrigin; reasons: string[]; workloadSamples: number; sourceIds: string[] }
+export interface WorkloadSample { requestCount: number; visibleOutputTokens: number; toolMs: number }
 export interface WorkloadHistory { kind: TaskKind; requestCount: number; visibleOutputTokens: number; toolMs: number; samples: number; lastObservedAtMs: number | null; sourceKind: 'local-measured' }
 export interface WorkloadObservation {
   kind: TaskKind;
@@ -146,7 +147,7 @@ export function classifyTask(input: TaskFeatures, rules: readonly Classification
   return { kind: 'unknown', reasons: ['no-classification-match', 'classification:heuristic'] };
 }
 
-export function estimateWorkload(input: TaskFeatures, route: RouteIdentity, options: { config?: Partial<EstimatorConfig>; templates?: readonly WorkloadTemplate[]; rules?: readonly ClassificationRule[]; history?: WorkloadHistory[] } = {}): WorkloadPlan {
+export function estimateWorkload(input: TaskFeatures, route: RouteIdentity, options: { config?: Partial<EstimatorConfig>; templates?: readonly WorkloadTemplate[]; rules?: readonly ClassificationRule[]; history?: WorkloadHistory[]; observations?: readonly WorkloadSample[] } = {}): WorkloadPlan {
   const config = validateConfig(options.config);
   const templates = options.templates ?? DEFAULT_TEMPLATES;
   validateTemplates(templates);
@@ -161,7 +162,19 @@ export function estimateWorkload(input: TaskFeatures, route: RouteIdentity, opti
   let output = { ...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(-config.maxSamplesPerBucket);
+  const empirical = observations.length >= config.minConditionalSamples;
+  if (empirical) {
+    // Recentring the original template never learns a narrower spread. Use the
+    // central observed distribution once comparable completed tasks support it.
+    const range = (key: keyof WorkloadSample): Span => {
+      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)]! };
+    };
+    count = range('requestCount'); output = range('visibleOutputTokens'); tool = range('toolMs');
+    reasons.push('local-workload-distribution');
+  } else if (history) {
     for (const key of ['requestCount', 'visibleOutputTokens', 'toolMs', 'samples'] as const) nonnegative(history[key], key);
     count = scaleRange(count, history.requestCount);
     count = { low: Math.max(1, Math.floor(count.low)), high: Math.max(1, Math.ceil(count.high)) };
@@ -193,13 +206,14 @@ export function estimateWorkload(input: TaskFeatures, route: RouteIdentity, opti
     output = { low: Math.max(output.low, length.low * artifacts), high: Math.max(output.high, length.high * artifacts * overhead) };
     reasons.push(input.explicitOutputTokens ? 'explicit-output-token-budget' : 'requested-length-token-conversion:heuristic');
   }
-  const origin: EstimateOrigin = history ? (template.sourceKind === 'local-measured' ? 'local-measured' : 'mixed') : template.sourceKind;
+  const origin: EstimateOrigin = empirical ? 'local-measured' : history ? (template.sourceKind === 'local-measured' ? 'local-measured' : 'mixed') : template.sourceKind;
   return {
     kind: classification.kind,
     low: buildScenario(count.low, output.low, tool.low, input.currentInputTokens, route, classification.kind, template.sourceKind, config, false, length ? length.low * artifacts : null),
     high: buildScenario(count.high, output.high, tool.high, input.currentInputTokens, route, classification.kind, template.sourceKind, config, 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}`] : [])],
+    origin, reasons, 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}`] : [])],
   };
 }