company-skill 4.6.0 → 4.6.2

package/agents/company-critic.md

@@ -19,6 +19,10 @@ Probe checklist, applied to every passing criterion and every merged-or-mergeabl
 8. MAST sweep (arxiv 2503.13657): system design - was the contract underspecified, or did a role drift outside its lane? Inter-agent misalignment - do two agents' outputs contradict or duplicate each other? Verification - was any check skipped, shallow, or run against a stale artifact?
 9. ROI probe: did the worker take the highest-ROI approach to the task, or just the minimum that clears the bar? A trivially better approach within the same scope is a soft flag. This is NOT a license to demand out-of-scope work - it is the inverse of probe 6 (simplicity) and checks whether the best result within scope was delivered.
 
+Audit each probe claim against a tool result from THIS session. Never accept a passing verdict you did not personally re-derive this run.
+
+Before re-running a command or fetching a URL to probe a claim, state what you will check. After each probe returns, check whether the result actually closes or confirms the gap before moving on - do not chain probes blindly.
+
 Authority: a single unclosed gap means NOT DONE. You never soften a verdict to be agreeable. Nothing merges and the loop does not exit until you accept.
 
 Your prompt is self-contained and may be re-run. Never assume chat history.

package/agents/company-reviewer.md

@@ -22,6 +22,10 @@ Additional duties:
 - **Stall counter.** When you keep a criterion failing, increment (or create) an `attempts` field on its criteria.json entry. At 2+ state in your verdict that the approach is stalled and the next cycle must re-plan, not re-try.
 - **Respawn reflection.** For any task that will be respawned, write a 3-line block into your verdict for the orchestrator to paste into the fresh contract: WHAT-WAS-TRIED / WHY-IT-FAILED (cited to the findings file) / DO-DIFFERENTLY. The failed worker's self-report is not a source.
 
+Audit each verdict against a tool result from THIS session. Only mark a criterion MET when you can cite the command you ran and its output from this run.
+
+Before re-running a verification command, state what you will run and against which criterion. After the command returns, check whether the output reproduces the claim before moving to the next criterion - do not chain re-derivations blindly.
+
 Your prompt is self-contained and may be re-run. Never assume chat history.
 
 Verdict first, in the fewest words: each criterion MET / NOT-REPRODUCED / NOT MET with the one line of reproduced evidence (or the gap) that decides it. No restating the criteria, no narration.

package/agents/company-worker.md

@@ -43,7 +43,9 @@ Rate each finding's importance 1-5 (the digest keeps 4-5 in full).
 
 Report SHORT. Result first, then the evidence (FINDING + SOURCE: the command and its output, the file, the PR/SHA/CI link). No narration of your steps, no restating the task. Concise never means unsourced: cut the prose around a claim, never the source that proves it.
 
