deuk-agent-rule 2.2.2 → 2.3.1

package/scripts/cli-ticket-commands.mjs

@@ -1,7 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, copyFileSync, readdirSync, rmSync, statSync } from "fs";
 import { basename, join, dirname, relative, resolve } from "path";
-import { toSlug, toRepoRelativePath, inferRefTitleAndTopic, resolveReferencedTicketPath, toPosixPath } from "./cli-utils.mjs";
-import { TICKET_DIR_NAME, appendTicketEntry, rebuildTicketIndexFromTopicFilesIfNeeded, detectConsumerTicketDir, readTicketIndexJson, writeTicketIndexJson, writeTicketListFile } from "./cli-ticket-logic.mjs";
+import { toSlug, toRepoRelativePath, inferRefTitleAndTopic, resolveReferencedTicketPath, toPosixPath, stringifyFrontMatter } from "./cli-utils.mjs";
+import { TICKET_DIR_NAME, appendTicketEntry, rebuildTicketIndexFromTopicFilesIfNeeded, detectConsumerTicketDir, readTicketIndexJson, writeTicketIndexJson, writeTicketListFile, syncActiveTicketPointer, generateTicketId, syncToPipeline } from "./cli-ticket-logic.mjs";
+import { loadInitConfig } from "./cli-utils.mjs";
+import ejs from "ejs";
 
 import { createInterface } from "readline";
 import { selectOne } from "./cli-prompts.mjs";
@@ -19,21 +21,60 @@ export async function runTicketCreate(opts) {
     path = resolveReferencedTicketPath(opts);
     source = "ticket-reference";
   } else {
-    let body = opts.content ? String(opts.content).replace(/\\n/g, '\n') : "";
-    if (!body && opts.from) body = readFileSync(join(opts.cwd, opts.from), "utf8");
-    const abs = join(opts.cwd, TICKET_DIR_NAME, group, `${topic}-${Date.now()}.md`);
-    mkdirSync(join(opts.cwd, TICKET_DIR_NAME, group), { recursive: true });
+    let tplText = "";
+    const consumerTplPath = join(opts.cwd, ".deuk-agent-templates", "TICKET_TEMPLATE.md");
+    const bundleTplPath = join(new URL('.', import.meta.url).pathname, "..", "bundle", "templates", "TICKET_TEMPLATE.md");
+    
+    if (existsSync(consumerTplPath)) tplText = readFileSync(consumerTplPath, "utf8");
+    else if (existsSync(bundleTplPath)) tplText = readFileSync(bundleTplPath, "utf8");
+    else throw new Error("ticket create: Template not found. Refusing to create an empty ticket.");
+
+    // Find nearest or create in CWD if missing
+    const ticketDir = detectConsumerTicketDir(opts.cwd, { createIfMissing: true });
+    const abs = join(ticketDir, group, `${topic}-${Date.now()}.md`);
+    mkdirSync(join(ticketDir, group), { recursive: true });
     path = toRepoRelativePath(opts.cwd, abs);
-    const marker = `\n\n<!-- Ticket (repo-relative): ${path} -->\n`;
-    writeFileSync(abs, body.trimEnd() + marker, "utf8");
+
+    const ticketId = generateTicketId(title);
+    const meta = {
+      id: ticketId,
+      title,
+      topic,
+      status: "open",
+      submodule: opts.submodule || "",
+      project: opts.project || "global",
+      createdAt: new Date().toISOString(),
+    };
+
+    const ejsFrontMatter = `---
+id: <%= meta.id %>
+title: "<%- meta.title.replace(/"/g, '\\"') %>"
+topic: <%= meta.topic %>
+status: open
+submodule: <%= meta.submodule %>
+project: <%= meta.project %>
+createdAt: <%= meta.createdAt %>
+---
+
+`;
+    const finalContent = ejs.render(ejsFrontMatter + tplText, { meta });
+    writeFileSync(abs, finalContent, "utf8");
     source = "ticket-create";
+    
+    // Remote Sync Hook
+    const config = loadInitConfig(opts.cwd);
+    if (config && config.remoteSync && config.pipelineUrl) {
+      syncToPipeline(config.pipelineUrl, { action: "create", ticket: meta });
+    }
+
+    appendTicketEntry(opts.cwd, {
+      id: ticketId,
+      title, topic, group, project: opts.project || "global",
+      createdAt: new Date().toISOString(), path, source
+    }, opts);
   }
 
