deuk-agent-rule 2.2.2 → 2.3.2

package/scripts/cli-ticket-logic.mjs

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync, copyFileSync } from "fs";
 import { basename, dirname, join, relative } from "path";
-import { toPosixPath, toRepoRelativePath, toSlug, formatTimestampForFile, makeEntryId, detectProjectFromBody, deriveTopicFromBaseName } from "./cli-utils.mjs";
+import { createHash } from "crypto";
+import { toPosixPath, toRepoRelativePath, toSlug, formatTimestampForFile, makeEntryId, detectProjectFromBody, deriveTopicFromBaseName, parseFrontMatter, stringifyFrontMatter, loadInitConfig } from "./cli-utils.mjs";
 
 export const TICKET_DIR_NAME = ".deuk-agent-ticket";
 export const TICKET_INDEX_FILENAME = "INDEX.json";
@@ -65,34 +66,42 @@ export function writeTicketIndexJson(cwd, indexJson, opts = {}) {
 
 export function renderTicketListMarkdown(cwd, entries) {
   const sorted = [...entries].sort((a, b) => String(b.createdAt || "").localeCompare(String(a.createdAt || "")));
-  const latest = sorted[0] || null;
+  const latest = sorted.find(e => e.status !== "archived") || sorted[0] || null;
 
   const ticketDir = detectConsumerTicketDir(cwd, { createIfMissing: true });
   const templatePath = join(ticketDir, TICKET_LIST_TEMPLATE_FILENAME);
   const template = existsSync(templatePath) ? readFileSync(templatePath, "utf8") : DEFAULT_TICKET_LIST_TEMPLATE;
 
-  let latestBlock = "- No ticket entries yet.";
+  let latestBlock = "- No active ticket entries yet.";
   if (latest) {
     const relPath = toPosixPath(relative(ticketDir, join(cwd, latest.path)));
     const safeLatestTitle = String(latest.title || "").replace(/\[|\]/g, '').replace(/\n/g, ' ');
-    latestBlock = `- [${safeLatestTitle}](${relPath})\n- group: \`${latest.group}\` / project: \`${latest.project}\` / created: \`${latest.createdAt}\``;
+    latestBlock = `- [${safeLatestTitle}](${relPath})\n- status: \`${latest.status}\` / group: \`${latest.group}\` / project: \`${latest.project}\``;
   }
 
-  let rows = sorted.slice(0, 30).map((e, i) => {
-    const relPath = toPosixPath(relative(ticketDir, join(cwd, e.path)));
-    const statusPrefix = e.status === "closed" ? "✓ " : "";
-    const safeTitle = String(e.title || "").replace(/\|/g, '|').replace(/(\n|\\n)+/g, ' ');
-    return `| ${i + 1} | ${statusPrefix}${safeTitle} | ${e.group} | ${e.project} | ${e.createdAt} | [open](${relPath}) |`;
-  }).join("\n");
+  const activeRows = sorted.filter(e => e.status !== "archived").map((e, i) => renderLine(e, i, ticketDir, cwd));
+  const archivedRows = sorted.filter(e => e.status === "archived").slice(0, 50).map((e, i) => renderLine(e, i, ticketDir, cwd));
+
+  let combinedRows = "### 🚀 Active Tickets\n\n| # | Status | Title | Group | Project | Created | Path |\n|---|---|---|---|---|---|---|\n" + 
+                     (activeRows.join("\n") || "| - | - | No active tickets | - | - | - | - |") + 
+                     "\n\n### 📦 Archived Tickets\n\n| # | Status | Title | Group | Project | Created | Path |\n|---|---|---|---|---|---|---|\n" + 
+                     (archivedRows.join("\n") || "| - | - | No archived tickets | - | - | - | - |");
 
   return template
     .replaceAll("{{SOURCE_INDEX}}", `${TICKET_DIR_NAME}/${TICKET_INDEX_FILENAME}`)
     .replaceAll("{{LATEST_BLOCK}}", latestBlock)
-    .replaceAll("{{ENTRIES_ROWS}}", rows || "| - | No entries yet | - | - | - | - |")
+    .replaceAll("{{ENTRIES_ROWS}}", combinedRows)
     .replaceAll("{{CMD_LIST}}", "npx deuk-agent-rule ticket list")
     .replaceAll("{{CMD_USE_LATEST}}", "npx deuk-agent-rule ticket use --latest");
 }
 
+function renderLine(e, i, ticketDir, cwd) {
+  const relPath = toPosixPath(relative(ticketDir, join(cwd, e.path)));
+  const statusIcon = e.status === "active" ? "🔥 " : (e.status === "archived" ? "📦 " : "[ ] ");
+  const safeTitle = String(e.title || "").replace(/\|/g, '|').replace(/(\n|\\n)+/g, ' ');
+  return `| ${i + 1} | ${statusIcon}${e.status} | ${safeTitle} | ${e.group} | ${e.project} | ${e.createdAt.split('T')[0]} | [open](${relPath}) |`;
+}
+
 export function writeTicketListFile(cwd, entries, opts = {}) {
   const ticketDir = detectConsumerTicketDir(cwd, { createIfMissing: true });
   const p = join(ticketDir, TICKET_LIST_FILENAME);
@@ -135,60 +144,243 @@ export function updateTicketEntryStatus(cwd, opts = {}) {
   return entry;
 }
 
+export function performUpgradeMigration(cwd, opts = {}) {
+  const root = join(cwd, TICKET_DIR_NAME);
+  const archiveDir = join(root, "archive");
+  
+  const files = collectTicketMarkdownFiles(root).filter(p => {
+    const base = basename(p);
+    return base !== "LATEST.md" && base !== TICKET_LIST_FILENAME && base !== TICKET_LIST_TEMPLATE_FILENAME && base !== "ACTIVE_TICKET.md";
+  });
+
+  console.log(`[UPGRADE] Scanning ${files.length} tickets for V2 migration...`);
+
+  let count = 0;
+  for (const abs of files) {
+    const rel = toRepoRelativePath(cwd, abs);
+    const body = readFileSync(abs, "utf8");
+    const { meta, content } = parseFrontMatter(body);
+
+    if (meta.id && meta.status) {
+      // Already V2, but check if it needs archiving
+      const isAlreadyInArchive = rel.includes("/archive/");
+      if (meta.status === "archived" && !isAlreadyInArchive && !opts.dryRun) {
+        // Move to archive if status is archived but file is in root
+        moveFileToArchive(cwd, abs, meta.group || "sub");
+      }
+      continue;
+    }
+
+    // V1 -> V2 Migration
+    const titleMatch = content.match(/^##\s+Task:\s*(.+)$/m);
+    const title = meta.title || titleMatch?.[1]?.trim() || basename(abs).replace(/\.md$/i, "");
+    
+    // Check if finished (all phases [x])
+    const phases = content.match(/\[[ x/]]/g);
+    const finished = phases && phases.length > 0 && phases.every(p => p.includes("x"));
+    const isAlreadyInArchive = rel.includes("/archive/");
+
+    let status = meta.status || "open";
+    if (finished || isAlreadyInArchive) {
+        status = "archived";
+    }
+
+    const project = meta.project || detectProjectFromBody(content);
+    
+    const newMeta = {
+      id: meta.id || `ticket_${statSync(abs).mtimeMs}`,
+      title,
+      status,
+      submodule: meta.submodule || (content.includes("DeukPack") ? "DeukPack" : ""),
+      project,
+      createdAt: meta.createdAt || statSync(abs).birthtime.toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    const migratedBody = stringifyFrontMatter(newMeta, content);
+    
+    if (opts.dryRun) {
+      console.log(`[DRY-RUN] Would upgrade: ${rel} (status: ${status})`);
+    } else {
+      let finalAbs = abs;
+      if (status === "archived" && !isAlreadyInArchive) {
+          finalAbs = moveFileToArchive(cwd, abs, basename(dirname(abs)));
+      }
+      writeFileSync(finalAbs, migratedBody, "utf8");
+      console.log(`[OK] Upgraded: ${toRepoRelativePath(cwd, finalAbs)}`);
+      count++;
+    }
+  }
+
+  if (!opts.dryRun) {
+    rebuildTicketIndexFromTopicFilesIfNeeded(cwd, { ...opts, force: true });
+    performDefragmentation(cwd, opts); // NEW: Split to submodules
+    syncActiveTicketPointer(cwd);
+  }
+  
+  return count;
+}
+
+export function performDefragmentation(cwd, opts = {}) {
+  const rootTicketDir = join(cwd, TICKET_DIR_NAME);
+  const tickets = collectTicketMarkdownFiles(rootTicketDir).filter(p => {
+    const base = basename(p);
+    return base !== "LATEST.md" && base !== TICKET_LIST_FILENAME && base !== TICKET_LIST_TEMPLATE_FILENAME && base !== "ACTIVE_TICKET.md";
+  });
+
+  console.log(`[DEFRAG] Checking ${tickets.length} tickets for submodule placement...`);
+
+  const modifiedSubmodules = new Set();
+  
+  for (const abs of tickets) {
+    const { meta } = parseFrontMatter(readFileSync(abs, "utf8"));
+    if (meta.submodule && meta.submodule !== "global") {
+      const subPath = join(cwd, meta.submodule);
+      if (existsSync(subPath) && statSync(subPath).isDirectory()) {
+        const subTicketDir = join(subPath, TICKET_DIR_NAME);
+        mkdirSync(subTicketDir, { recursive: true });
+        
+        const relToRoot = relative(rootTicketDir, abs);
+        const destAbs = join(subTicketDir, relToRoot);
+        
+        if (opts.dryRun) {
+          console.log(`[DRY-RUN] Would move to submodule: ${relToRoot} -> ${meta.submodule}/${TICKET_DIR_NAME}/`);
+        } else {
+          mkdirSync(dirname(destAbs), { recursive: true });
+          copyFileSync(abs, destAbs);
+          unlinkSync(abs);
+          console.log(`[DEFRAG] Moved: ${meta.submodule}/${TICKET_DIR_NAME}/${relToRoot}`);
+          modifiedSubmodules.add(subPath);
+        }
+      }
+    }
+  }
+
+  // Re-index all touched submodules
+  if (!opts.dryRun) {
+    for (const subCwd of modifiedSubmodules) {
+      rebuildTicketIndexFromTopicFilesIfNeeded(subCwd, { ...opts, force: true });
+      syncActiveTicketPointer(subCwd);
+    }
+  }
+}
+
+function moveFileToArchive(cwd, abs, group) {
+  const archiveBase = join(cwd, TICKET_DIR_NAME, "archive");
+  const targetSubDir = (group === TICKET_DIR_NAME || !group) ? "sub" : group;
+  const targetDir = join(archiveBase, targetSubDir);
+  mkdirSync(targetDir, { recursive: true });
+  const finalAbs = join(targetDir, basename(abs));
+  if (finalAbs !== abs) {
+    if (existsSync(finalAbs)) {
+      unlinkSync(abs); // Already exists in archive
+    } else {
+      writeFileSync(finalAbs, readFileSync(abs, "utf8"), "utf8");
+      unlinkSync(abs);
+    }
+  }
+  return finalAbs;
+}
+
 export function collectTicketMarkdownFiles(dir, out = []) {
   if (!existsSync(dir)) return out;
   for (const ent of readdirSync(dir, { withFileTypes: true })) {
     const abs = join(dir, ent.name);
+    // Ignore common noise
+    if (ent.name === "node_modules" || ent.name === ".git") continue;
+    
     if (ent.isDirectory()) collectTicketMarkdownFiles(abs, out);
-    else if (ent.isFile() && /\.md$/i.test(ent.name)) out.push(abs);
+    else if (ent.isFile() && /\.md$/i.test(ent.name)) {
+      const base = ent.name;
+      if (base === "LATEST.md" || base === TICKET_LIST_FILENAME || base === TICKET_LIST_TEMPLATE_FILENAME || base === "ACTIVE_TICKET.md") continue;
+      out.push(abs);
+    }
+  }
+  return out;
+}
+
+/**
+ * Finds all .deuk-agent-ticket directories recursively, skipping node_modules/.git
+ */
+export function discoverAllTicketDirs(baseCwd, out = []) {
+  if (!existsSync(baseCwd)) return out;
+  const entries = readdirSync(baseCwd, { withFileTypes: true });
+  
+  // If current dir has .deuk-agent-ticket, add it
+  const local = join(baseCwd, TICKET_DIR_NAME);
+  if (existsSync(local) && statSync(local).isDirectory()) {
+    out.push(local);
+  }
+
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    if (ent.name === "node_modules" || ent.name === ".git" || ent.name === TICKET_DIR_NAME) continue;
+    discoverAllTicketDirs(join(baseCwd, ent.name), out);
   }
   return out;
 }
 
 export function rebuildTicketIndexFromTopicFilesIfNeeded(cwd, opts = {}) {
   const indexJson = readTicketIndexJson(cwd);
-  const root = join(cwd, TICKET_DIR_NAME);
-  const files = collectTicketMarkdownFiles(root).filter(p => {
-    const base = basename(p);
-    return base !== "LATEST.md" && base !== TICKET_LIST_FILENAME && base !== TICKET_LIST_TEMPLATE_FILENAME;
-  });
+  // Hierarchical Scan: If we are at root, discover all sub-dirs. 
+  const isRoot = existsSync(join(cwd, "DeukAgentRules")) || existsSync(join(cwd, "project_i"));
+  
+  let ticketDirs = [];
+  if (opts.recursive !== false && isRoot) {
+    ticketDirs = discoverAllTicketDirs(cwd);
+  } else {
+    const local = join(cwd, TICKET_DIR_NAME);
+    if (existsSync(local) && statSync(local).isDirectory()) {
+      ticketDirs = [local];
+    }
+  }
+
+  if (ticketDirs.length === 0) return indexJson;
+
+  const files = [];
+  for (const dir of ticketDirs) {
+    collectTicketMarkdownFiles(dir, files);
+  }
 
   let dirty = false;
-  const existingPaths = new Set(indexJson.entries.map(e => toPosixPath(e.path)));
+  const newEntries = [];
 
   for (let i = 0; i < files.length; i++) {
     const abs = files[i];
     const rel = toPosixPath(toRepoRelativePath(cwd, abs));
-    if (!existingPaths.has(rel)) {
-      const body = readFileSync(abs, "utf8");
-      const titleMatch = body.match(/^##\s+Task:\s*(.+)$/m);
-      const title = titleMatch ? titleMatch[1].trim() : basename(abs).replace(/\.md$/i, "");
-      indexJson.entries.push({
-        id: `ticket_recovered_${Date.now()}_${i}`,
-        title,
-        topic: deriveTopicFromBaseName(basename(abs)),
-        group: basename(dirname(abs)),
-        project: detectProjectFromBody(body),
-        createdAt: statSync(abs).mtime.toISOString(),
-        path: rel,
-        source: "ticket-recover-scan",
-        status: "open",
-      });
-      dirty = true;
-    }
+    const body = readFileSync(abs, "utf8");
+    const { meta, content } = parseFrontMatter(body);
+    const titleMatch = content.match(/^##\s+Task:\s*(.+)$/m);
+    
+    const title = meta.title || titleMatch?.[1]?.trim() || basename(abs).replace(/\.md$/i, "");
+    const isAlreadyInArchive = rel.includes("/archive/");
+    const status = isAlreadyInArchive ? "archived" : (meta.status || "open");
+    const project = meta.project || detectProjectFromBody(content);
+    const submodule = meta.submodule || "";
+
+    newEntries.push({
+      id: meta.id || makeEntryId(),
+      title,
+      topic: deriveTopicFromBaseName(basename(abs)),
+      group: basename(dirname(abs)),
+      project,
+      submodule: meta.submodule || (rel.startsWith(TICKET_DIR_NAME) ? "" : rel.split("/")[0]),
+      createdAt: meta.createdAt || statSync(abs).mtime.toISOString(),
+      updatedAt: meta.updatedAt || statSync(abs).mtime.toISOString(),
+      path: rel,
+      source: "ticket-sync",
+      status,
+    });
   }
 
-  const physicalPaths = new Set(files.map(abs => toPosixPath(toRepoRelativePath(cwd, abs))));
-  const originalLength = indexJson.entries.length;
-  indexJson.entries = indexJson.entries.filter(e => physicalPaths.has(toPosixPath(e.path)));
-  
-  if (indexJson.entries.length !== originalLength) {
+  // Compare with old index to see if dirty
+  if (JSON.stringify(indexJson.entries) !== JSON.stringify(newEntries)) {
     dirty = true;
   }
 
-  if (dirty) {
-    indexJson.entries.sort((a,b) => String(b.createdAt||"").localeCompare(String(a.createdAt||"")));
-    const next = { version: 1, updatedAt: new Date().toISOString(), entries: indexJson.entries };
+  if (dirty || opts.force) {
+    newEntries.sort((a,b) => String(b.createdAt||"").localeCompare(String(a.createdAt||"")));
+    const next = { version: 1, updatedAt: new Date().toISOString(), entries: newEntries };
     writeTicketIndexJson(cwd, next, opts);
     writeTicketListFile(cwd, next.entries, opts);
     return next;
@@ -211,7 +403,7 @@ export function parseLegacyTicketMeta(legacyBody) {
 }
 
 export function getLegacyMigrationCandidate(cwd) {
-  const candidateFiles = ["LATEST.md", "implementation_plan.md"];
+  const candidateFiles = ["LATEST.md"];
   const candidateDirs = [cwd, join(cwd, TICKET_DIR_NAME), join(cwd, "ticket")];
   for (const dir of candidateDirs) {
     for (const file of candidateFiles) {
@@ -219,7 +411,7 @@ export function getLegacyMigrationCandidate(cwd) {
       if (existsSync(p)) {
         const body = readFileSync(p, "utf8");
         // Check for common plan or task markers
-        if (body.length > 50 && (/^##\s+Task:/m.test(body) || /^#\s+Plan:/m.test(body) || /^#\s+Implementation Plan:/m.test(body))) {
+        if (body.length > 50 && (/^##\s+Task:/m.test(body) || /^#\s+Plan:/m.test(body))) {
           return { latestPath: p, body };
         }
       }
@@ -227,3 +419,87 @@ export function getLegacyMigrationCandidate(cwd) {
   }
   return null;
 }
+
+export function syncActiveTicketPointer(cwd) {
+  const index = readTicketIndexJson(cwd);
+  // Find the single "active" ticket, or the most recent "open" ticket.
+  const activeEntry = index.entries.find(e => e.status === "active") || 
+                      index.entries.find(e => e.status === "open");
+  
+  const ticketDir = detectConsumerTicketDir(cwd);
+  if (!ticketDir) return;
+
+  // LATEST.md is deprecated. Remove it on every sync to prevent stale reads.
+  const legacyLatestPath = join(ticketDir, "LATEST.md");
+  if (existsSync(legacyLatestPath)) {
+    unlinkSync(legacyLatestPath);
+  }
+
+  const pointerPathMd = join(ticketDir, "ACTIVE_TICKET.md");
+  const pointerPathJson = join(ticketDir, "ACTIVE_TICKET.json");
+  
+  if (activeEntry) {
+    const srcAbs = join(cwd, activeEntry.path);
+    if (existsSync(srcAbs)) {
+      const redirectBody = `# 🚀 Active Ticket Redirect\n\n> **[STOP] DO NOT EDIT THIS FILE!**\n> This is a pointer file. Editing this file will result in data loss because it is not the original ticket.\n\n**Please open and edit the original ticket here:**\n🔗 [${basename(activeEntry.path)}](/${toPosixPath(activeEntry.path)})\n\n---\n*Original Path:* \`${activeEntry.path}\`\n*Topic:* \`${activeEntry.topic}\``;
+      const redirectContent = stringifyFrontMatter({
+          id: activeEntry.id || "pointer",
+          title: activeEntry.title || "ACTIVE_TICKET_POINTER",
+          topic: activeEntry.topic || "",
+          status: activeEntry.status || "active",
+          submodule: activeEntry.submodule || "",
+          project: activeEntry.project || "",
+          createdAt: activeEntry.createdAt || new Date().toISOString()
+      }, redirectBody);
+      writeFileSync(pointerPathMd, redirectContent, "utf8");
+      writeFileSync(pointerPathJson, JSON.stringify({ ...activeEntry, syncedAt: new Date().toISOString() }, null, 2), "utf8");
+      
+      // Hook: Optional background sync to remote pipeline
+      const config = loadInitConfig(cwd);
+      if (config && config.remoteSync && config.pipelineUrl) {
+        syncToPipeline(config.pipelineUrl, { action: "sync_active", ticket: activeEntry });
+      }
+      return;
+    }
+  }
+
+  // If no active ticket, clear pointers
+  const noTicketMsg = "# No Active Ticket Found\nUse `npx deuk-agent-rule ticket list` to find open tasks.\n";
+  writeFileSync(pointerPathMd, noTicketMsg, "utf8");
+  writeFileSync(pointerPathJson, JSON.stringify({ status: "none", message: "No active ticket" }), "utf8");
+}
+
+
+/**
+ * Deterministic or Hash-based ID to prevent collisions in multi-device sync
+ */
+export function generateTicketId(title) {
+  const seed = `${title}-${Date.now()}-${Math.random()}`;
+  try {
+    return "ticket_" + createHash("md5").update(seed).digest("hex").slice(0, 12);
+  } catch {
+    return "ticket_" + Date.now() + "_" + Math.floor(Math.random() * 1000);
+  }
+}
+
+/**
+ * Async background sync to AI Pipeline.
+ * Returning true on success, false on failure (for connect check).
+ */
+export async function syncToPipeline(url, data) {
+  if (typeof fetch === "undefined") {
+    // Node.js version < 18 or no fetch polyfill
+    return false;
+  }
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+      signal: AbortSignal?.timeout ? AbortSignal.timeout(3000) : undefined
+    });
+    return response.ok;
+  } catch (err) {
+    return false;
+  }
+}

package/scripts/cli-utils.mjs

@@ -1,5 +1,51 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, join, relative } from "path";
+import YAML from "yaml";
+
+export const INIT_CONFIG_FILENAME = ".deuk-agent-rule.config.json";
+export const INIT_CONFIG_VERSION = 1;
+
+export const STACKS = [
+  { label: "Unity / C#", value: "unity" },
+  { label: "Unity + WebApp + C++ Server (Hybrid)", value: "unity-webapp-cpp" },
+  { label: "Next.js + C#", value: "nextjs-dotnet" },
+  { label: "Web (React / Vue / general)", value: "web" },
+  { label: "Java / Spring Boot", value: "java" },
+  { label: "Other / skip", value: "other" },
+];
+
+export const AGENT_TOOLS = [
+  { label: "Cursor (Rule System)", value: "cursor" },
+  { label: "Gemini / Antigravity", value: "gemini" },
+  { label: "Claude / Dev", value: "claude" },
+];
+
+export function loadInitConfig(cwd) {
+  const p = join(cwd, INIT_CONFIG_FILENAME);
+  if (!existsSync(p)) return null;
+  try {
+    const j = JSON.parse(readFileSync(p, "utf8"));
+    if (j.version !== INIT_CONFIG_VERSION) return null;
+    return j;
+  } catch {
+    return null;
+  }
+}
+
+export function writeInitConfig(cwd, opts) {
+  const p = join(cwd, INIT_CONFIG_FILENAME);
+  const data = {
+    version: INIT_CONFIG_VERSION,
+    agentsMode: opts.agents || "inject",
+    stack: opts.stack,
+    agentTools: opts.agentTools,
+    shareTickets: !!opts.shareTickets,
+    remoteSync: !!opts.remoteSync,
+    pipelineUrl: opts.pipelineUrl,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(p, JSON.stringify(data, null, 2), "utf8");
+}
 
 export function toPosixPath(p) {
   return p.replace(/\\/g, "/");
@@ -80,3 +126,20 @@ export function inferRefTitleAndTopic(opts) {
     topic,
   };
 }
+
+export function parseFrontMatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]+?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, content };
+  try {
+    const meta = YAML.parse(match[1]);
+    return { meta: meta || {}, content: match[2] };
+  } catch (e) {
+    console.error("YAML Parse Error:", e);
+    return { meta: {}, content };
+  }
+}
+
+export function stringifyFrontMatter(meta, content) {
+  const yamlStr = YAML.stringify(meta).trim();
+  return `---\n${yamlStr}\n---\n\n${content.trim()}\n`;
+}

package/scripts/cli.mjs

@@ -4,8 +4,9 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { parseArgs, parseTicketArgs } from "./cli-args.mjs";
 import { runInit, runMerge } from "./cli-init-commands.mjs";
-import { runTicketCreate, runTicketList, runTicketUse, runTicketClose, runTicketArchive, runTicketReports } from "./cli-ticket-commands.mjs";
-import { loadInitConfig, writeInitConfig } from "./cli-prompts.mjs";
+import { runTicketCreate, runTicketList, runTicketUse, runTicketClose, runTicketArchive, runTicketReports, runTicketMeta, runTicketConnect } from "./cli-ticket-commands.mjs";
+import { performUpgradeMigration } from "./cli-ticket-logic.mjs";
+import { loadInitConfig, writeInitConfig } from "./cli-utils.mjs";
 import { runInteractive } from "./cli-prompts.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -30,7 +31,12 @@ async function main() {
     else if (action === "close") await runTicketClose(opts);
     else if (action === "archive") await runTicketArchive(opts);
     else if (action === "reports") await runTicketReports(opts);
-    else if (action === "migrate") await runTicketMigrate(opts);
+    else if (action === "meta") await runTicketMeta(opts);
+    else if (action === "connect") await runTicketConnect(opts);
+    else if (action === "upgrade" || action === "migrate") {
+      const count = performUpgradeMigration(opts.cwd, opts);
+      console.log(`Migration complete: ${count} tickets upgraded.`);
+    }
     else {
       console.error("Unknown ticket action: " + action);
       printHelp();
@@ -66,7 +72,7 @@ async function main() {
   printHelp();
 }
 
-import { runTicketMigrate } from "./cli-ticket-commands.mjs";
+// Removed legacy migration runTicketMigrate
 
 async function handleInit(opts) {
   if (!opts.interactive && !opts.nonInteractive && !loadInitConfig(opts.cwd)) {
@@ -86,7 +92,7 @@ function printHelp() {
 Usage:
   npx deuk-agent-rule init   [options]
   npx deuk-agent-rule merge  [options]
-  npx deuk-agent-rule ticket <create|list|use|close|archive|reports|migrate> [options]
+  npx deuk-agent-rule ticket <create|list|use|close|archive|reports|migrate|upgrade|meta|connect> [options]
 
 Options:
   --cwd <path>          Target repo root
@@ -96,13 +102,19 @@ Options:
   --agents <mode>       inject | skip | overwrite
   --rules <mode>        prefix | skip | overwrite
   --cursorrules <mode>  inject | skip | overwrite
+  --json                Output result in JSON format
+  --remote <url>        Temporary pipeline URL
+  --sync                Force enable remote sync
+  --no-sync             Force disable remote sync
 
 Ticket Options:
   --topic <name>        Ticket topic slug
   --group <name>        Ticket group (sub|main|discussion)
   --project <name>      Project filter (DeukUI|DeukAgentRules)
-  --latest              Use most recent ticket
+  --submodule <name>    Submodule filter (DeukPack|DeukUI)
+  --latest              Use most recent ticket (default if no topic)
   --path-only           Print only the file path
+  --json                Output result in JSON format
 `);
 }
 

package/scripts/sync-oss.mjs

@@ -49,6 +49,9 @@ cpSync(join(pkgRoot, "README.ko.md"), join(ossRoot, "README.ko.md"), { force: tr
 if (existsSync(join(pkgRoot, "CHANGELOG.md"))) {
   cpSync(join(pkgRoot, "CHANGELOG.md"), join(ossRoot, "CHANGELOG.md"), { force: true });
 }
+if (existsSync(join(pkgRoot, "CHANGELOG.ko.md"))) {
+  cpSync(join(pkgRoot, "CHANGELOG.ko.md"), join(ossRoot, "CHANGELOG.ko.md"), { force: true });
+}
 if (existsSync(join(pkgRoot, "package-lock.json"))) {
   cpSync(join(pkgRoot, "package-lock.json"), join(ossRoot, "package-lock.json"), { force: true });
 }
@@ -91,6 +94,7 @@ const outPkg = {
     "README.md",
     "README.ko.md",
     "CHANGELOG.md",
+    "CHANGELOG.ko.md",
   ],
 };
 delete outPkg.private;
@@ -119,4 +123,4 @@ if (existsSync(ossPolish)) {
 }
 
 console.log("deuk-agent-rule: synced OSS tree at " + ossRoot);
-console.log("  Override repo URL: DEUK_AGENT_RULES_OSS_REPO=https://github.com/org/DeukAgentRulesOSS");
+console.log("  Override repo URL: DEUK_AGENT_RULES_OSS_REPO=https://github.com/joygram/DeukAgentRules");