tycono 0.1.29 → 0.1.31

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 the-company-inc contributors
+Copyright (c) 2026 Tycono contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,6 +1,27 @@
-# tycono
+<p align="center">
+  <img src=".github/assets/hero-office.png" alt="Tycono — AI Office" width="640" />
+</p>
 
-> Build an AI company. Watch them work.
+<h1 align="center">tycono</h1>
+
+<p align="center">
+  <strong>Build an AI company. Watch them work.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/tycono"><img src="https://img.shields.io/npm/v/tycono.svg" alt="npm version" /></a>
+  <a href="https://github.com/seongsu-kang/tycono/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/tycono.svg" alt="license" /></a>
+  <a href="https://www.npmjs.com/package/tycono"><img src="https://img.shields.io/node/v/tycono.svg" alt="node version" /></a>
+</p>
+
+<p align="center">
+  <a href="https://tycono.ai">Website</a> &middot;
+  <a href="#quick-start">Quick Start</a> &middot;
+  <a href="#how-it-works">How It Works</a> &middot;
+  <a href="CONTRIBUTING.md">Contributing</a>
+</p>
+
+---
 
 **tycono** is an open-source platform that lets you create and run an AI-powered organization. Define roles (CTO, PM, Engineer...), assign them AI agents, and watch them collaborate through a real-time dashboard.
 
@@ -13,15 +34,29 @@ npx tycono
 
 That's it. A setup wizard guides you through creating your company, then your browser opens to a live dashboard showing your AI team at work.
 
+## Why Tycono?
+
+| | Single AI Agent | Tycono |
+|---|---|---|
+| **Structure** | One agent, one context | Multiple roles with org hierarchy |
+| **Knowledge** | Loses context between sessions | Persistent, file-based knowledge system (AKB) |
+| **Authority** | Can do anything | Scoped — each role has boundaries |
+| **Delegation** | Manual prompt chaining | Automatic dispatch through org chart |
+| **Visibility** | Terminal output | Real-time isometric office dashboard |
+
 ## What You Get
 
 - **Role-based AI agents** — Each role has its own persona, authority scope, and knowledge boundaries
 - **Org hierarchy** — Roles report to each other. CTO dispatches to Engineers. PM coordinates with Design.
-- **Real-time dashboard** — Watch your AI team work in an isometric office view
+- **Real-time dashboard** — Watch your AI team work in an isometric pixel-art office
 - **Knowledge management** — Automatic document routing, cross-linking, and Hub-based organization
 - **Local-first** — Everything runs on your machine. Your data stays yours.
 - **BYOK** — Bring your own Anthropic API key. No middleman.
 
+<p align="center">
+  <img src=".github/assets/sidepanel-chat.png" alt="Tycono Dashboard" width="640" />
+</p>
+
 ## Requirements
 
 - Node.js >= 18
@@ -29,14 +64,14 @@ That's it. A setup wizard guides you through creating your company, then your br
 
 ## Team Templates
 
-During setup, pick a template:
+During setup, pick a template or build your own:
 
-| Template | Roles |
-|----------|-------|
-| **Startup** | CTO + PM + Engineer |
-| **Research** | Lead Researcher + Analyst + Writer |
-| **Agency** | Creative Director + Designer + Developer |
-| **Custom** | Start with no roles, build your own |
+| Template | Roles | Best For |
+|----------|-------|----------|
+| **Startup** | CTO + PM + Engineer | Product development |
+| **Research** | Lead Researcher + Analyst + Writer | Analysis & reports |
+| **Agency** | Creative Director + Designer + Developer | Client projects |
+| **Custom** | Start empty, hire as you go | Full control |
 
 ## How It Works
 
@@ -54,25 +89,26 @@ Every role has:
 - `profile.md` — Public-facing description
 - `journal/` — Work history
 
-## Project Structure
+## Your Company Structure
 
 ```
 your-company/
-├── CLAUDE.md           ← AI entry point
+├── CLAUDE.md           ← AI entry point (auto-managed)
 ├── company/            ← Mission, vision, values
 ├── roles/              ← AI role definitions
 ├── projects/           ← Product specs and tasks
 ├── architecture/       ← Technical decisions
-├── operations/         ← Standups, decisions
-└── knowledge/          ← Domain knowledge
+├── operations/         ← Standups, decisions, waves
+├── knowledge/          ← Domain knowledge
+└── .tycono/            ← Config and preferences
 ```
 
 ## CLI Usage
 
 ```bash
-tycono              # Start server + open dashboard (setup wizard if first run)
-tycono --help        # Show help
-tycono --version     # Show version
+npx tycono              # Start server + open dashboard
+npx tycono --help       # Show help
+npx tycono --version    # Show version
 ```
 
 ## Environment Variables
