tycono 0.1.65 → 0.1.66

package/bin/tycono.ts

@@ -19,10 +19,15 @@ function printHelp(): void {
   Build an AI company. Watch them work.
 
   Usage:
-    tycono              Start the server and open dashboard
+    tycono [path]       Start the server (optionally point to a company directory)
     tycono --help       Show this help message
     tycono --version    Show version
 
+  Examples:
+    tycono                      Start in current directory
+    tycono ./my-company         Start with existing company folder
+    tycono /path/to/akb         Start with absolute path
+
   AI Engine (auto-detected):
     1. Claude Code CLI       Install from https://claude.ai/download (recommended)
     2. ANTHROPIC_API_KEY     Set in .env for direct API mode (BYOK)
@@ -199,9 +204,13 @@ export async function main(args: string[]): Promise<void> {
   }
 
   if (command && !command.startsWith('-')) {
-    console.error(`  Unknown command: ${command}`);
-    printHelp();
-    process.exit(1);
+    // Treat as path to company directory
+    const resolved = path.resolve(command);
+    if (!fs.existsSync(resolved)) {
+      console.error(`  Path not found: ${resolved}`);
+      process.exit(1);
+    }
+    process.env.COMPANY_ROOT = resolved;
   }
 
   await startServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/create-server.ts

@@ -30,6 +30,8 @@ import { syncRouter } from './routes/sync.js';
 import { gitRouter } from './routes/git.js';
 import { skillsRouter } from './routes/skills.js';
 import { questsRouter } from './routes/quests.js';
+import { coinsRouter } from './routes/coins.js';
+import { activeSessionsRouter } from './routes/active-sessions.js';
 import { importKnowledge } from './services/knowledge-importer.js';
 import { AnthropicProvider, type LLMProvider } from './engine/llm-adapter.js';
 import { readConfig } from './services/company-config.js';
@@ -117,7 +119,7 @@ export function createHttpServer(): http.Server {
     const method = req.method ?? '';
 
     // SSE 엔드포인트: Express 우회하여 raw HTTP로 처리
-    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs') || url === '/api/setup/import-knowledge') && method === 'POST') {
+    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs') || url === '/api/waves/save' || url === '/api/setup/import-knowledge') && method === 'POST') {
       setExecCors(req, res);
       if (url === '/api/setup/import-knowledge') {
         handleImportKnowledge(req, res);
@@ -197,6 +199,8 @@ export function createExpressApp(): express.Application {
   app.use('/api/git', gitRouter);
   app.use('/api/skills', skillsRouter);
   app.use('/api/quests', questsRouter);
+  app.use('/api/coins', coinsRouter);
+  app.use('/api/active-sessions', activeSessionsRouter);
 
   app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', companyRoot: COMPANY_ROOT });

package/src/api/src/engine/agent-loop.ts

@@ -26,6 +26,7 @@ export interface AgentConfig {
   model?: string;             // LLM model name for cost tracking
   tokenLedger?: TokenLedger;  // Token usage ledger (optional)
   attachments?: ImageAttachment[];  // Image attachments for vision
+  targetRoles?: string[];          // Selective dispatch scope
   // Callbacks
   onText?: (text: string) => void;
   onToolExec?: (name: string, input: Record<string, unknown>) => void;
@@ -82,7 +83,7 @@ export async function runAgentLoop(config: AgentConfig): Promise<AgentResult> {
   const llm = config.llm ?? new AnthropicProvider();
 
   // 1. Assemble context
-  const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus: config.teamStatus });
+  const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus: config.teamStatus, targetRoles: config.targetRoles });
 
   // 2. Determine tools
   const subordinates = getSubordinates(orgTree, roleId);
@@ -299,16 +300,25 @@ export async function runAgentLoop(config: AgentConfig): Promise<AgentResult> {
         `${i + 1}. **${d.roleId}**: "${d.task.slice(0, 80)}"\n   Result: ${d.result.slice(0, 300)}`,
       ).join('\n\n');
 
+      // Build list of already-dispatched tasks to prevent re-dispatch
+      const dispatchedList = dispatches.map(d => `- ${d.roleId}: "${d.task.slice(0, 100)}"`).join('\n');
+
       const supervisionPrompt = [
         '[SUPERVISION LOOP] Your subordinates have completed their tasks. Follow the C-Level Protocol:',
         '',
         '## Subordinate Results',
         dispatchSummary,
         '',
+        '## Already Dispatched (DO NOT re-dispatch these)',
+        dispatchedList,
+        '',
+        '⛔ **Do NOT re-dispatch the same or similar task to the same role.** If a subordinate already completed a task, accept the result and move on.',
+        '⛔ **If the result is satisfactory, do NOT dispatch again.** Only re-dispatch if the result clearly fails acceptance criteria with SPECIFIC feedback on what to fix.',
+        '',
         '## Required Actions (do ALL of these):',
         '',
         '### 1. Review',
-        'Does each result meet the acceptance criteria? If not, re-dispatch with specific feedback.',
+        'Does each result meet the acceptance criteria? If clearly unsatisfactory, re-dispatch with SPECIFIC fix instructions (not the same task again).',
         '',
         '### 2. Knowledge Update (The Loop Step ④)',
         'Record any new decisions, findings, or analysis in appropriate AKB documents:',
@@ -320,10 +330,11 @@ export async function runAgentLoop(config: AgentConfig): Promise<AgentResult> {
         'Update task status in the relevant tasks.md or project documents.',
         'Mark completed items as DONE. Identify the NEXT task to dispatch.',
         '',
-        '### 4. Next Dispatch',
-        'If there are remaining tasks (e.g., QA after Engineer, or the next task in the backlog):',
-        '- Dispatch the next task to the appropriate subordinate',
-        '- If all work is done, synthesize a final report for your superior',
+        '### 4. Next Dispatch (ONLY if there is genuinely NEW work)',
+        'If there are DIFFERENT remaining tasks (e.g., QA after Engineer, or a DIFFERENT backlog item):',
+        '- Dispatch the NEXT DIFFERENT task to the appropriate subordinate',
+        '- If all work from the directive is done, synthesize a final report for your superior',
+        '- **If the subordinate already completed the requested work, report success — do NOT re-dispatch**',
         '',
         'Execute these actions now using your tools (Read, Edit, Bash, dispatch).',
       ].join('\n');

package/src/api/src/engine/context-assembler.ts

@@ -10,6 +10,7 @@ import {
   formatOrgChart,
   canConsult,
 } from './org-tree.js';
+import { extractKeywords, searchRelatedDocs } from './knowledge-gate.js';
 
 /* ─── Types ──────────────────────────────────── */
 
@@ -49,7 +50,7 @@ export function assembleContext(
   task: string,
   sourceRole: string,
   orgTree: OrgTree,
-  options?: { teamStatus?: TeamStatus },
+  options?: { teamStatus?: TeamStatus; targetRoles?: string[] },
 ): AssembledContext {
   const node = orgTree.nodes.get(roleId);
   if (!node) {
@@ -103,11 +104,34 @@ export function assembleContext(
   // 9. Code Root (코드 프로젝트 경로)
   const config = readConfig(companyRoot);
   if (config.codeRoot) {
-    sections.push(`# Code Project\n\nThe code repository is located at: \`${config.codeRoot}\`\nUse this path when working with source code (reading, writing, building, testing).`);
+    sections.push(`# Code Project
+
+The code repository is located at: \`${config.codeRoot}\` (env: $TYCONO_CODE_ROOT)
+The AKB (knowledge) directory is at: \`${companyRoot}\` (env: $TYCONO_AKB_ROOT)
+
+Use the code repository path for all source code work (reading, writing, building, testing).
+
+## Git Worktree Rules (CRITICAL)
+- Your cwd is already set to the code repository. When creating worktrees, use relative paths or \`$TYCONO_CODE_ROOT\`.
+- **NEVER run \`git worktree add\` in \`$TYCONO_AKB_ROOT\`** — the AKB directory is not a code repository.
+- Recommended worktree path: \`$TYCONO_CODE_ROOT/.worktrees/{branch-name}\`
+- Example: \`git worktree add .worktrees/feature-xyz -b feature/xyz\` (from cwd, which is already code repo)`);
+  }
+
+  // 10. Pre-Knowledging: 작업 관련 문서 자동 탐색
+  const preKSection = buildPreKnowledgingSection(companyRoot, task);
+  if (preKSection) {
+    sections.push(preKSection);
   }
 
-  // 10. Task는 별도 필드로 분리
-  const subordinates = getSubordinates(orgTree, roleId);
+  // Task는 별도 필드로 분리
+  let subordinates = getSubordinates(orgTree, roleId);
+
+  // Filter subordinates by targetRoles ONLY for CEO (wave dispatch scope)
+  // C-Level roles should always see their own subordinates regardless of targetRoles
+  if (options?.targetRoles && options.targetRoles.length > 0 && roleId === 'ceo') {
+    subordinates = subordinates.filter(id => options.targetRoles!.includes(id));
+  }
 
   // Dispatch 도구 안내 (하위 Role이 있는 경우)
   if (subordinates.length > 0) {
@@ -163,7 +187,20 @@ export function assembleContext(
 
 ## Output
 - Always produce a concrete deliverable: code change, report, analysis, or clear status update.
-- End with a brief summary of what you did and any unresolved items.`);
+- End with a brief summary of what you did and any unresolved items.
+
+## Sub-task Efficiency (when dispatched by a superior)
+- Focus ONLY on the assigned task — nothing else.
+- Do NOT update journals, knowledge docs, or tasks.md — your superior handles that.
+- Do NOT read CLAUDE.md or explore unrelated files — go straight to the target file.
+- If tsc/tests fail, fix the specific error. Do NOT refactor surrounding code.
+
+## Commit Rule (when you modify code files)
+- After completing code changes, you MUST commit your work.
+- Use a descriptive commit message: \`git commit -m "type(scope): description"\`
+- Common types: feat, fix, refactor, test, chore
+- This ensures your work is not lost in uncommitted changes.
+- Do NOT push — just commit locally. Your superior or the system handles push/PR.`);
 
   const systemPrompt = sections.join('\n\n---\n\n');
 
@@ -183,6 +220,27 @@ export function assembleContext(
 
 /* ─── Section Builders ───────────────────────── */
 
+function buildPreKnowledgingSection(companyRoot: string, task: string): string | null {
+  // Extract keywords from the task directive
+  const keywords = extractKeywords(task);
+  if (keywords.length < 2) return null; // Too few keywords to be meaningful
+
+  const related = searchRelatedDocs(companyRoot, keywords);
+  if (related.length === 0) return null;
+
+  const docList = related
+    .map(doc => `- \`${doc.path}\` — ${doc.preview} (relevance: ${doc.matches})`)
+    .join('\n');
+
+  return `# 📚 Pre-Knowledging: Related Documents
+
+The following existing documents are related to this task. **Read relevant ones before starting work** to avoid duplicating knowledge or missing existing context.
+
+${docList}
+
+> **Knowledging Rule**: Check these documents first. If your work produces new knowledge, update existing docs or create new ones with cross-links.`;
+}
+
 function loadCompanyRules(companyRoot: string): string | null {
   const parts: string[] = [];
 
@@ -443,40 +501,48 @@ ${subInfo}
 
 ## How to Dispatch
 
-**Use Bash to run the dispatch command:**
+**Dispatch is async: start a job → poll for result → review → next task.**
 
 \`\`\`bash
-# Start a job (returns immediately with job ID)
+# Step 1: Dispatch (returns immediately with job ID)
 python3 "$DISPATCH_CMD" ${exampleSubId} "Task description here"
 
-# Check job status/result later
+# Step 2: Poll for result (repeat every 10-30s until DONE)
 python3 "$DISPATCH_CMD" --check <jobId>
-
-# Start and wait for result (blocks up to 90s)
-python3 "$DISPATCH_CMD" --wait ${exampleSubId} "Task description here"
 \`\`\`
 
-**IMPORTANT**: Always use \`python3 "$DISPATCH_CMD"\` — this is the ONLY way to dispatch tasks to subordinates.
-
-### Recommended Pattern: Parallel Dispatch
+⛔ **NEVER use the Agent tool or Task tool to spawn sub-agents.** Those bypass the job tracking system. Use ONLY the dispatch command.
 
-For multiple tasks, dispatch all at once, then check results:
+### The Pattern: Dispatch → Poll → Review → Next
 
 \`\`\`bash
-# 1. Dispatch all tasks (each returns immediately)
+# 1. Dispatch first task (returns job ID immediately)
 python3 "$DISPATCH_CMD" ${exampleSubId} "Task A"
+# Output includes: Job ID: job-xxx
+
+# 2. Poll for result (repeat until status is DONE)
+python3 "$DISPATCH_CMD" --check job-xxx
+# If RUNNING → wait 10-30s → --check again
+# If DONE → read the result → proceed to next task
+
+# 3. Dispatch next task
 python3 "$DISPATCH_CMD" ${subordinates.length > 1 ? subordinates[1] : exampleSubId} "Task B"
+python3 "$DISPATCH_CMD" --check job-yyy
+# ... repeat
 
-# 2. Check results later (use the Job IDs from step 1)
-python3 "$DISPATCH_CMD" --check <jobId-A>
-python3 "$DISPATCH_CMD" --check <jobId-B>
+# 4. Continue until ALL tasks are done
 \`\`\`
 
-### Status Values
-- **running** — Subordinate is working
-- **done** — Task completed, result available
-- **error** — Task failed
-- **awaiting_input** — Subordinate has a question for you`;
+### --check Status Values
+- **RUNNING** — Subordinate still working → poll again in 10-30s
+- **DONE** — Task completed, result is printed
+- **ERROR** — Task failed (re-dispatch with different instructions or report)
+- **AWAITING_INPUT** — Subordinate has a question for you
+
+### ⛔ CRITICAL Rules
+- **NEVER re-dispatch the same task.** If --check shows RUNNING, just keep polling.
+- **NEVER dispatch and immediately finish.** The dispatch→check→review loop must continue until ALL work is complete.
+- **Save the job ID** from each dispatch to use with --check.`;
 
   // C-level roles get mandatory delegation rules
   if (isCLevel) {
@@ -492,9 +558,10 @@ python3 "$DISPATCH_CMD" --check <jobId-B>
 When you receive a directive:
 1. **Analyze** — Break it into sub-tasks appropriate for each subordinate
 2. **Dispatch** — Assign tasks to subordinates with clear acceptance criteria
-3. **Monitor** — Wait for results, review quality
-4. **Follow up** — If output doesn't meet criteria, dispatch back with feedback
-5. **Report** — Synthesize results and report to your superior
+3. **Monitor** — Poll for results, review quality
+4. **Verify** — Check git status: did subordinate commit? What files changed?
+5. **Follow up** — If output doesn't meet criteria, dispatch back with feedback
+6. **Report** — Synthesize results with change summary (files, commits, branch)
 
 ### What You Do vs What Subordinates Do
 
@@ -506,36 +573,54 @@ When you receive a directive:
 | Update knowledge & tasks | Update their own journals |
 | Report to superior | Report to you |
 
-### The Supervision Loop (CRITICAL)
+### The Supervision Loop (CRITICAL — DO NOT SKIP)
 
-After dispatching tasks, follow this loop:
+⛔ **You MUST keep running until ALL planned tasks are dispatched, reviewed, and completed.**
+⛔ **NEVER dispatch once and stop. That leaves work half-done.**
 
+The loop:
 \`\`\`
-DISPATCH ALL → CHECK RESULTS → REVIEW → DECIDE
-                                          ├── PASS → Knowledge Update → Task Update → Next Dispatch
-                                          └── FAIL → Re-dispatch with feedback
+PLAN TASKS → DISPATCH → POLL (--check) → REVIEW RESULT → DECIDE
+                                                           ├── PASS → Next DIFFERENT Task
+                                                           └── FAIL → Re-dispatch with SPECIFIC fix
+                                                           └── ALL DONE → Update knowledge → Report
 \`\`\`
 
-**Step 1: Dispatch all tasks** (fire-and-forget, collect job IDs)
-\`\`\`bash
-python3 "$DISPATCH_CMD" engineer "Task A"   # → job-xxx
-python3 "$DISPATCH_CMD" designer "Task B"   # → job-yyy
-\`\`\`
+### ⛔ CRITICAL: No Duplicate Dispatch
 
-**Step 2: Check results** (after waiting, use --check with saved job IDs)
+**NEVER dispatch the same or similar task to the same role twice.**
+- If --check shows RUNNING, keep polling — do NOT re-dispatch
+- If a subordinate completed a task, accept the result — do NOT re-dispatch
+- If the result is unsatisfactory, re-dispatch with SPECIFIC different instructions
+- Track dispatched job IDs — never repeat the same task
+- After 2 dispatches to the same role, accept the result or report to CEO
+
+**Example: Full supervision session**
 \`\`\`bash
-python3 "$DISPATCH_CMD" --check <job-xxx>
-python3 "$DISPATCH_CMD" --check <job-yyy>
+# Task 1: Dispatch to engineer
+python3 "$DISPATCH_CMD" engineer "Implement feature X. Read tasks.md first."
+# → Job ID: job-001
+
+# Poll until done
+python3 "$DISPATCH_CMD" --check job-001
+# → Status: RUNNING — check again in 10-30s
+python3 "$DISPATCH_CMD" --check job-001
+# → Status: DONE (result printed)
+
+# Review result... looks good. Task 2 (QA):
+python3 "$DISPATCH_CMD" qa "Test feature X that engineer just implemented."
+# → Job ID: job-002
+python3 "$DISPATCH_CMD" --check job-002
+# → Status: DONE — found bugs
+
+# Re-dispatch with SPECIFIC fix:
+python3 "$DISPATCH_CMD" engineer "Fix BUG: null check missing in auth.ts line 42"
+# → Job ID: job-003
+python3 "$DISPATCH_CMD" --check job-003
+# → Status: DONE — all good. Update knowledge and report.
 \`\`\`
 
-**Step 3-4: Review → Knowledge Update → Task Update → Next Dispatch**
-1. **Review**: Does the output meet acceptance criteria?
-2. **Knowledge Update**: Record decisions, findings, analysis in AKB (journals, knowledge/)
-3. **Task Update**: Update task status in tasks.md or project docs
-4. **Next Dispatch**: Identify and dispatch the next task
-
 ⚠️ Do NOT use curl or other methods to create jobs — always use the dispatch command.
-⚠️ Do NOT use sleep loops to wait — use --check to poll for results.
 
 ### Dispatch Quality Requirements
 
@@ -547,12 +632,35 @@ Every dispatch MUST include:
 
 ### Anti-Patterns (NEVER do these)
 
+- ❌ **Dispatching once and stopping** — you MUST keep working until directive is complete
+- ❌ **Dispatching and NOT polling with --check** — you must poll for results
+- ❌ **Re-dispatching when --check shows RUNNING** — just poll again
 - ❌ Writing code yourself instead of dispatching to engineer
 - ❌ Dispatching without acceptance criteria
 - ❌ Accepting output without reviewing it
 - ❌ Forgetting to update knowledge/tasks after work completes
 - ❌ Doing only 1 dispatch when you should chain multiple (Engineer → QA)
-- ❌ Reporting to superior without synthesizing subordinate outputs`;
+- ❌ Reporting to superior without synthesizing subordinate outputs
+
+### Post-Dispatch Verification (CRITICAL)
+
+After a subordinate completes a code task, you MUST verify the work is preserved:
+
+\`\`\`bash
+# 1. Check if subordinate committed their work
+git log --oneline -3
+
+# 2. If NOT committed (changes are unstaged), commit on their behalf
+git add -A && git commit -m "feat(scope): description of subordinate's work"
+
+# 3. Include in your report to CEO:
+#    - What files were changed
+#    - Commit hash (if committed)
+#    - Whether the changes compile (tsc --noEmit)
+\`\`\`
+
+⛔ **Uncommitted work = lost work.** If the subordinate didn't commit, YOU must commit before reporting.
+Your final report MUST include a **Change Summary** with files changed and commit status.`;
   } else {
     section += `