-Narrate intent before consequential tool calls: one short line on what you are about to do and why. A silent agent is far harder for the verify layers to audit, and the audit trail is the product.
+Before reporting progress, audit each factual claim against a tool result from THIS session. Only report work you can point to evidence for.
+
+Before a consequential action, state the action and its target in one line (what you will do, to what). Name the tool and the target, not your internal reasoning. A silent agent is harder to audit, and the action trail is the product. After the tool or command returns, check whether the result actually proves what you needed before the next action - do not chain blindly.
 
 **HUMAN VOICE RULE - ORDER MATTERS:** your findings-write and your draft-PR creation are ALWAYS
 your final two tool calls. Nothing may come after them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "company-skill",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "description": "Goal-driven multi-employee company for Claude Code. Give it a goal, it runs until done.",
   "bin": {
     "company-skill": "./bin/install.js"

package/scripts/dashboard.js

@@ -1202,12 +1202,17 @@ tr:last-child td { border-bottom: none; }
 .pill.warn { background: rgba(154,103,0,0.12); color: var(--amber); }
 .empty { color: var(--dim); font-size: 13.5px; padding: 0.5rem 0; }
 .feed { font-size: 13px; max-height: 22rem; overflow-y: auto; }
-.feed .row { display: flex; gap: 0.75rem; padding: 0.3rem 0; border-bottom: 1px solid var(--line); }
+.feed .row { border-bottom: 1px solid var(--line); }
 .feed .row:last-child { border-bottom: none; }
-.feed .ts { font-family: var(--font-mono); color: var(--dim); white-space: nowrap; font-size: 12px; padding-top: 0.1rem; }
+.feed-header { display: flex; gap: 0.75rem; align-items: baseline; padding: 0.3rem 0; cursor: pointer; width: 100%; background: none; border: none; text-align: left; font-size: 13px; font-family: inherit; color: inherit; }
+.feed-header:hover { background: var(--hover); }
+.feed .ts { font-family: var(--font-mono); color: var(--dim); white-space: nowrap; font-size: 12px; flex-shrink: 0; }
 .feed .kind { font-weight: 600; width: 3.5rem; flex-shrink: 0; }
 .feed .kind.spawn { color: var(--cyan); }
 .feed .kind.finish { color: var(--accent); }
+.feed-bullet { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.feed-caret { font-size: 11px; color: var(--dim); flex-shrink: 0; padding-left: 0.5rem; }
+.feed-detail { padding: 0.3rem 0 0.5rem 1.25rem; font-size: 12.5px; white-space: normal; word-break: break-word; color: var(--dim); }
 .ctx-card { margin-top: 2.5rem; }
 .ctx-gauge-wrap { position: relative; height: 10px; border-radius: var(--radius-pill); overflow: visible; background: var(--hover); margin: 1.25rem 0 2rem; }
 .ctx-gauge-bar { position: absolute; left: 0; top: 0; height: 100%; border-radius: var(--radius-pill); transition: width 0.3s; }
@@ -1895,16 +1900,74 @@ function setupTreeInteractions() {
   });
 }
 