@@ -103,10 +139,17 @@ npm run typecheck
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
+## Get Help
+
+- [GitHub Issues](https://github.com/seongsu-kang/tycono/issues) — Bug reports and feature requests
+- [GitHub Discussions](https://github.com/seongsu-kang/tycono/discussions) — Questions and ideas
+
 ## License
 
 [MIT](LICENSE)
 
 ---
 
-*Built with tycono. An AI company that builds itself.*
+<p align="center">
+  <sub>Built with tycono. An AI company that builds itself.</sub>
+</p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {
@@ -45,16 +45,20 @@
   },
   "keywords": [
     "ai",
+    "tycono",
     "company",
     "organization",
     "roles",
     "claude",
-    "agent"
+    "agent",
+    "multi-agent",
+    "agentic",
+    "local-first"
   ],
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/seongsu-kang/the-company.git"
+    "url": "git+https://github.com/seongsu-kang/tycono.git"
   },
-  "homepage": "https://github.com/seongsu-kang/the-company#readme"
+  "homepage": "https://github.com/seongsu-kang/tycono#readme"
 }

package/src/api/src/engine/runners/claude-cli.ts

@@ -163,8 +163,10 @@ export class ClaudeCliRunner implements ExecutionRunner {
       mcpServers: {
         playwright: {
           type: 'stdio',
-          command: '/Users/nodias/.local/bin/playwright-mcp.sh',
-          args: ['--output-dir', runnerOutputDir],
+          command: process.env.PLAYWRIGHT_MCP_PATH || 'npx',
+          args: process.env.PLAYWRIGHT_MCP_PATH
+            ? ['--output-dir', runnerOutputDir]
+            : ['@anthropic-ai/mcp-playwright', '--output-dir', runnerOutputDir],
         },
       },
     });

package/src/api/src/routes/execute.ts

@@ -83,6 +83,13 @@ function handleJobsRequest(url: string, method: string, req: IncomingMessage, re
     return;
   }
 
