@deepseek-insight/dsi 0.10.1 → 0.10.2

package/build/server/chunks/nodes/{0.js-xX4GZsu5.js → 0.js-Do4ZKaKe.js}

@@ -4,9 +4,9 @@ const index = 0;
 let component_cache;
 const component = async () => component_cache ??= (await import('../entries/pages/_layout.svelte.js-DRfiLzlz.js')).default;
 const universal_id = "src/routes/+layout.ts";
-const imports = ["_app/immutable/nodes/0.CfpMgVS-.js","_app/immutable/chunks/0Tfhif1V.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/CTWtsoJD.js","_app/immutable/chunks/D9jhmf3I.js"];
-const stylesheets = ["_app/immutable/assets/0.CxUWwepa.css"];
+const imports = ["_app/immutable/nodes/0.CYP0vr1_.js","_app/immutable/chunks/0Tfhif1V.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/CTWtsoJD.js","_app/immutable/chunks/D9jhmf3I.js"];
+const stylesheets = ["_app/immutable/assets/0.B2rul4Mk.css"];
 const fonts = [];
 
 export { component, fonts, imports, index, stylesheets, universal_id };
-//# sourceMappingURL=0.js-xX4GZsu5.js.map
+//# sourceMappingURL=0.js-Do4ZKaKe.js.map

package/build/server/chunks/nodes/1.js-CRbdbfof.js

@@ -0,0 +1,9 @@
+const index = 1;
+let component_cache;
+const component = async () => component_cache ??= (await import('../entries/pages/_error.svelte.js-TrOSxb0e.js')).default;
+const imports = ["_app/immutable/nodes/1.CSTMQTZ7.js","_app/immutable/chunks/0Tfhif1V.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/BodLd2is.js","_app/immutable/chunks/D17XAauH.js","_app/immutable/chunks/D9jhmf3I.js"];
+const stylesheets = [];
+const fonts = [];
+
+export { component, fonts, imports, index, stylesheets };
+//# sourceMappingURL=1.js-CRbdbfof.js.map

package/build/server/chunks/nodes/{2.js-CBdFoBFK.js → 2.js-BFX_zPfJ.js}

@@ -1,8 +1,8 @@
-export { _ as server } from '../entries/pages/_page.server.ts.js-BK3Y6eff.js';
-import '../chunks/dsh-connection.js-BW07Aicl.js';
-import '../chunks/insight-config.js-C5-Rhh5A.js';
+export { _ as server } from '../entries/pages/_page.server.ts.js-BFDPRDEm.js';
+import '../chunks/dsh-connection.js-Dcdxqp52.js';
+import '../chunks/insight-config.js-ylYA2CXm.js';
 import '../chunks/config.js-r_jw_bQQ.js';
-import '../chunks/settings-document.js-DxKURfc_.js';
+import '../chunks/settings-document.js-BIxaivJ1.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
@@ -19,11 +19,11 @@ import '../chunks/uneval.js-BJ9Qq2SF.js';
 
 const index = 2;
 let component_cache;
-const component = async () => component_cache ??= (await import('../entries/pages/_page.svelte.js-DaZfwP76.js')).default;
+const component = async () => component_cache ??= (await import('../entries/pages/_page.svelte.js-BUuXoaje.js')).default;
 const server_id = "src/routes/+page.server.ts";
-const imports = ["_app/immutable/nodes/2.D0JzdegJ.js","_app/immutable/chunks/0Tfhif1V.js","_app/immutable/chunks/DttyJZuo.js","_app/immutable/chunks/HclGiUj8.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/D9jhmf3I.js","_app/immutable/chunks/CTWtsoJD.js","_app/immutable/chunks/UcxQDPMg.js"];
-const stylesheets = ["_app/immutable/assets/2.CSFboNRO.css"];
+const imports = ["_app/immutable/nodes/2.CdbJFHUF.js","_app/immutable/chunks/0Tfhif1V.js","_app/immutable/chunks/D17XAauH.js","_app/immutable/chunks/HclGiUj8.js","_app/immutable/chunks/xihTtKlq.js","_app/immutable/chunks/D9jhmf3I.js","_app/immutable/chunks/CTWtsoJD.js","_app/immutable/chunks/BodLd2is.js"];
+const stylesheets = ["_app/immutable/assets/2.glyfXGzi.css"];
 const fonts = [];
 
 export { component, fonts, imports, index, server_id, stylesheets };
