tycono 0.1.26 → 0.1.28

package/package.json

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

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

@@ -32,6 +32,7 @@ import { skillsRouter } from './routes/skills.js';
 import { importKnowledge } from './services/knowledge-importer.js';
 import { AnthropicProvider, type LLMProvider } from './engine/llm-adapter.js';
 import { readConfig } from './services/company-config.js';
+import { ensureClaudeMd } from './services/claude-md-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -102,7 +103,11 @@ function handleImportKnowledge(req: http.IncomingMessage, res: http.ServerRespon
 }
 
 export function createHttpServer(): http.Server {
-  cleanupStaleActivities();
+  // Only cleanup/ensure if a company is already initialized (avoid creating dirs in CWD)
+  if (COMPANY_ROOT && fs.existsSync(path.join(COMPANY_ROOT, 'CLAUDE.md'))) {
+    cleanupStaleActivities();
+    ensureClaudeMd(COMPANY_ROOT);
+  }
 
   const app = createExpressApp();
 
@@ -166,8 +171,9 @@ export function createExpressApp(): express.Application {
     let companyName: string | null = null;
     if (initialized) {
       try {
-        const claudeMdPath = path.join(COMPANY_ROOT, 'CLAUDE.md');
-        const content = fs.readFileSync(claudeMdPath, 'utf-8');
+        // Read company name from company/company.md (user-owned data)
+        const companyMdPath = path.join(COMPANY_ROOT, 'company', 'company.md');
+        const content = fs.readFileSync(companyMdPath, 'utf-8');
         const match = content.match(/^#\s+(.+)/m);
         if (match) companyName = match[1].trim();
       } catch { /* ignore */ }

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

@@ -164,14 +164,33 @@ export function assembleContext(
 /* ─── Section Builders ───────────────────────── */
 
 function loadCompanyRules(companyRoot: string): string | null {
+  const parts: string[] = [];
+
+  // 1. System rules (CLAUDE.md — Tycono managed)
   const claudeMdPath = path.join(companyRoot, 'CLAUDE.md');
-  if (!fs.existsSync(claudeMdPath)) return null;
+  if (fs.existsSync(claudeMdPath)) {
+    parts.push(fs.readFileSync(claudeMdPath, 'utf-8'));
+  }
+
+  // 2. User custom rules (.tycono/custom-rules.md — user owned)
+  const customPath = path.join(companyRoot, '.tycono', 'custom-rules.md');
+  if (fs.existsSync(customPath)) {
+    const custom = fs.readFileSync(customPath, 'utf-8').trim();
+    if (custom) {
+      parts.push('---\n\n## Company Custom Rules\n\n' + custom);
+    }
+  }
+
+  // 3. Company info (company/company.md — user owned)
+  const companyMdPath = path.join(companyRoot, 'company', 'company.md');
+  if (fs.existsSync(companyMdPath)) {
+    const companyInfo = fs.readFileSync(companyMdPath, 'utf-8').trim();
+    if (companyInfo) {
+      parts.push('---\n\n## Company Info\n\n' + companyInfo);
+    }
+  }
 
-  // Give the full CLAUDE.md — it contains the routing table, folder structure,
-  // Hub-first principle, and other navigation info that roles need to work effectively.
-  // Previously we extracted only AKB + Git rules, but that stripped out the most
-  // practically useful parts (routing table, folder structure, skill principle).
-  return fs.readFileSync(claudeMdPath, 'utf-8');
+  return parts.length > 0 ? parts.join('\n\n') : null;
 }
 
 function buildOrgContextSection(orgTree: OrgTree, node: OrgNode): string {

package/src/api/src/engine/role-lifecycle.ts

@@ -99,9 +99,6 @@ export class RoleLifecycleManager {
 
     // 5. Update roles.md Hub
     this.addToRolesHub(def);
-
-    // 6. Update CLAUDE.md org table
-    this.addToClaudeMdOrgTable(def);
   }
 
   /**
@@ -160,8 +157,6 @@ export class RoleLifecycleManager {
 
     // Remove from roles.md Hub
     this.removeFromRolesHub(id);
-    // Remove from CLAUDE.md org table
-    this.removeFromClaudeMdOrgTable(id);
   }
 
   /**
@@ -337,25 +332,6 @@ ${def.authority.needsApproval.map((a) => `- ${a}`).join('\n')}
     fs.writeFileSync(hubPath, updatedContent);
   }
 
-  private addToClaudeMdOrgTable(def: RoleDefinition): void {
-    const claudeMdPath = path.join(this.companyRoot, 'CLAUDE.md');
-    if (!fs.existsSync(claudeMdPath)) return;
-
-    const content = fs.readFileSync(claudeMdPath, 'utf-8');
-    if (content.includes(`| **${def.name}**`)) {
-      return; // Already exists
-    }
-
-    const row = `| **${def.name}** | AI (${def.id}) | ${def.level} | ${def.reportsTo.toUpperCase()} | Active |`;
-
-    const orgSectionMatch = content.match(/## (?:조직|Organization)[\s\S]*?\n(\|[^\n]*\n)+/);
-    if (orgSectionMatch) {
-      const insertPos = (orgSectionMatch.index ?? 0) + orgSectionMatch[0].length;
-      const updated = content.slice(0, insertPos) + row + '\n' + content.slice(insertPos);
-      fs.writeFileSync(claudeMdPath, updated);
-    }
-  }
-
   private removeFromRolesHub(id: string): void {
     const hubPath = path.join(this.companyRoot, 'roles', 'roles.md');
     if (!fs.existsSync(hubPath)) return;
@@ -369,16 +345,6 @@ ${def.authority.needsApproval.map((a) => `- ${a}`).join('\n')}
     fs.writeFileSync(hubPath, lines.join('\n'));
   }
 
-  private removeFromClaudeMdOrgTable(id: string): void {
-    const claudeMdPath = path.join(this.companyRoot, 'CLAUDE.md');
-    if (!fs.existsSync(claudeMdPath)) return;
-
-    const content = fs.readFileSync(claudeMdPath, 'utf-8');
-    const lines = content.split('\n').filter((line) => {
-      return !line.includes(`(${id})`) || !line.startsWith('|');
-    });
-    fs.writeFileSync(claudeMdPath, lines.join('\n'));
-  }
 }
 
 /* ─── Helpers ──────────────────────────────── */

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

@@ -13,8 +13,8 @@ import { COMPANY_ROOT } from '../services/file-reader.js';
 
 export const knowledgeRouter = Router();
 
-const knowledgeDir = path.join(COMPANY_ROOT, 'knowledge');
-const companyRoot = COMPANY_ROOT;
+function knowledgeDir(): string { return path.join(COMPANY_ROOT, 'knowledge'); }
+function companyRoot(): string { return COMPANY_ROOT; }
 
 /* ─── Helpers ─────────────────────────────────────── */
 
@@ -61,13 +61,13 @@ function inferCategory(filePath: string, tags: string[]): string {
 
 knowledgeRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
   try {
-    if (!fs.existsSync(companyRoot)) {
+    if (!fs.existsSync(companyRoot())) {
       res.json([]);
       return;
     }
 
     const files = glob.sync('**/*.{md,html}', {
-      cwd: companyRoot,
+      cwd: companyRoot(),
       ignore: [
         'node_modules/**', '.claude/**', '.obsidian/**', '.tycono/**', '.git/**',
         '**/node_modules/**',
@@ -82,7 +82,7 @@ knowledgeRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
       .sort();
 
     const docs = files.map((f) => {
-      const absPath = path.join(companyRoot, f);
+      const absPath = path.join(companyRoot(), f);
       let raw = '';
       try { raw = fs.readFileSync(absPath, 'utf-8'); } catch { return null; }
 
@@ -165,9 +165,9 @@ knowledgeRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
     // Sanitize filename
     const safeName = filename.replace(/[^a-zA-Z0-9가-힣_\-. ]/g, '').replace(/\s+/g, '-');
     const fullName = safeName.endsWith('.md') ? safeName : `${safeName}.md`;
-    const absPath = path.join(knowledgeDir, fullName);
+    const absPath = path.join(knowledgeDir(), fullName);
 
-    if (!absPath.startsWith(knowledgeDir)) {
+    if (!absPath.startsWith(knowledgeDir())) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }
@@ -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.join(companyRoot(), docId);
+    if (!absPath.startsWith(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.join(companyRoot(), docId);
+    if (!absPath.startsWith(companyRoot())) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }
@@ -277,10 +277,10 @@ knowledgeRouter.get('/{*path}', (req: Request, res: Response, next: NextFunction
       return;
     }
 
-    const absPath = path.join(knowledgeDir, docId);
+    const absPath = path.join(knowledgeDir(), docId);
 
     // Security: ensure path stays within knowledgeDir
-    if (!absPath.startsWith(knowledgeDir)) {
+    if (!absPath.startsWith(knowledgeDir())) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }

package/src/api/src/routes/setup.ts

@@ -16,6 +16,7 @@ import { AnthropicProvider, type LLMProvider } from '../engine/llm-adapter.js';
 import { jobManager } from '../services/job-manager.js';
 import { applyConfig, readConfig, writeConfig } from '../services/company-config.js';
 import { mergePreferences } from '../services/preferences.js';
+import { setCompanyRoot } from '../services/file-reader.js';
 
 export const setupRouter = Router();
 
@@ -122,7 +123,7 @@ setupRouter.post('/scaffold', (req, res) => {
   try {
     const created = scaffold(config);
 
-    process.env.COMPANY_ROOT = projectRoot;
+    setCompanyRoot(projectRoot);
     // Load config.json written by scaffold and apply to process.env
     const scaffoldConfig = applyConfig(projectRoot);
     // Save codeRoot if provided
@@ -217,7 +218,7 @@ setupRouter.post('/connect-akb', (req, res) => {
     if (match) companyName = match[1].trim();
   } catch { /* ignore */ }
 
-  process.env.COMPANY_ROOT = resolved;
+  setCompanyRoot(resolved);
 
   // Load existing config.json if present
   const config = readConfig(resolved);

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

@@ -24,16 +24,19 @@ export interface ActivityEvent {
 
 /* ─── Constants ──────────────────────────── */
 
-const STREAMS_DIR = path.join(COMPANY_ROOT, 'operations', 'activity-streams');
+function streamsDir(): string {
+  return path.join(COMPANY_ROOT, 'operations', 'activity-streams');
+}
 
 function ensureDir(): void {
-  if (!fs.existsSync(STREAMS_DIR)) {
-    fs.mkdirSync(STREAMS_DIR, { recursive: true });
+  const dir = streamsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 
 function streamPath(jobId: string): string {
-  return path.join(STREAMS_DIR, `${jobId}.jsonl`);
+  return path.join(streamsDir(), `${jobId}.jsonl`);
 }
 
 /* ─── Subscriber type ────────────────────── */
@@ -149,7 +152,7 @@ export class ActivityStream {
   /** List all stream files (job IDs) */
   static listAll(): string[] {
     ensureDir();
-    return fs.readdirSync(STREAMS_DIR)
+    return fs.readdirSync(streamsDir())
       .filter(f => f.endsWith('.jsonl'))
       .map(f => f.replace('.jsonl', ''));
   }

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

@@ -2,7 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { COMPANY_ROOT } from './file-reader.js';
 
-const ACTIVITY_DIR = path.join(COMPANY_ROOT, 'operations', 'activity');
+function activityDir(): string {
+  return path.join(COMPANY_ROOT, 'operations', 'activity');
+}
 
 export interface RoleActivity {
   roleId: string;
@@ -14,12 +16,13 @@ export interface RoleActivity {
 }
 
 function activityPath(roleId: string): string {
-  return path.join(ACTIVITY_DIR, `${roleId}.json`);
+  return path.join(activityDir(), `${roleId}.json`);
 }
 
 function ensureDir(): void {
-  if (!fs.existsSync(ACTIVITY_DIR)) {
-    fs.mkdirSync(ACTIVITY_DIR, { recursive: true });
+  const dir = activityDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 
@@ -71,10 +74,10 @@ export function getActivity(roleId: string): RoleActivity | null {
 
 export function getAllActivities(): RoleActivity[] {
   ensureDir();
-  const files = fs.readdirSync(ACTIVITY_DIR).filter(f => f.endsWith('.json'));
+  const files = fs.readdirSync(activityDir()).filter(f => f.endsWith('.json'));
   return files.map(f => {
     try {
-      return JSON.parse(fs.readFileSync(path.join(ACTIVITY_DIR, f), 'utf-8'));
+      return JSON.parse(fs.readFileSync(path.join(activityDir(), f), 'utf-8'));
     } catch {
       return null;
     }

package/src/api/src/services/claude-md-manager.ts

@@ -0,0 +1,93 @@
+/**
+ * claude-md-manager.ts — CLAUDE.md lifecycle management
+ *
+ * CLAUDE.md is 100% Tycono-managed. This module handles:
+ * - Version tracking via .tycono/rules-version
+ * - Auto-regeneration on version mismatch (server startup)
+ * - Backup of pre-existing CLAUDE.md (first time only)
+ * - Stub creation for .tycono/custom-rules.md
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.resolve(__dirname, '../../../../templates');
+
+/**
+ * Read the current package version from package.json
+ */
+function getPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../../../package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Generate CLAUDE.md content from template with version marker
+ */
+function generateClaudeMd(version: string): string {
+  const tmplPath = path.join(TEMPLATES_DIR, 'CLAUDE.md.tmpl');
+  const template = fs.readFileSync(tmplPath, 'utf-8');
+  return template.replaceAll('{{VERSION}}', version);
+}
+
+/**
+ * Ensure CLAUDE.md is up-to-date with the current package version.
+ *
+ * Called on server startup. Compares .tycono/rules-version with package version.
+ * If different, regenerates CLAUDE.md from template (safe because CLAUDE.md
+ * contains 0% user data — all user customization is in .tycono/custom-rules.md).
+ */
+export function ensureClaudeMd(companyRoot: string): void {
+  const tyconoDir = path.join(companyRoot, '.tycono');
+  const rulesVersionPath = path.join(tyconoDir, 'rules-version');
+  const claudeMdPath = path.join(companyRoot, 'CLAUDE.md');
+  const customRulesPath = path.join(tyconoDir, 'custom-rules.md');
+  const backupPath = path.join(tyconoDir, 'CLAUDE.md.backup');
+
+  // Skip if not initialized (no .tycono/ directory)
+  if (!fs.existsSync(tyconoDir)) return;
+
+  const currentVersion = getPackageVersion();
+
+  // Read stored version
+  let storedVersion = '0.0.0';
+  if (fs.existsSync(rulesVersionPath)) {
+    storedVersion = fs.readFileSync(rulesVersionPath, 'utf-8').trim();
+  }
+
+  // Skip if already up-to-date
+  if (storedVersion === currentVersion) return;
+
+  // Backup existing CLAUDE.md (first time only — don't overwrite previous backup)
+  if (fs.existsSync(claudeMdPath) && !fs.existsSync(backupPath)) {
+    fs.copyFileSync(claudeMdPath, backupPath);
+    console.log(`[CLAUDE.md] Backed up existing CLAUDE.md to .tycono/CLAUDE.md.backup`);
+  }
+
+  // Regenerate CLAUDE.md from template
+  const content = generateClaudeMd(currentVersion);
+  fs.writeFileSync(claudeMdPath, content);
+
+  // Update rules-version
+  fs.writeFileSync(rulesVersionPath, currentVersion);
+
+  // Create custom-rules.md stub if not exists
+  if (!fs.existsSync(customRulesPath)) {
+    fs.writeFileSync(customRulesPath, `# Custom Rules
+
+> Company-specific rules, constraints, and processes.
+> This file is owned by you — Tycono will never overwrite it.
+
+<!-- Add your custom rules below -->
+`);
+  }
+
+  console.log(`[CLAUDE.md] System rules updated to v${currentVersion} (was v${storedVersion})`);
+}

package/src/api/src/services/file-reader.ts

@@ -14,7 +14,13 @@ function findCompanyRoot(): string {
   return process.cwd();
 }
 
-export const COMPANY_ROOT = findCompanyRoot();
+export let COMPANY_ROOT = findCompanyRoot();
+
+/** Update COMPANY_ROOT at runtime (e.g. after scaffold picks a new location) */
+export function setCompanyRoot(root: string): void {
+  COMPANY_ROOT = root;
+  process.env.COMPANY_ROOT = root;
+}
 
 function resolve(...segments: string[]): string {
   return path.resolve(COMPANY_ROOT, ...segments);

package/src/api/src/services/scaffold.ts

@@ -13,6 +13,16 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMPLATES_DIR = path.resolve(__dirname, '../../../../templates');
 
+function getPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../../../package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
 export interface ScaffoldConfig {
   companyName: string;
   description: string;
@@ -155,11 +165,23 @@ export function scaffold(config: ScaffoldConfig): string[] {
     created.push(dir + '/');
   }
 
-  // Write CLAUDE.md
+  // Write CLAUDE.md (no variable substitution — 100% Tycono managed)
   const claudeTmpl = loadTemplate('CLAUDE.md.tmpl');
-  fs.writeFileSync(path.join(root, 'CLAUDE.md'), renderTemplate(claudeTmpl, vars));
+  const pkgVersion = getPackageVersion();
+  fs.writeFileSync(path.join(root, 'CLAUDE.md'), claudeTmpl.replaceAll('{{VERSION}}', pkgVersion));
   created.push('CLAUDE.md');
 
+  // Write .tycono/rules-version
+  fs.writeFileSync(path.join(root, '.tycono', 'rules-version'), pkgVersion);
+  created.push('.tycono/rules-version');
+
+  // Write .tycono/custom-rules.md (empty stub — user owned)
+  const customRulesPath = path.join(root, '.tycono', 'custom-rules.md');
+  if (!fs.existsSync(customRulesPath)) {
+    fs.writeFileSync(customRulesPath, `# Custom Rules\n\n> Company-specific rules, constraints, and processes.\n> This file is owned by you — Tycono will never overwrite it.\n\n<!-- Add your custom rules below -->\n`);
+    created.push('.tycono/custom-rules.md');
+  }
+
   // Write company/company.md
   const companyTmpl = loadTemplate('company.md.tmpl');
   fs.writeFileSync(path.join(root, 'company', 'company.md'), renderTemplate(companyTmpl, vars));
@@ -310,16 +332,4 @@ function createRole(root: string, role: TeamRole): void {
     fs.writeFileSync(rolesHubPath, hubContent.trimEnd() + '\n' + row + '\n');
   }
 
-  // Append to CLAUDE.md org table
-  const claudeMdPath = path.join(root, 'CLAUDE.md');
-  if (fs.existsSync(claudeMdPath)) {
-    const claudeContent = fs.readFileSync(claudeMdPath, 'utf-8');
-    const orgRow = `| **${role.name}** | AI (${role.id}) | ${role.level} | ${role.reportsTo} | Active |`;
-    const orgMatch = claudeContent.match(/(## Organization[\s\S]*?\n(\|[^\n]*\n)+)/);
-    if (orgMatch) {
-      const insertPos = (orgMatch.index ?? 0) + orgMatch[0].length;
-      const updated = claudeContent.slice(0, insertPos) + orgRow + '\n' + claudeContent.slice(insertPos);
-      fs.writeFileSync(claudeMdPath, updated);
-    }
-  }
 }

package/src/api/src/services/session-store.ts

@@ -26,16 +26,19 @@ export interface Session {
 
 /* ─── Session directory ─────────────────── */
 
-const SESSIONS_DIR = path.join(COMPANY_ROOT, 'operations', 'sessions');
+function sessionsDir(): string {
+  return path.join(COMPANY_ROOT, 'operations', 'sessions');
+}
 
 function ensureDir(): void {
-  if (!fs.existsSync(SESSIONS_DIR)) {
-    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  const dir = sessionsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 
 function sessionPath(id: string): string {
-  return path.join(SESSIONS_DIR, `${id}.json`);
+  return path.join(sessionsDir(), `${id}.json`);
 }
 
 /* ─── Debounced write ───────────────────── */
@@ -69,21 +72,27 @@ const cache = new Map<string, Session>();
 
 function loadAll(): void {
   ensureDir();
-  const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.json'));
+  const files = fs.readdirSync(sessionsDir()).filter((f) => f.endsWith('.json'));
   for (const file of files) {
     try {
-      const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, file), 'utf-8')) as Session;
+      const data = JSON.parse(fs.readFileSync(path.join(sessionsDir(), file), 'utf-8')) as Session;
       cache.set(data.id, data);
     } catch { /* skip corrupted */ }
   }
 }
 
-// Load on startup
-loadAll();
+// Lazy load: defer until first access (avoids creating dirs in CWD before scaffold)
+let loaded = false;
+function ensureLoaded(): void {
+  if (loaded) return;
+  loaded = true;
+  loadAll();
+}
 
 /* ─── Public API ────────────────────────── */
 
 export function createSession(roleId: string, mode: 'talk' | 'do' = 'talk'): Session {
+  ensureLoaded();
   const id = `ses-${roleId}-${Date.now()}`;
   const now = new Date().toISOString();
   const session: Session = {
@@ -102,10 +111,12 @@ export function createSession(roleId: string, mode: 'talk' | 'do' = 'talk'): Ses
 }
 
 export function getSession(id: string): Session | undefined {
+  ensureLoaded();
   return cache.get(id);
 }
 
 export function listSessions(): Omit<Session, 'messages'>[] {
+  ensureLoaded();
   return Array.from(cache.values())
     .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
     .map(({ messages: _, ...meta }) => meta);

package/templates/CLAUDE.md.tmpl

@@ -1,13 +1,6 @@
-# {{COMPANY_NAME}}
+# Company Rules
 
-> {{DESCRIPTION}}
-
----
-
-## Organization
-
-| Role | Assignee | Level | Reports To | Status |
-|------|----------|-------|------------|--------|
+> Powered by [Tycono](https://tycono.ai) — AI Company Operating Platform
 
 ---
 
@@ -47,6 +40,12 @@
 Every folder has a Hub file (`{folder-name}.md`) as its entry point.
 Check the Task Routing table above to find the right Hub, then read it first.
 
+### Custom Rules (CRITICAL)
+
+> ⛔ **Before starting work, check if `.tycono/custom-rules.md` exists and read it.**
+> This file contains company-specific rules, constraints, and processes.
+> If the file doesn't exist, ignore this section.
+
 ### Knowledge Gate
 
 > **Before creating a new document, search existing docs first.**
@@ -162,10 +161,15 @@ After completing any task:
 ## Folder Structure
 
 ```
-{{COMPANY_NAME}}/
-+-- CLAUDE.md                <- AI entry point
+{company}/
++-- CLAUDE.md                <- AI entry point (Tycono managed)
++-- .tycono/
+|   +-- config.json          <- Engine settings
+|   +-- preferences.json     <- UI preferences
+|   +-- custom-rules.md      <- Company custom rules (user owned)
+|   +-- rules-version        <- Current CLAUDE.md version
 +-- company/
-|   +-- company.md           <- Mission, vision
+|   +-- company.md           <- Mission, vision, company info
 +-- roles/
 |   +-- roles.md             <- Role listing (Hub)
 |   +-- {role-id}/
@@ -189,4 +193,5 @@ After completing any task:
 
 ---
 
-*Powered by [tycono](https://github.com/seongsu-kang/the-company)*
+<!-- tycono:managed v{{VERSION}} — This file is managed by Tycono. Do not edit manually. -->
+<!-- Company-specific rules go in .tycono/custom-rules.md -->