-  appendTicketEntry(opts.cwd, {
-    id: `ticket_${Date.now()}`,
-    title, topic, group, project: opts.project || "global",
-    createdAt: new Date().toISOString(), path, source
-  }, opts);
+  syncActiveTicketPointer(opts.cwd);
 }
 
 export async function runTicketList(opts) {
@@ -42,24 +83,64 @@ export async function runTicketList(opts) {
     throw new Error("No ticket system found. Please run 'npx deuk-agent-rule init' first.");
   }
   const index = rebuildTicketIndexFromTopicFilesIfNeeded(opts.cwd, opts);
+  syncActiveTicketPointer(opts.cwd);
   let rows = index.entries;
+
   
-  if (!opts.all) {
-    const targetStatus = opts.status || "open";
-    rows = rows.filter(e => e.status === targetStatus);
+  if (opts.active) {
+    rows = rows.filter(e => e.status === "active" || e.status === "open");
+  } else if (opts.archived) {
+    rows = rows.filter(e => e.status === "archived");
+  } else if (!opts.all) {
+    // Default: major/active list (open or active)
+    rows = rows.filter(e => e.status === "open" || e.status === "active");
   }
   
   if (opts.group) rows = rows.filter(e => e.group === opts.group);
   if (opts.project) rows = rows.filter(e => e.project === opts.project);
+  if (opts.submodule) rows = rows.filter(e => e.submodule === opts.submodule);
   
-  console.log("#  STATUS  GROUP       PROJECT     CREATED                  TITLE");
+  if (opts.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+
+  console.log("#  STATUS   SUBMODULE   GROUP       PROJECT     CREATED                  TITLE");
   rows.slice(0, opts.limit).forEach((e, idx) => {
     const stat = (e.status === "closed" ? "[x]" : "[ ]").padEnd(7);
+    const sub = (e.submodule || "-").padEnd(11);
     const safeTitle = String(e.title || e.topic || "").replace(/(\n|\\n)+/g, " ").slice(0, 50);
-    console.log(`${String(idx+1).padEnd(2)} ${stat} ${e.group.padEnd(10)} ${e.project.padEnd(11)} ${e.createdAt.padEnd(24)} ${safeTitle}`);
+    console.log(`${String(idx+1).padEnd(2)} ${stat} ${sub} ${String(e.group||"").padEnd(10)} ${String(e.project||"").padEnd(11)} ${String(e.createdAt||"").padEnd(24)} ${safeTitle}`);
   });
 }
 
+export async function runTicketMeta(opts) {
+  const index = rebuildTicketIndexFromTopicFilesIfNeeded(opts.cwd, opts);
+  const found = pickTicketEntry(opts, index);
+  if (!found) throw new Error("ticket meta: no matching ticket found");
+
+  if (opts.json) {
+    console.log(JSON.stringify(found, null, 2));
+  } else {
+    console.log(`Ticket Meta [${found.topic}]`);
+    Object.entries(found).forEach(([k, v]) => console.log(`  ${k}: ${v}`));
+  }
+}
+
+export async function runTicketConnect(opts) {
+  const config = loadInitConfig(opts.cwd);
+  const url = opts.remote || config?.pipelineUrl;
+  if (!url) throw new Error("ticket connect: no pipeline URL configured or provided via --remote");
+
+  console.log(`Connecting to AI Pipeline at ${url} ...`);
+  const success = await syncToPipeline(url, { action: "ping", timestamp: new Date().toISOString() });
+  if (success) {
+    console.log("SUCCESS: Pipeline is reachable.");
+  } else {
+    console.error("FAILED: Could not connect to pipeline or returned non-OK status.");
+  }
+}
+
 import { updateTicketEntryStatus } from "./cli-ticket-logic.mjs";
 
 export async function runTicketClose(opts) {
@@ -85,6 +166,7 @@ export async function runTicketClose(opts) {
   }
   opts.status = "closed";
   const entry = updateTicketEntryStatus(opts.cwd, opts);
+  syncActiveTicketPointer(opts.cwd);
   console.log(`ticket: closed -> ${entry.topic} (${entry.path})`);
 }
 
@@ -117,45 +199,7 @@ export async function runTicketUse(opts) {
   }
 }
 
-import { getLegacyMigrationCandidate, parseLegacyTicketMeta } from "./cli-ticket-logic.mjs";
 
-export async function runTicketMigrate(opts) {
-  const candidate = getLegacyMigrationCandidate(opts.cwd);
-  if (!candidate) {
-    console.log("ticket: no legacy LATEST.md migration candidate found");
-    return;
-  }
-
-  const { title, group, project } = parseLegacyTicketMeta(candidate.body);
-  const topic = toSlug(title);
-  const stamp = Date.now();
-  const relPath = join(TICKET_DIR_NAME, group, `${topic}-${stamp}.md`);
-  const absPath = join(opts.cwd, relPath);
-
-  if (opts.dryRun) {
-    console.log("ticket: would migrate -> " + relPath);
-  } else {
-    mkdirSync(dirname(absPath), { recursive: true });
-    const marker = `\n\n<!-- Ticket (repo-relative): ${relPath} -->\n`;
-    writeFileSync(absPath, candidate.body.trimEnd() + marker, "utf8");
-    console.log("ticket: migrated body -> " + relPath);
-
-    appendTicketEntry(opts.cwd, {
-      id: `ticket_migrated_${stamp}`,
-      title,
-      topic,
-      group,
-      project,
-      createdAt: new Date().toISOString(),
-      path: relPath,
-      source: "ticket-migrate",
-    }, opts);
-    if (existsSync(candidate.latestPath)) {
-      unlinkSync(candidate.latestPath);
-      console.log("ticket: deleted legacy LATEST.md");
-    }
-  }
-}
 
 export function pickTicketEntry(opts, indexJson) {
   const rows = [...indexJson.entries].sort((a, b) => String(b.createdAt || "").localeCompare(String(a.createdAt || "")));

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;
+  }
+}