-//# sourceMappingURL=2.js-CBdFoBFK.js.map
+//# sourceMappingURL=2.js-BFX_zPfJ.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@deepseek-insight/dsi",
-	"version": "0.10.1",
+	"version": "0.10.2",
 	"description": "See your multiple agents run on the floor (agent, sub-agent, etc), each conversation on the floor are updated instantly.",
 	"keywords": [
 		"Deepseek",

package/skills/dsi-drive-terminal/SKILL.md

@@ -126,7 +126,7 @@ curl -s -X POST http://127.0.0.1:$PORT/api/terminal/$ID/send \
   -H 'content-type: application/json' --data-binary @/tmp/t1-cmd.json
 ```
 
-- **Human pace when the operator watches**: one char per write, ~120 ms
+- **Human pace when the operator watches**: one char per write, ~60 ms
   apart, each response checked `{"written":true}`. Faster bursts hit the
   write fence and DROP characters (live: `sudo apt update` →
   `sudoaptupdate`, zsh "command not found").
@@ -200,6 +200,28 @@ verified at the end.
 
 ---
 
+## --peek — the Read-Only Mode (2026-11-07, ADR amendment D7)
+
+\`/dsi-drive-terminal --peek {session or tab badge}\` checks WHAT IS GOING ON
+on the designated terminal and writes NOTHING. No baton is taken — watching
+is token-free, so the operator's tab never heals, never blinks.
+
+Recipe (all reads, zero writes):
+
+1. Resolve the session id from evidence — the badge law stands: read the
+   desk badge \`T{n}:{id}\` or \`GET /api/terminal\` (\`curl -s http://127.0.0.1:$PORT/api/terminal\`),
+   cross-check the \`exited\` flag. NEVER assume tab position = session id.
+2. Read the ring tail — the watcher path, no token:
+   \`curl -s "http://127.0.0.1:$PORT/api/terminal/$ID/output?fromByte=0"\`
+   (the retained ring is the authority; ANSI-strip the tail per Step 3).
+3. Report: session id, exited or live, the last screenful of output, and —
+   if live — the likely foreground command visible in the scrollback.
+
+Peek NEVER: reattaches, writes bytes, mints or accepts a token. If the
+operator then says "drive it", hand over to the full drive pipeline (Step 1).
+
+---
+
 ## How This Skill Connects to the Docs
 
 The skill is the DO-path; the docs carry the WHY and the CONTRACT.

package/skills/dsi-spec/SKILL.md

@@ -204,6 +204,12 @@ Save to: `{project-path}/dev/specs/{YYYY-MM}/{TODAY} - {Feature Name}/karpathy-c
 
 **Contents:** All 3 layers as structured markdown. This is the internal context file the task-executor loads when executing.
 
+**Self-sufficiency contract (2026-11-07, the 5.7M lesson):** under the split-session flow (AGENTS.md,
+Split-Session Execution) a fresh NORMAL session (auto-spawned via `schedule_create` `new_once`)
+executes from this folder alone — the planner is gone when it runs. Every file:line fact, decision rationale, rejected alternative, and verification command the
+executor will need MUST be written here while the planner still holds it; a gap means the child
+re-does the discovery, which is the exact cost the split exists to cut.
+
 ### Document 4: Tasks Machine Twin (Tasks.json)
 
 Save to: `{project-path}/dev/specs/{YYYY-MM}/{TODAY} - {Feature Name}/Tasks.json`
@@ -291,6 +297,8 @@ This is the ONLY checklist output to the user. Declared at the start. Verified a
 
 ## How This Skill Connects to task-executor
 
+⛔ **MANDATORY HANDOFF (2026-11-07, earned twice)**: when this skill's four deliverables are saved, the NEXT action in the same session is invoking `dsi-task` (repo skills copy: `skills/dsi-task/SKILL.md`) — its Step 3.10 Wave Executor and Step 3.11 Churn Discipline are the only sanctioned execution path for the produced waves. Do NOT implement the waves inline in the parent; do not end the turn with "deliverables ready" and treat execution as a separate discretionary task. Writing Tasks.md discharges NOTHING — the consuming skill does (AGENTS.md hard gate). Skipping it re-burns the spend the amendments were written to save (2026-11-07: 10.6M lesson, re-paid at 16.6M).
+
 After `/feature-spec` produces the deliverables, the user can run `/execute-tasks` to begin implementation. The task-executor skill loads the Karpathy context and tasks document produced by this skill.
 
 ```mermaid

package/skills/dsi-task/SKILL.md

@@ -91,6 +91,13 @@ Before any execution, load exactly these files:
 
 Read these files at the start. Do NOT carry them from previous conversation context — reload fresh.
 
+> **Handoff-valid (2026-11-07, the 5.7M lesson):** this skill is designed to be loaded by a FRESH
+> NORMAL session dispatched by the planner via `schedule_create` `new_once` (AGENTS.md, Split-Session
+> Execution — never a subagent: Step 3.10/Step 4 need depth-1 children) — Step 1's
+> two disk files ARE the whole contract, no planner context required. If the dispatch prompt names a
+> spec folder, resolve karpathy-context + Tasks from it and begin; anything the spec folder fails to
+> answer is a STOP-and-report, never a re-discovery.
+
 ---
 
 ## Step 1.5: Date Resolution ⛔ MANDATORY
@@ -231,6 +238,33 @@ When a gate or spec pins a tag-filtered run (`--grep @tag`):
 Criterion: the tagged invocation reports the expected collected count, and every failure in a newly reachable suite is classified with git-log evidence.
 <!-- RCA: 2026-08-17 openclaw-insight Control Room Recovery W5 — the spec-pinned `--grep @orchestration` had selected zero tests ever since the base config gained its exclusion grep; a sibling config (spread base, clear only grep) un-buried the recovery spec (5/5 green) plus a 2026-08-08 suite asserting the removed pre-redesign page — stale, documented, not rewritten. -->
 
+
+### Step 3.10: Wave Executor — Cost-Driven Sub-Agent Delegation
+
+When a wave's declared tasks imply >= 8 mechanical execution steps (test authoring + reruns, sibling-suite surveys, file migrations, gate runs), delegate the execution loop to ONE sub-agent and keep decisions in the parent. Never delegate acceptance-scenario adjudication (Step 3.1), commits, or operator-gesture tasks (glass live passes).
+
+1. **Wave-pack**: mechanical extraction from Tasks.md + karpathy-context.md, verbatim — the wave header (tasks, touched-file contract, checklist, gate command), Layer-3 constraint/boundary/shared-layer excerpts, compatibility-matrix rows proved by this wave, risk-register rows pinned by this wave's -T tasks, behavioral commitments, TODAY.
+2. **Child runs scoped suites freely**; the parent re-runs the completion gate itself before marking the wave done.
+3. **Deviation protocol**: the child never silently expands the touched-file contract — out-of-contract need is PROPOSED to the parent (files + why), never executed unasked.
+4. **Escalation budget**: > 3 consecutive failing runs with the same root cause -> return `ESCALATED: <finding>` with evidence; never grind.
+5. **Parent duties**: adjudicate the structured return (gate output, git status, failure ledger with root causes, escalations), assert the touched-file contract including approved deviations, keep the checklist in the parent transcript. The child holds no commit or next-wave authority.
+6. **Rolling pool**: a -T task that is a cluster of >= 3 independent file migrations may run as TWO children, one wave-pack slice per file. Feature-code tasks never parallelize — they share files across waves.
+
+Criterion: delegated wave completes with parent-adjudicated gate output, touched-file contract asserted, and zero unapproved scope expansions.
+<!-- RCA: 2026-11-07 deepseek-insight Terminal Stream Hub — Waves 3+4 burned 61 percent of 10.6M tok on 47 percent of steps at 110-150k per-step context; a child runs the same steps at 20-60k. The streamEnded arc (unhandled rejection skipped the unmount cleanup) is the escalation-valve case: the child returns the finding, the parent decides with session memory. Real Wave-3 touched 7 files against a 3-file contract — hence the deviation protocol. -->
+
+### Step 3.11: Churn Discipline ⛔
+
+1. **Contract pins before consumer waves**: when a wave changes a shared contract (wire shapes, URL grammar, store fields), its -T tests pin the NEW contract first; dependent suites migrate only after the pin is green.
+2. **Batch-then-run**: author a wave's full test set, then one scoped run — no run-per-test authoring.
+3. **Scoped suites per wave**; the full suite only in the final gates wave (Step 5 already scopes this — apply it inside waves too).
+4. **Assertions match the implementation as written**: read the diff before finalizing test text; tests drafted from the intended design produce assertion churn.
+5. **Failure ledger**: every test-fix step classifies the failure test-side / regression / environment. Two consecutive test-side failures on the same suite -> stop, re-read the implementation, rewrite the test.
+6. **Churn budget**: a wave burning > 50 percent of its steps on fix loops triggers a scope-or-contract review — fix the cause, not the symptom.
+
+Criterion: a wave's fix-loop steps stay under half its step count, and every fix-loop step names its failure class.
+<!-- RCA: 2026-11-07 deepseek-insight Terminal Stream Hub — 17 of 111 steps were fix loops; 10 were test-side assertions drafted from intended design instead of the written code; batching + scoped suites would have collapsed most. Deferral of tests to feature-end rejected: it moves the same fix steps to maximum context with N-wave attribution bisection. -->
+
 ## Step 4: Sub-Agent Safety — When Spawning Children
 
 Only fires when a task requires spawning a sub-agent. If no sub-agents are spawned, mark `[⊘]` in the checklist and skip this step.

package/skills/dsi-token-spent/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: "dsi-token-spent"
+description: "Reconstruct the current session's token spend — phase breakdown, tool-call error ledger, degenerate-loop detection — and write a dated TL;DR report with flow + sequence diagrams under dev/token-spent/, ADR-style filename. Reserved keyword: /dsi-token-spent."
+---
+
+# DSI Token Spend Report
+
+One trigger → full reconstruction pipeline. Rebuild how the session's tokens were actually spent (phases, tool calls, errors, loops), write a dated report with a TL;DR, a breakdown table, an error ledger, and two mermaid diagrams (flowchart + sequence), saved under `dev/token-spent/` with the ADR-style filename convention.
+
+## When to Use
+
+- User runs `/dsi-token-spent` or asks "how much did this session spend / where did the tokens go?"
+- User asks for a spend/cost breakdown of the current conversation
+- After a notably expensive session, to record where it went and what to carry forward
+
+## Hard rules earned 2026-11-07 (the session this skill was born from)
+
+1. **Never emit a placeholder call.** A call that does not advance the task is a STOP signal, not a stepping stone.
+2. **Three identical calls with zero state change = hard halt** and surface to the operator. (The founding session looped 93 identical `console.log` calls at maximum context — plausibly a third of the session's spend.)
+3. **On a quoting/parse failure, SWITCH TRANSPORT immediately** (direct file tool, or write a script file and run it) — never retry the same broken embedding.
+4. **Load skills whole** — length-check the load (`TOTAL CHARS`) before executing; a truncated skill produces truncated work.
+5. **Heavy waits go to background jobs on the first timeout** — the deadline is a signal, not a wall to bump.
+
+These rules apply DURING this pipeline too — the report must not become the next offender.
+
+## Step 0: No Params — Defaults
+
+With no arguments, use these defaults (state them, don't ask):
+
+- **Scope**: the CURRENT session, from its first turn to now
+- **Output**: `dev/token-spent/{TODAY} - Token Spend Report — {TOTAL} tok — {a memorable claim about where it went}.md` (ADR-style naming: date prefix, the DSH-reported total token count, em-dash claim — see existing files in that folder). The TOTAL comes from DSH's own usage counters (Step 0.6) and is quoted verbatim in the filename; no estimate goes in the title.
+- **Precision**: estimates ±20 percent, methodology stated in the report — never fake precision
+
+## Step 0.5: Date Resolution ⛔ MANDATORY
+
+Resolve today's date via `date +%Y-%m-%d`. Store as `TODAY`. Never infer from context.
+
+## Step 0.6: Read DSH's own usage counters ⛔ MANDATORY (hard data)
+
+The operator's DSH GUI shows a session usage strip (turns / steps / tok/s / total tok / cache hit %). Before ANY estimation:
+
+1. Ask the operator for that strip, or read it from the harness surface if reachable — **these counters outrank every estimate**.
+2. Quote them verbatim in the TL;DR and put the total in the filename/title.
+3. Count steps THE WAY DSH counts steps: one step = one model round-trip (every tool call is a step), NOT one operator-visible message. A 12-message session is routinely 100+ steps.
+4. Total token count includes CACHED input — a high cache-hit percent reduces COST, never the token TOTAL. Never model "cost" and report it as "tokens".
+
+## Pipeline Checklist — MANDATORY
+
+This is the ONLY checklist output to the user. Declared at the start. Re-rendered with `[✅]/[🔄]/[ ]` at each phase transition. Verified at the end.
+
+```
+📋 dsi-token-spent: {session summary}
+
+   [ ]  0.5 ⛔ Resolve today's date via `date +%Y-%m-%d` (store as TODAY)
+   [ ]  0.6 ⛔ Read DSH's usage counters (turns / steps / total tok / cache hit %) — TOTAL goes in the title verbatim
+
+   Step 1: Reconstruct the transcript
+   [ ]  1.1  Turn count and phase boundaries identified
+   [ ]  1.2  Tool calls counted by category (bash/read/write/edit/skills/goal ops)
+   [ ]  1.3  Tool-call ERRORS counted with per-error root cause (the ledger)
+   [ ]  1.4  Degenerate loops detected: identical no-op calls counted (the 3-identical rule, applied retroactively)
+
+   Step 2: Spend analysis
+   [ ]  2.1  Phase breakdown table with share + estimated tokens + WHY each phase cost what it cost — RECOUNTED from the transcript's step sequence (tally shown, anchored to the DSH step/total counters), never a rescale of a wrong estimate
+   [ ]  2.2  Session-overhead tax accounted (preamble/skills re-sent every turn)
+   [ ]  2.3  Methodology paragraph written (estimates, ±20 percent, no fake precision)
+   [ ]  2.4  Operator captures (usage screenshots) quoted as hard data when available
+
+   Step 3: Write the report
+   [ ]  3.1  TL;DR — the headline numbers and the headline lesson
+   [ ]  3.2  Breakdown table + tool-call ledger + error ledger with root causes
+   [ ]  3.3  Mermaid flowchart (spend concentration) + sequenceDiagram (a typical error or loop round-trip) — per the mermaid syntax rules (no colons in labels, no style in sequence blocks)
+   [ ]  3.4  Operator complaints/quotes verbatim as the entrance
+   [ ]  3.5  Carry-forward rules — numbered, each earned by a specific trap from THIS session
+
+   Step 4: Verify and save
+   [ ]  4.1  Report exists on disk at the ADR-style path (verified via ls)
+   [ ]  4.2  Both mermaid blocks present and syntax-clean (no stray semicolons/colons in labels)
+   [ ]  4.3  No placeholder or no-op calls were emitted during THIS pipeline (self-audit aloud)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Step 1: Reconstruct the transcript
+
+Walk the session from memory of the CURRENT context (the transcript is in it — do not guess):
+
+- **Phase boundaries**: feature/bug/report arcs, with turn ranges
+- **Tool calls by category**: bash, read, write, edit, skills, goal/todo/present/ask_user/job ops
+- **Error ledger**: every rejected/failed call with its ROOT CAUSE (hygiene rule violated, path wrong, timeout, policy rejection), not just its text
+- **Degenerate loops**: any run of identical or near-identical calls with zero state change. Count them. Name them. The founding session's 93-call `console.log('www…')` loop is the exemplar — it was the single largest cost line and the operator had to catch it.
+
+## Step 2: Spend analysis
+
+The harness re-feeds the whole conversation at every STEP (one step = one model round-trip; a tool call is a step): **total = sum of context at each step** — and the DSH counter counts cached input too. So:
+
+- Late-session calls cost more than early ones (bigger re-feed) — weight accordingly
+- Large artifacts written early (ADRs, PRDs, test outputs) are re-paid every later turn — artifacts ARE the budget
+- Session overhead (system prompt + AGENTS.md + skill bodies) is a fixed tax on every turn
+- Operator-provided usage counters (screenshots, the DSH strip) are HARD DATA — quote them; they outrank estimates. If your estimate disagrees with the counter by orders of magnitude, the estimate is wrong: explain the gap with a 5-why in the report, never defend the model
+- State the ±20 percent band and the methodology in the report. Never invent precise numbers.
+- **The breakdown table MUST be a recount, never a rescale.** Tally STEPS per phase from the actual call sequence in the transcript (one tool round-trip = one step — the tally should match the DSH step counter), price each phase's steps at the context size at its position, and show the arithmetic in the report (steps × avg context = tokens per phase, summing to the DSH total within a stated residual). A table whose phase tokens are the old wrong total re-labeled is a LAZY table — regenerate the arithmetic or do not write the section. If the tally misses the DSH step counter, say where the uncounted steps live; do not pad.
+
+## Step 3: Write the report
+
+Save to `dev/token-spent/{TODAY} - Token Spend Report — {claim}.md`:
+
+1. **TL;DR** — headline numbers (total, calls, error count, commits), the headline lesson, the biggest avoidable cost
+2. **The complaints/quotes in the operator's own words** — verbatim, numbered (they are the entrance of the story)
+3. **Breakdown table** — phase | what | share | est. tokens | why it cost what it cost. Include degenerate loops as their OWN line item when found
+4. **Tool-call ledger** — category counts, then the error ledger: # | error | root cause | cost shape
+5. **Mermaid flowchart** — where the spend concentrates (turn → preamble → re-feed → tool → result/error → history grows)
+6. **Mermaid sequenceDiagram** — a typical error or loop round-trip, actors labeled
+7. **Carry-forward rules** — numbered, each phrased as a rule earned by a specific trap from this session ("be careful" is not a rule)
+
+Writing rule: every section leads with a plain-language sentence; file/line citations are handles, not prose.
+
+## Step 4: Verify and save
+
+- `ls` the output path — the file exists
+- Both mermaid blocks present; check syntax (no `;` in message text, no style directives in sequence blocks)
+- Self-audit aloud: no placeholder calls were emitted during this pipeline; the 3-identical rule was not tripped
+- Offer commit/push; do not push unasked