feat: Sprint 23 — agentic transparency + polish

Track A: Token/cost display
- Read agent usage attrs (session_prompt_tokens, session_completion_tokens,
  session_estimated_cost_usd) after run_conversation in streaming.py
- Add input_tokens, output_tokens, estimated_cost fields to Session model
- Include usage in done SSE event payload
- Store usage on S.lastUsage in messages.js done handler
- Render usage badge below last assistant message (input/output/cost)

Track B: Subagent delegation cards
- Add subagent_progress to toolIcon map with shuffle emoji
- Special-case subagent_progress in buildToolCard: "Subagent" label,
  strip double emoji from preview, add tool-card-subagent CSS class
- Indented border-left styling for subagent cards
- Clean delegate_task display name

Track C: Skill picker in cron create form
- Add skill search input + tag chips to cron create form HTML
- Skill picker JS in panels.js: search/filter, click-to-add tags,
  remove tag chips, pre-fetch skill list on form open
- submitCronCreate sends skills array in POST body
- Skill picker dropdown + tag CSS

Track D: Skill linked files viewer
- Add file query param to /api/skills/content endpoint
- Serve linked files from skill directory with path traversal protection
- Ensure linked_files key always present in skill content response
- Render linked files section below SKILL.md content in preview panel
- openSkillFile function for viewing individual linked files

Track E: Bug fixes and code quality
- Expand Session.__init__ and compact() to readable multi-line format
- Remove inline import json as _j2 inside loop in streaming.py
- Fix tool_calls: capture args from assistant messages, skip unresolved names
- Store args snapshot in persisted tool_calls for reload display

6 new tests. Total: 421 (409 passing).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

api/models.py

@@ -34,17 +34,65 @@ def _write_session_index():
 
 
 class Session:
-    def __init__(self, session_id=None, title='Untitled', workspace=str(DEFAULT_WORKSPACE), model=DEFAULT_MODEL, messages=None, created_at=None, updated_at=None, tool_calls=None, pinned=False, archived=False, project_id=None, profile=None, **kwargs):
-        self.session_id = session_id or uuid.uuid4().hex[:12]; self.title = title; self.workspace = str(Path(workspace).expanduser().resolve()); self.model = model; self.messages = messages or []; self.tool_calls = tool_calls or []; self.created_at = created_at or time.time(); self.updated_at = updated_at or time.time(); self.pinned = bool(pinned); self.archived = bool(archived); self.project_id = project_id or None; self.profile = profile
+    def __init__(self, session_id=None, title='Untitled',
+                 workspace=str(DEFAULT_WORKSPACE), model=DEFAULT_MODEL,
+                 messages=None, created_at=None, updated_at=None,
+                 tool_calls=None, pinned=False, archived=False,
+                 project_id=None, profile=None,
+                 input_tokens=0, output_tokens=0, estimated_cost=None,
+                 **kwargs):
+        self.session_id = session_id or uuid.uuid4().hex[:12]
+        self.title = title
+        self.workspace = str(Path(workspace).expanduser().resolve())
+        self.model = model
+        self.messages = messages or []
+        self.tool_calls = tool_calls or []
+        self.created_at = created_at or time.time()
+        self.updated_at = updated_at or time.time()
+        self.pinned = bool(pinned)
+        self.archived = bool(archived)
+        self.project_id = project_id or None
+        self.profile = profile
+        self.input_tokens = input_tokens or 0
+        self.output_tokens = output_tokens or 0
+        self.estimated_cost = estimated_cost
+
     @property
-    def path(self): return SESSION_DIR / f'{self.session_id}.json'
-    def save(self): self.updated_at = time.time(); self.path.write_text(json.dumps(self.__dict__, ensure_ascii=False, indent=2), encoding='utf-8'); _write_session_index()
+    def path(self):
+        return SESSION_DIR / f'{self.session_id}.json'
+
+    def save(self):
+        self.updated_at = time.time()
+        self.path.write_text(
+            json.dumps(self.__dict__, ensure_ascii=False, indent=2),
+            encoding='utf-8',
+        )
+        _write_session_index()
+
     @classmethod
     def load(cls, sid):
         p = SESSION_DIR / f'{sid}.json'
-        if not p.exists(): return None
+        if not p.exists():
+            return None
         return cls(**json.loads(p.read_text(encoding='utf-8')))
-    def compact(self): return {'session_id': self.session_id, 'title': self.title, 'workspace': self.workspace, 'model': self.model, 'message_count': len(self.messages), 'created_at': self.created_at, 'updated_at': self.updated_at, 'pinned': self.pinned, 'archived': self.archived, 'project_id': self.project_id, 'profile': self.profile}
+
+    def compact(self):
+        return {
+            'session_id': self.session_id,
+            'title': self.title,
+            'workspace': self.workspace,
+            'model': self.model,
+            'message_count': len(self.messages),
+            'created_at': self.created_at,
+            'updated_at': self.updated_at,
+            'pinned': self.pinned,
+            'archived': self.archived,
+            'project_id': self.project_id,
+            'profile': self.profile,
+            'input_tokens': self.input_tokens,
+            'output_tokens': self.output_tokens,
+            'estimated_cost': self.estimated_cost,
+        }
 
 def get_session(sid):
     with LOCK:

api/routes.py

@@ -223,11 +223,26 @@ def handle_get(handler, parsed):
         return j(handler, {'skills': data.get('skills', [])})
 
     if parsed.path == '/api/skills/content':
-        from tools.skills_tool import skill_view as _skill_view
-        name = parse_qs(parsed.query).get('name', [''])[0]
+        from tools.skills_tool import skill_view as _skill_view, SKILLS_DIR
+        qs = parse_qs(parsed.query)
+        name = qs.get('name', [''])[0]
         if not name: return j(handler, {'error': 'name required'}, status=400)
+        file_path = qs.get('file', [''])[0]
+        if file_path:
+            # Serve a linked file from the skill directory
+            skill_dir = None
+            for p in SKILLS_DIR.rglob(name):
+                if p.is_dir(): skill_dir = p; break
+            if not skill_dir: return bad(handler, 'Skill not found', 404)
+            target = (skill_dir / file_path).resolve()
+            try: target.relative_to(skill_dir.resolve())
+            except ValueError: return bad(handler, 'Invalid file path', 400)
+            if not target.exists() or not target.is_file():
+                return bad(handler, 'File not found', 404)
+            return j(handler, {'content': target.read_text(encoding='utf-8'), 'path': file_path})
         raw = _skill_view(name)
         data = json.loads(raw) if isinstance(raw, str) else raw
+        if 'linked_files' not in data: data['linked_files'] = {}
         return j(handler, data)
 
     # ── Memory API (GET) ──

api/streaming.py

@@ -171,11 +171,20 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
             )
             s.messages = result.get('messages') or s.messages
             s.title = title_from(s.messages, s.title)
+            # Read token/cost usage from the agent object (if available)
+            input_tokens = getattr(agent, 'session_prompt_tokens', 0) or 0
+            output_tokens = getattr(agent, 'session_completion_tokens', 0) or 0
+            estimated_cost = getattr(agent, 'session_estimated_cost_usd', None)
+            s.input_tokens = (s.input_tokens or 0) + input_tokens
+            s.output_tokens = (s.output_tokens or 0) + output_tokens
+            if estimated_cost:
+                s.estimated_cost = (s.estimated_cost or 0) + estimated_cost
             # Extract tool call metadata grouped by assistant message index
             # Each tool call gets assistant_msg_idx so the client can render
             # cards inline with the assistant bubble that triggered them.
             tool_calls = []
             pending_names = {}   # tool_call_id -> name
+            pending_args = {}    # tool_call_id -> args dict
             pending_asst_idx = {} # tool_call_id -> index in s.messages
             for msg_idx, m in enumerate(s.messages):
                 if m.get('role') == 'assistant':
@@ -184,22 +193,31 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
                         for p in c:
                             if isinstance(p, dict) and p.get('type') == 'tool_use':
                                 tid = p.get('id', '')
-                                pending_names[tid] = p.get('name', 'tool')
+                                pending_names[tid] = p.get('name', '')
+                                pending_args[tid] = p.get('input', {})
                                 pending_asst_idx[tid] = msg_idx
                 elif m.get('role') == 'tool':
                     tid = m.get('tool_call_id') or m.get('tool_use_id', '')
-                    name = pending_names.get(tid, 'tool')
+                    name = pending_names.get(tid, '')
+                    if not name or name == 'tool':
+                        continue  # skip unresolvable tool entries
                     asst_idx = pending_asst_idx.get(tid, -1)
+                    args = pending_args.get(tid, {})
                     raw = str(m.get('content', ''))
                     try:
-                        import json as _j2
-                        rd = _j2.loads(raw)
+                        rd = json.loads(raw)
                         snippet = str(rd.get('output') or rd.get('result') or rd.get('error') or raw)[:200]
                     except Exception:
                         snippet = raw[:200]
+                    # Truncate args values for storage
+                    args_snap = {}
+                    if isinstance(args, dict):
+                        for k, v in list(args.items())[:6]:
+                            s2 = str(v)
+                            args_snap[k] = s2[:120] + ('...' if len(s2) > 120 else '')
                     tool_calls.append({
                         'name': name, 'snippet': snippet, 'tid': tid,
-                        'assistant_msg_idx': asst_idx,
+                        'assistant_msg_idx': asst_idx, 'args': args_snap,
                     })
             s.tool_calls = tool_calls
             # Tag the matching user message with attachment filenames for display on reload
@@ -215,7 +233,8 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
                             m['attachments'] = attachments
                             break
             s.save()
-            put('done', {'session': s.compact() | {'messages': s.messages, 'tool_calls': tool_calls}})
+            usage = {'input_tokens': input_tokens, 'output_tokens': output_tokens, 'estimated_cost': estimated_cost}
+            put('done', {'session': s.compact() | {'messages': s.messages, 'tool_calls': tool_calls}, 'usage': usage})
           finally:
             if old_cwd is None: os.environ.pop('TERMINAL_CWD', None)
             else: os.environ['TERMINAL_CWD'] = old_cwd