+  // Match /api/jobs/:id/reply
+  const replyMatch = path.match(/^\/api\/jobs\/([^/]+)\/reply$/);
+  if (replyMatch && method === 'POST') {
+    readBody(req).then((body) => handleReplyToJob(replyMatch[1], body, res));
+    return;
+  }
+
   // Match /api/jobs/:id/history
   const historyMatch = path.match(/^\/api\/jobs\/([^/]+)\/history$/);
   if (historyMatch && method === 'GET') {
@@ -213,8 +220,8 @@ function handleJobStream(jobId: string, fromSeq: number, req: IncomingMessage, r
     sendSSE(res, 'activity', event);
   }
 
-  // If the job is not running (or doesn't exist in memory), send end and close
-  if (!job || job.status !== 'running') {
+  // If the job is finished (not running/awaiting), send end and close
+  if (!job || (job.status !== 'running' && job.status !== 'awaiting_input')) {
     sendSSE(res, 'stream:end', { reason: job ? job.status : 'not-found' });
     res.end();
     return;
@@ -225,12 +232,13 @@ function handleJobStream(jobId: string, fromSeq: number, req: IncomingMessage, r
     if (event.seq >= fromSeq) {
       sendSSE(res, 'activity', event);
     }
-    // Auto-close SSE when job ends
+    // Auto-close SSE when job ends (done or error, NOT awaiting_input)
     if (event.type === 'job:done' || event.type === 'job:error') {
       sendSSE(res, 'stream:end', { reason: event.type === 'job:done' ? 'done' : 'error' });
       res.end();
       job.stream.unsubscribe(subscriber);
     }
+    // awaiting_input keeps SSE open (sends event but doesn't close)
   };
 
   job.stream.subscribe(subscriber);
@@ -263,6 +271,24 @@ function handleAbortJob(jobId: string, res: ServerResponse): void {
   jsonResponse(res, 200, { ok: true });
 }
 
+/* ─── POST /api/jobs/:id/reply ──────────── */
+
+function handleReplyToJob(jobId: string, body: Record<string, unknown>, res: ServerResponse): void {
+  const message = body.message as string;
+  if (!message) {
+    jsonResponse(res, 400, { error: 'message is required' });
+    return;
+  }
+
+  const newJob = jobManager.replyToJob(jobId, message);
+  if (!newJob) {
+    jsonResponse(res, 400, { error: 'Job not found or not awaiting input' });
+    return;
+  }
+
+  jsonResponse(res, 200, { jobId: newJob.id, roleId: newJob.roleId });
+}
+
 /* ═══════════════════════════════════════════════
    Legacy /api/exec/* — kept for backward compat
    Now internally delegates to JobManager where possible

package/src/api/src/routes/knowledge.ts

@@ -206,8 +206,8 @@ knowledgeRouter.put('/{*path}', (req: Request, res: Response, next: NextFunction
       return;
     }
 
-    const absPath = path.join(companyRoot(), docId);
-    if (!absPath.startsWith(companyRoot())) {
+    const absPath = path.resolve(companyRoot(), docId);
+    if (!absPath.startsWith(companyRoot() + path.sep) && absPath !== companyRoot()) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }
@@ -248,8 +248,8 @@ knowledgeRouter.delete('/{*path}', (req: Request, res: Response, next: NextFunct
       return;
     }
 
-    const absPath = path.join(companyRoot(), docId);
-    if (!absPath.startsWith(companyRoot())) {
+    const absPath = path.resolve(companyRoot(), docId);
+    if (!absPath.startsWith(companyRoot() + path.sep) && absPath !== companyRoot()) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }

package/src/api/src/routes/speech.ts

@@ -3,25 +3,187 @@
  *
  * POST /api/speech/chat — History-aware channel conversation.
  * AI reads channel history and responds in character.
- * Uses Haiku for cost efficiency (~$0.0006/call).
+ * Uses Haiku with AKB tool-use for grounded, context-aware chat.
  */
 import { Router, Request, Response, NextFunction } from 'express';
 import fs from 'node:fs';
 import path from 'node:path';
+import { glob } from 'glob';
 import { COMPANY_ROOT, readFile, fileExists, listFiles } from '../services/file-reader.js';
 import { buildOrgTree } from '../engine/index.js';
 import { parseMarkdownTable, extractBoldKeyValues } from '../services/markdown-parser.js';
-import { AnthropicProvider, ClaudeCliProvider, type LLMProvider } from '../engine/llm-adapter.js';
+import {
+  AnthropicProvider, ClaudeCliProvider,
+  type LLMProvider, type ToolDefinition, type LLMMessage, type LLMResponse, type MessageContent,
+} from '../engine/llm-adapter.js';
 import { TokenLedger } from '../services/token-ledger.js';
 import { readConfig } from '../services/company-config.js';
 import { calcLevel } from '../utils/role-level.js';
 
 export const speechRouter = Router();
 
+/* ══════════════════════════════════════════════════
+ * AKB Tools — Let chat roles explore company knowledge
+ * ══════════════════════════════════════════════════ */
+
+const MAX_TOOL_ROUNDS = 2;
+const MAX_FILE_CHARS = 1500; // truncate large files
+
+const AKB_TOOLS: ToolDefinition[] = [
+  {
+    name: 'search_akb',
+    description: 'Search the company knowledge base (AKB) for keywords. Returns matching file paths and snippets. Use to find decisions, journals, projects, waves, standups, or any company knowledge.',
+    input_schema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Search keywords (e.g. "landing deploy", "refactoring decision", "Store Import")' },
+        path: { type: 'string', description: 'Optional subdirectory to search in (e.g. "operations/decisions", "projects", "knowledge"). Defaults to entire AKB.' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'read_file',
+    description: 'Read a specific file from the AKB. Use after search_akb to read full content of interesting files.',
+    input_schema: {
+      type: 'object' as const,
+      properties: {
+        path: { type: 'string', description: 'File path relative to AKB root (e.g. "operations/decisions/008-repo-structure.md", "projects/projects.md")' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'list_files',
+    description: 'List files in a directory. Useful to discover what exists (e.g. "operations/waves/", "roles/engineer/journal/").',
+    input_schema: {
+      type: 'object' as const,
+      properties: {
+        path: { type: 'string', description: 'Directory path relative to AKB root (e.g. "operations/standups", "roles/pm/journal")' },
+        pattern: { type: 'string', description: 'Glob pattern (default: "*.md")' },
+      },
+      required: ['path'],
+    },
+  },
+];
+
+function executeAkbTool(name: string, input: Record<string, unknown>): string {
+  try {
+    switch (name) {
+      case 'search_akb': {
+        const query = String(input.query || '');
+        const searchPath = input.path ? String(input.path) : '';
+        const searchDir = path.resolve(COMPANY_ROOT, searchPath);
+
+        if (!fs.existsSync(searchDir)) return `Directory not found: ${searchPath || '/'}`;
+
+        // Find all .md files, then grep for query keywords
+        const mdFiles = glob.sync('**/*.md', { cwd: searchDir, nodir: true }).slice(0, 100);
+        const keywords = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const results: string[] = [];
+
+        for (const file of mdFiles) {
+          const fullPath = path.join(searchDir, file);
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          const lower = content.toLowerCase();
+          const matchCount = keywords.filter(k => lower.includes(k)).length;
+          if (matchCount >= Math.max(1, Math.ceil(keywords.length * 0.5))) {
+            // Extract a relevant snippet (first matching line + context)
+            const lines = content.split('\n');
+            let snippet = '';
+            for (let i = 0; i < lines.length; i++) {
+              const ll = lines[i].toLowerCase();
+              if (keywords.some(k => ll.includes(k))) {
+                snippet = lines.slice(Math.max(0, i - 1), i + 3).join('\n').slice(0, 200);
+                break;
+              }
+            }
+            const relPath = searchPath ? `${searchPath}/${file}` : file;
+            results.push(`📄 ${relPath} (${matchCount}/${keywords.length} keywords)\n${snippet}`);
+          }
+          if (results.length >= 8) break;
+        }
+
+        return results.length > 0
+          ? results.join('\n\n')
+          : `No results for "${query}" in ${searchPath || 'AKB'}`;
+      }
+
+      case 'read_file': {
+        const filePath = String(input.path || '');
+        const absolute = path.resolve(COMPANY_ROOT, filePath);
+        if (!fs.existsSync(absolute)) return `File not found: ${filePath}`;
+        const content = fs.readFileSync(absolute, 'utf-8');
+        return content.length > MAX_FILE_CHARS
+          ? content.slice(0, MAX_FILE_CHARS) + `\n\n... (truncated, ${content.length} chars total)`
+          : content;
+      }
+
+      case 'list_files': {
+        const dirPath = String(input.path || '');
+        const pat = String(input.pattern || '*.md');
+        const absolute = path.resolve(COMPANY_ROOT, dirPath);
+        if (!fs.existsSync(absolute)) return `Directory not found: ${dirPath}`;
+        const files = glob.sync(pat, { cwd: absolute, nodir: true }).sort();
+        return files.length > 0
+          ? files.map(f => `- ${dirPath}/${f}`).join('\n')
+          : `No files matching "${pat}" in ${dirPath}`;
+      }
+
+      default:
+        return `Unknown tool: ${name}`;
+    }
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+/**
+ * Run mini agent loop: LLM call → tool use → LLM call → ... → final text.
+ * Max MAX_TOOL_ROUNDS rounds of tool use, then force a text response.
+ */
+async function chatWithTools(
+  provider: LLMProvider,
+  systemPrompt: string,
+  initialMessages: LLMMessage[],
+  useTools: boolean,
+): Promise<{ text: string; totalUsage: { inputTokens: number; outputTokens: number } }> {
+  const messages: LLMMessage[] = [...initialMessages];
+  const totalUsage = { inputTokens: 0, outputTokens: 0 };
+  const tools = useTools ? AKB_TOOLS : undefined;
+
+  for (let round = 0; round <= MAX_TOOL_ROUNDS; round++) {
+    const response = await provider.chat(systemPrompt, messages, tools);
+    totalUsage.inputTokens += response.usage.inputTokens;
+    totalUsage.outputTokens += response.usage.outputTokens;
+
+    // Check if there are tool calls
+    const toolCalls = response.content.filter(c => c.type === 'tool_use');
+    const textParts = response.content.filter(c => c.type === 'text').map(c => (c as { type: 'text'; text: string }).text);
+
+    if (toolCalls.length === 0 || round === MAX_TOOL_ROUNDS) {
+      // No tool calls or max rounds reached — return text
+      return { text: textParts.join('').trim(), totalUsage };
+    }
+
+    // Execute tool calls and build tool results
+    messages.push({ role: 'assistant', content: response.content });
+
+    const toolResults: MessageContent[] = toolCalls.map(tc => {
+      const call = tc as { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> };
+      const result = executeAkbTool(call.name, call.input);
+      return { type: 'tool_result' as any, tool_use_id: call.id, content: result } as any;
+    });
+
+    messages.push({ role: 'user', content: toolResults });
+  }
+
+  return { text: '', totalUsage };
+}
+
 /**
  * Build a compact company context for chat system prompts.
- * Includes: company info, org overview, projects, knowledge highlights.
- * Kept brief to minimize Haiku token cost.
+ * Provides a seed overview — the agent can dig deeper via AKB tools.
  */
 function buildCompanyContext(): string {
   const parts: string[] = [];
@@ -316,10 +478,27 @@ ${relContext}
 
 ${roleStyle}
 
+AKB EXPLORATION (IMPORTANT):
+You have tools to search and read the company knowledge base (AKB). Use them to ground your conversation in REAL company context.
+Before responding, consider: "Is there something in our AKB that relates to this conversation?"
+- search_akb: Search for keywords across the AKB (decisions, projects, journals, waves, standups)
+- read_file: Read a specific file for details
+- list_files: Discover what files exist in a directory
+
+Useful paths to explore:
+- operations/decisions/ — CEO decisions (what was decided and why)
+- operations/waves/ — Work dispatches (what CEO asked teams to do)
+- operations/standups/ — Daily standups (what everyone reported)
+- projects/ — Active projects and their tasks
+- roles/${roleId}/journal/ — Your own work journal
+- knowledge/ — Domain knowledge
+
+You don't need to search every time. But when the conversation touches on company work, decisions, or direction, DO search to find real facts rather than making up generic discussion.
+
 CONVERSATION RULES:
 1. Stay deeply in character — your expertise, vocabulary, and concerns should be DISTINCT from other roles.
 2. Keep it to 1-3 sentences. No walls of text.
-3. Be SPECIFIC. Reference actual projects, files, tools, metrics, or decisions — never vague platitudes.
+3. Be SPECIFIC. Reference actual projects, files, tools, metrics, or decisions from the AKB — never vague platitudes.
 4. Do NOT just agree with everyone. Real teams have different perspectives:
    - If you genuinely disagree, say so (respectfully but firmly)
    - If someone oversimplifies your domain, push back with specifics
@@ -340,39 +519,40 @@ ANTI-PATTERNS (never do these):
 - Using the same emoji pattern as the previous speaker
 - Restating the consensus without adding anything new
 - Meta-commentary about the conversation itself ("wow we actually agreed")
-- Generic statements that any role could say — speak from YOUR expertise`;
+- Generic statements that any role could say — speak from YOUR expertise
+- Talking about vague "refactoring" or "metrics" without referencing actual company work`;
 
     const provider = getLLM();
-    const response = await provider.chat(
+
+    // Use tool-based agent loop (AnthropicProvider supports tools; ClaudeCliProvider falls back to no-tools)
+    const useTools = provider instanceof AnthropicProvider;
+    const { text: raw, totalUsage } = await chatWithTools(
+      provider,
       systemPrompt,
       [{ role: 'user', content: historyText }],
+      useTools,
     );
 
-    const raw = response.content
-      .filter(c => c.type === 'text')
-      .map(c => (c as { type: 'text'; text: string }).text)
-      .join('')
-      .trim()
-      .replace(/^["']|["']$/g, '');
+    const cleaned = raw.replace(/^["']|["']$/g, '');
 
     // Filter out CLI noise and [SILENT]
-    const message = (raw === '[SILENT]' || raw.startsWith('Error: Reached max turns')) ? '' : raw;
+    const message = (cleaned === '[SILENT]' || cleaned.startsWith('Error: Reached max turns') || !cleaned) ? '' : cleaned;
 
     // Record usage in token ledger (category: chat)
-    if (response.usage) {
+    if (totalUsage) {
       getLedger().record({
         ts: new Date().toISOString(),
         jobId: `chat-${channelId}`,
         roleId,
         model: process.env.SPEECH_MODEL || 'claude-haiku-4-5-20251001',
-        inputTokens: response.usage.inputTokens ?? 0,
-        outputTokens: response.usage.outputTokens ?? 0,
+        inputTokens: totalUsage.inputTokens ?? 0,
+        outputTokens: totalUsage.outputTokens ?? 0,
       });
     }
 
     res.json({
       message,
-      tokens: response.usage,
+      tokens: totalUsage,
     });
   } catch (err) {
     next(err);

package/src/api/src/services/activity-stream.ts

@@ -6,6 +6,7 @@ import { COMPANY_ROOT } from './file-reader.js';
 
 export type ActivityEventType =
   | 'job:start' | 'job:done' | 'job:error'
+  | 'job:awaiting_input' | 'job:reply'
   | 'text' | 'thinking'
   | 'tool:start' | 'tool:result'
   | 'dispatch:start' | 'dispatch:done'