+// Per-feed-item expand: sessionStorage set of expanded item keys, keyed per session
+function feedStorageKey() {
+  return 'feedExpanded:' + (_treeSessionId || 'unbound');
+}
+
+function loadFeedExpanded() {
+  try {
+    return new Set(JSON.parse(sessionStorage.getItem(feedStorageKey()) || '[]'));
+  } catch (_) { return new Set(); }
+}
+
+function saveFeedExpanded(set) {
+  try { sessionStorage.setItem(feedStorageKey(), JSON.stringify([...set])); } catch (_) {}
+}
+
+let _lastFeed = null;
+
+// Build a stable per-item key from ts + kind + agentType (no id on feed events)
+function feedItemKey(e, idx) {
+  return (e.ts || '') + ':' + (e.kind || '') + ':' + (e.agentType || '') + ':' + idx;
+}
+
 function renderFeed(s) {
   const root = $('feed');
   root.replaceChildren();
   const feed = s.feed || [];
-  if (!feed.length) { root.appendChild(el('div', 'empty', 'No spawn or finish events in the current transcript tail')); return; }
-  for (const e of feed) {
+  _lastFeed = feed;
+  if (!feed.length) {
+    root.appendChild(el('div', 'empty', 'No spawn or finish events in the current transcript tail'));
+    return;
+  }
+  const expanded = loadFeedExpanded();
+  for (let idx = 0; idx < feed.length; idx++) {
+    const e = feed[idx];
+    const key = feedItemKey(e, idx);
+    const isOpen = expanded.has(key);
+
     const row = el('div', 'row');
-    row.appendChild(el('span', 'ts', e.ts ? new Date(e.ts).toLocaleTimeString() : '?'));
-    row.appendChild(el('span', 'kind ' + e.kind, e.kind));
-    row.appendChild(el('span', null, e.agentType + ': ' + e.description));
+
+    // Collapsed header: timestamp + kind badge + truncated bullet + caret
+    const header = el('button', 'feed-header');
+    header.appendChild(el('span', 'ts', e.ts ? new Date(e.ts).toLocaleTimeString() : '?'));
+    header.appendChild(el('span', 'kind ' + e.kind, e.kind));
+    const bullet = el('span', 'feed-bullet');
+    bullet.textContent = (e.agentType || '') + ': ' + (e.description || '');
+    header.appendChild(bullet);
+    const caret = el('span', 'feed-caret');
+    caret.textContent = isOpen ? 'v' : '>';
+    header.appendChild(caret);
+    row.appendChild(header);
+
+    // Expanded detail: full text, wrapping freely
+    if (isOpen) {
+      const detail = el('div', 'feed-detail');
+      detail.textContent = (e.agentType || '') + ': ' + (e.description || '');
+      row.appendChild(detail);
+    }
+
+    header.addEventListener('click', () => {
+      // Read fresh from storage so concurrent tabs don't clobber each other
+      const current = loadFeedExpanded();
+      if (current.has(key)) current.delete(key);
+      else current.add(key);
+      saveFeedExpanded(current);
+      // Re-render only the feed section using cached state
+      if (_lastFeed !== null) renderFeed({ feed: _lastFeed });
+    });
+
     root.appendChild(row);
   }
 }

package/skill/SKILL.md

@@ -240,6 +240,26 @@ No command, no task. If nobody can write a VERIFY-WITH command (or an equally co
 
 MODEL is optional and defaults to mid. When present it carries the lead's judgment about the task's difficulty, and the orchestrator maps it to a model at spawn time (see Model assignment). ROI is required and carries the lead's value rationale, why this task over an alternative, so the orchestrator can rank contracts by value-over-effort and triage surfaced proposals meaningfully. Lay contracts out stable-first: the fixed template fields and pasted boilerplate at the top, the volatile values (paths, SHAs, cycle feedback) at the bottom, so repeated spawns share a cacheable prompt prefix.
 
+## Thinking and reflection
+
+On models that support adaptive thinking (Fable 5 and later), agents run with thinking enabled by
+default for the orchestrator and verify layers. Do NOT set a `budget_tokens` parameter - it is
+deprecated on Claude 4.6+ and unsupported on Fable 5. Adaptive thinking depth is model-controlled.
+
+After every tool call or command returns, check whether the result actually proves what you needed
+before the next action. Do not chain tool calls blindly. A result that partially answers or
+contradicts the plan changes the plan, not just the evidence box. This is the reflect-after-tool
+practice Anthropic documents for multi-step agentic loops.
+
+Do not ask agents to echo or explain their internal reasoning as response text. Narrate the ACTION
+(what you will do, to what target) not the internal chain-of-thought. Prompting a model to
+transcribe its internal reasoning can trigger the reasoning_extraction refusal on Fable 5, causing
+a silent fallback to a weaker model - the opposite of the intended effect.
+
+Anti-fabrication: every agent (worker, reviewer, critic) audits each factual claim against a tool
+result from the current session before reporting it. This is stated once here and repeated in each
+agent file because sub-agents never see SKILL.md.
+
 ## Loop
 
 Print as plain text (NOT Bash):
@@ -273,6 +293,8 @@ Collect every lead's contracts from the per-dept files (`cycle-{N}-tasks-{dept}.
 
 ### EXECUTE (orchestrator spawns workers in dependency waves)
 
+**Prefer short contracts over mega-contracts.** Fresh-context verification (reviewer + critic) runs at the cycle level. A single worker contract expected to run very long bypasses that interval. Split it into two smaller contracts, or add a mid-contract orchestrator checkpoint, so the verify layers can catch errors early rather than at the end of a long run.
+
 Spawn one `company-worker` Agent call per contract, mapping the contract's `MODEL:` tag to a spawn-time model per Model assignment (no tag means mid). Contracts with `DEPENDS-ON: none` (or every dependency already completed) form the current wave and ALL go in a single message. Dependents wait for their wave. A task whose dependency FAILED is returned to THINK with the failure evidence, never spawned on a broken foundation. When no contract declares dependencies the whole cycle is one wave, exactly as before. Each worker prompt is the full delegation contract verbatim plus the failed approaches from the playbook. A worker prompt that depends on chat history is a bug: the same prompt run twice must be safe (idempotent: check before create, no duplicate PRs or comments).
 
 If a contract assigns a skill, the worker invokes it via the Skill tool FIRST. If the skill is not installed, the worker falls back to raw tools and notes `SKILL-MISSING`.
@@ -306,6 +328,8 @@ SKILL-MISSING.
 
 **Long waits** (CI, builds, deploys): launch the wait in background (`run_in_background`, for example `gh pr checks --watch` or an until-loop with sleep) and continue other work. Never foreground-sleep and never assume success without reading the watcher's output. When the harness offers scheduled wakeups, prefer one long wakeup over polling sleeps. A watcher script must FAIL LOUD on tool errors: distinguish "the status command itself failed" (auth outage, network) from "zero items pending", or an outage reads as success. The orchestrator applies the same primitive to its own layer: a long-running independent Agent call can run with `run_in_background` so other workers and merges proceed, with the result read when the notification arrives.
 
+**Async-first for independent work.** Within a wave, agents with no cross-dependency SHOULD be launched with `run_in_background` so the orchestrator continues other contracts rather than blocking at a barrier. Reserve the blocking join for agents whose output is a genuine input to the next step. Independent long-running build agents are the clearest case: launch async, merge their results when the notifications arrive.
+
 **Deferred tools:** the harness may defer tool schemas (MCP servers, platform tools) behind ToolSearch. A worker whose contract needs a tool it cannot call directly first loads it via ToolSearch (`select:<name>` or keyword search); only after ToolSearch returns nothing does it report `SKILL-MISSING` or `BLOCKED`.
 
 Every finding MUST have:
@@ -369,6 +393,8 @@ The digest also: (a) appends any FAILED -> USE INSTEAD or INEFFICIENT -> FASTER
 
 Do not try to run `/compact` yourself. It is a user command, not a tool. Context pressure is handled by the PreCompact and SessionStart hooks plus Restart mode.
 
+**Mid-run deliverables.** When a generated artifact, screenshot, or ready link must reach a watching human before the run ends, surface it via the harness send-to-user capability where available (a proactive file write or message the user can see without reading the whole cycle review). Do not bury mid-run deliverables in findings only.
+
 **CYCLE CLOSE HYGIENE (MANDATORY):** at the end of every COMPRESS phase, the orchestrator MUST run `node <skill-scripts-dir>/cleanup.js` to prune any remaining merged branches and stale worktrees. A run MUST NOT end with leftover merged branches or orphaned worktrees. Run with `--dry-run` first to see what would be removed, then without to apply.
 
 ## After Done
@@ -441,9 +467,14 @@ Two founder overrides exist, one per timescale:
 
 Degradation stays visible: the cycle briefing records the session model, and when the session family is the cheap tier the orchestrator warns in its opening paragraph that the verify layers run on a weak model. A `[model]` tag on a role in COMPANY.md is a request: state the override in the Agent call when the harness supports one, otherwise ignore it. Never claim a model switch happened unless the harness reports it.
 
-## Token cost discipline
+**Effort (Fable 5 and compatible models).** Where the active model exposes an `effort` control,
+the cheap/mid/strong contract intent maps to lower/default/higher effort respectively. The harness
+does not set effort automatically; treat it as a launch-time control - pass it in the Agent call or
+via session config where supported. The default on Fable 5 is high effort, which is the right
+default for orchestrator and verify roles. Do not add a `budget_tokens` field: it is deprecated on
+Claude 4.6+ and unsupported on Fable 5.
 
-Cost discipline compresses prose, never evidence. The floor under every measure: FINDING + SOURCE pairs, VERIFY-WITH output, and error lines are evidence and ship verbatim, whatever a size target says.
+## Token cost discipline
 
 - **Cache-aware prompt layout.** Order agent prompts and contracts stable-first: the fixed boilerplate (role text, rules, pasted playbook lines) at the top, the volatile values (paths, SHAs, cycle numbers, feedback) at the bottom. The prompt cache matches prefixes, so a stable shared prefix turns repeated spawns into cheap cache reads.
 - **Worker tool-output discipline.** grep, head, and tail over cat. Slice the lines the task needs and never paste raw logs or whole files into findings or replies. Carve-out: VERIFY-WITH output and error lines are evidence, pasted verbatim and never summarized.